# 4.编译选项

tsconfig.json 是 TypeScript 项目的配置文件。如果一个目录下存在一个 tsconfig.json 文件，那么往往意味着这个目录就是 TypeScript 项目的根目录。

tsconfig.json 包含 TypeScript 编译的相关配置，通过更改编译配置项，我们可以让 TypeScript 编译出 ES6、ES5、node 的代码。

tsconfig.json 重要字段

• files - 设置要编译的文件的名称；
• include - 设置需要进行编译的文件，支持路径模式匹配；
• exclude - 设置无需进行编译的文件，支持路径模式匹配；
• compilerOptions - 设置与编译流程相关的选项。

• 自动编译文件

  • 编译文件时，使用 -w 指令后，TS编译器会自动监视文件的变化，并在文件发生变化时对文件进行重新编译。

  • 示例：

    • tsc xxx.ts -w
      

• 自动编译整个项目

  • 如果直接使用tsc指令，则可以自动将当前项目下的所有ts文件编译为js文件。

  • 但是能直接使用tsc命令的前提时，要先在项目根目录下创建一个ts的配置文件 tsconfig.json

  • tsconfig.json是一个JSON文件，添加配置文件后，只需只需 tsc 命令即可完成对整个项目的编译

  • 配置选项：

    • include

      • 定义希望被编译文件所在的目录

      • 默认值：["**/*"]

      • 示例：

        • "include":["src/**/*", "tests/**/*"]
          

        • 上述示例中，所有src目录和tests目录下的文件都会被编译

    • exclude

      • 定义需要排除在外的目录

      • 默认值：["node_modules", "bower_components", "jspm_packages"]

      • 示例：

        • "exclude": ["./src/hello/**/*"]
          

        • 上述示例中，src下hello目录下的文件都不会被编译

    • extends

      • 定义被继承的配置文件

      • 示例：

        • "extends": "./configs/base"
          

        • 上述示例中，当前配置文件中会自动包含config目录下base.json中的所有配置信息

    • files

      • 指定被编译文件的列表，只有需要编译的文件少时才会用到

      • 示例：

        • "files": [
              "core.ts",
              "sys.ts",
              "types.ts",
              "scanner.ts",
              "parser.ts",
              "utilities.ts",
              "binder.ts",
              "checker.ts",
              "tsc.ts"
            ]
          

        • 列表中的文件都会被TS编译器所编译

      • compilerOptions

        • 编译选项是配置文件中非常重要也比较复杂的配置选项

        • 在compilerOptions中包含多个子选项，用来完成对编译的配置

          • 项目选项

            • target

              • 设置ts代码编译的目标版本

              • 可选值：

                • ES3（默认）、ES5、ES6/ES2015、ES7/ES2016、ES2017、ES2018、ES2019、ES2020、ESNext

              • 示例：

                • "compilerOptions": {
                      "target": "ES6"
                  }
                  

                • 如上设置，我们所编写的ts代码将会被编译为ES6版本的js代码

            • lib

              • 指定代码运行时所包含的库（宿主环境）

              • 可选值：

                • ES5、ES6/ES2015、ES7/ES2016、ES2017、ES2018、ES2019、ES2020、ESNext、DOM、WebWorker、ScriptHost ......

              • 示例：

                • "compilerOptions": {
                      "target": "ES6",
                      "lib": ["ES6", "DOM"],
                      "outDir": "dist",
                      "outFile": "dist/aa.js"
                  }
                  

            • module

              • 设置编译后代码使用的模块化系统

              • 可选值：

                • CommonJS、UMD、AMD、System、ES2020、ESNext、None

              • 示例：

                • "compilerOptions": {
                      "module": "CommonJS"
                  }
                  

            • outDir

              • 编译后文件的所在目录

              • 默认情况下，编译后的js文件会和ts文件位于相同的目录，设置outDir后可以改变编译后文件的位置

              • 示例：

                • "compilerOptions": {
                      "outDir": "dist"
                  }
                  

                • 设置后编译后的js文件将会生成到dist目录

            • outFile

              • 将所有的文件编译为一个js文件

              • 默认会将所有的编写在全局作用域中的代码合并为一个js文件，如果module制定了None、System或AMD则会将模块一起合并到文件之中

              • 示例：

                • "compilerOptions": {
                      "outFile": "dist/app.js"
                  }
                  

            • rootDir

              • 指定代码的根目录，默认情况下编译后文件的目录结构会以最长的公共目录为根目录，通过rootDir可以手动指定根目录

              • 示例：

                • "compilerOptions": {
                      "rootDir": "./src"
                  }
                  

            • allowJs

              • 是否对js文件编译

            • checkJs

              • 是否对js文件进行检查

              • 示例：

                • "compilerOptions": {
                      "allowJs": true,
                      "checkJs": true
                  }
                  

            • removeComments

              • 是否删除注释
              • 默认值：false

            • noEmit

              • 不对代码进行编译
              • 默认值：false

            • sourceMap

              • 是否生成sourceMap
              • 默认值：false

          • 严格检查

            • strict
              • 启用所有的严格检查，默认值为true，设置后相当于开启了所有的严格检查
            • alwaysStrict
              • 总是以严格模式对代码进行编译
            • noImplicitAny
              • 禁止隐式的any类型
            • noImplicitThis
              • 禁止类型不明确的this(比如函数时window调用)
            • strictBindCallApply
              • 严格检查bind、call和apply的参数列表
            • strictFunctionTypes
              • 严格检查函数的类型
            • strictNullChecks
              • 严格的空值检查
            • strictPropertyInitialization
              • 严格检查属性是否初始化

          • 额外检查

            • noFallthroughCasesInSwitch
              • 检查switch语句包含正确的break
            • noImplicitReturns
              • 检查函数没有隐式的返回值
            • noUnusedLocals
              • 检查未使用的局部变量
            • noUnusedParameters
              • 检查未使用的参数

          • 高级

            • allowUnreachableCode
              • 检查不可达代码
              • 可选值：
                • true，忽略不可达代码
                • false，不可达代码将引起错误
            • noEmitOnError
              • 有错误的情况下不进行编译
              • 默认值：false

超哥的compilerOptions 选项

{
/*
  tsconfig.json是ts编译器的配置文件，ts编译器可以根据它的信息来对代码进行编译
    "include" 用来指定哪些ts文件需要被编译
      路径：** 表示任意目录
            * 表示任意文件
    "exclude" 不需要被编译的文件目录
        默认值：["node_modules", "bower_components", "jspm_packages"]

*/
  "include": [
    "./src/**/*"
  ],
//  "exclude": [
//    "./src/hello/**/*"
//  ]

  /*
    compilerOptions 编译器的选项
  */
  "compilerOptions": {

    // target 用来指定ts被编译为的ES的版本
    // 'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext'
    "target": "es2015",
    // module 指定要使用的模块化的规范
    // 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'es2020', 'esnext'
    "module": "es2015",
    // lib用来指定项目中要使用的库(默认即可)
//    "lib": []
    // outDir 用来指定编译后文件所在的目录
    "outDir": "./dist",
    // 将代码合并为一个文件
    // 设置outFile后，所有的全局作用域中的代码会合并到同一个文件中
    //"outFile": "./dist/app.js"

    // 是否对js文件进行编译，默认是false
//    "allowJs": true,
    // 是否检查js代码是否符合语法规范，默认是false
//    "checkJs": true,
    // 是否移除注释
    "removeComments": true,
    // 不生成编译后的文件
    "noEmit": false,


    // 当有错误时不生成编译后的文件
    "noEmitOnError": true,

    // 所有严格检查的总开关
    "strict": true,

    // 用来设置编译后的文件是否使用严格模式，默认false
    "alwaysStrict": true,

    // 不允许隐式的any类型
    "noImplicitAny": true,

    // 不允许不明确类型的this
    "noImplicitThis": true,

    // 严格的检查空值
    "strictNullChecks": true

  }
}

网上找的compilerOptions 选项

{
  "compilerOptions": {
  
    /* 基本选项 */
    "target": "es5",                       // 指定 ECMAScript 目标版本: 'ES3' (default), 'ES5', 'ES6'/'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'
    "module": "commonjs",                  // 指定使用模块: 'commonjs', 'amd', 'system', 'umd' or 'es2015'
    "lib": [],                             // 指定要包含在编译中的库文件
    "allowJs": true,                       // 允许编译 javascript 文件
    "checkJs": true,                       // 报告 javascript 文件中的错误
    "jsx": "preserve",                     // 指定 jsx 代码的生成: 'preserve', 'react-native', or 'react'
    "declaration": true,                   // 生成相应的 '.d.ts' 文件
    "sourceMap": true,                     // 生成相应的 '.map' 文件
    "outFile": "./",                       // 将输出文件合并为一个文件
    "outDir": "./",                        // 指定输出目录
    "rootDir": "./",                       // 用来控制输出目录结构 --outDir.
    "removeComments": true,                // 删除编译后的所有的注释
    "noEmit": true,                        // 不生成输出文件
    "importHelpers": true,                 // 从 tslib 导入辅助工具函数
    "isolatedModules": true,               // 将每个文件做为单独的模块 （与 'ts.transpileModule' 类似）.

    /* 严格的类型检查选项 */
    "strict": true,                        // 启用所有严格类型检查选项
    "noImplicitAny": true,                 // 在表达式和声明上有隐含的 any类型时报错
    "strictNullChecks": true,              // 启用严格的 null 检查
    "noImplicitThis": true,                // 当 this 表达式值为 any 类型的时候，生成一个错误
    "alwaysStrict": true,                  // 以严格模式检查每个模块，并在每个文件里加入 'use strict'

    /* 额外的检查 */
    "noUnusedLocals": true,                // 有未使用的变量时，抛出错误
    "noUnusedParameters": true,            // 有未使用的参数时，抛出错误
    "noImplicitReturns": true,             // 并不是所有函数里的代码都有返回值时，抛出错误
    "noFallthroughCasesInSwitch": true,    // 报告 switch 语句的 fallthrough 错误。（即，不允许 switch 的 case 语句贯穿）

    /* 模块解析选项 */
    "moduleResolution": "node",            // 选择模块解析策略： 'node' (Node.js) or 'classic' (TypeScript pre-1.6)
    "baseUrl": "./",                       // 用于解析非相对模块名称的基目录
    "paths": {},                           // 模块名到基于 baseUrl 的路径映射的列表
    "rootDirs": [],                        // 根文件夹列表，其组合内容表示项目运行时的结构内容
    "typeRoots": [],                       // 包含类型声明的文件列表
    "types": [],                           // 需要包含的类型声明文件名列表
    "allowSyntheticDefaultImports": true,  // 允许从没有设置默认导出的模块中默认导入。

    /* Source Map Options */
    "sourceRoot": "./",                    // 指定调试器应该找到 TypeScript 文件而不是源文件的位置
    "mapRoot": "./",                       // 指定调试器应该找到映射文件而不是生成文件的位置
    "inlineSourceMap": true,               // 生成单个 soucemaps 文件，而不是将 sourcemaps 生成不同的文件
    "inlineSources": true,                 // 将代码与 sourcemaps 生成到一个文件中，要求同时设置了 --inlineSourceMap 或 --sourceMap 属性

    /* 其他选项 */
    "experimentalDecorators": true,        // 启用装饰器
    "emitDecoratorMetadata": true          // 为装饰器提供元数据的支持
  }
}

# 5.webpack配置

# 5.1 项目基本配置

• 通常情况下，实际开发中我们都需要使用构建工具对代码进行打包，TS同样也可以结合构建工具一起使用，下边以webpack为例介绍一下如何结合构建工具使用TS。

• 步骤：

  1. 初始化项目

     • 进入项目根目录，执行命令 npm init -y
       • 主要作用：创建package.json文件

  2. 下载构建工具

     • npm i -D webpack webpack-cli webpack-dev-server typescript ts-loader clean-webpack-plugin
       • 共安装了7个包
         • webpack
           • 构建工具webpack
         • webpack-cli
           • webpack的命令行工具
         • webpack-dev-server
           • webpack的开发服务器
         • typescript
           • ts编译器
         • ts-loader
           • ts加载器，用于在webpack中编译ts文件
         • html-webpack-plugin
           • webpack中html插件，用来自动创建html文件
         • clean-webpack-plugin
           • webpack中的清除插件，每次构建都会先清除目录

  3. 根目录下创建webpack的配置文件webpack.config.js

     • // 引入一个包
       const path = require('path');
       // 引入html插件
       const HTMLWebpackPlugin = require('html-webpack-plugin');
       
       // webpack中的所有的配置信息都应该写在module.exports中
       module.exports = {
       
           // 指定入口文件
           entry: "./src/index.ts",
       
           // 指定打包文件所在目录
           output: {
               // 指定打包文件的目录
               path: path.resolve(__dirname, 'dist'),
               // 打包后文件的文件
               filename: "bundle.js",
       
               // 告诉webpack不使用箭头
               environment:{
                   arrowFunction: false
               },
               
               clean:true
           },
       
           // 指定webpack打包时要使用模块
           module: {
               // 指定要加载的规则
               rules: [
                   {
                       // test指定的是规则生效的文件
                       test: /\.ts$/,
                       // 要使用的loader
                       use: [
                            // 配置babel
                            {
                                // 指定加载器
                                loader:"babel-loader",
                                // 设置babel
                                options: {
                                    // 设置预定义的环境
                                    presets:[
                                        [
                                            // 指定环境的插件
                                            "@babel/preset-env",
                                            // 配置信息
                                            {
                                                // 要兼容的目标浏览器
                                                targets:{
                                                    "chrome":"58",
                                                    "ie":"11"
                                                },
                                                // 指定corejs的版本
                                                "corejs":"3",
                                                // 使用corejs的方式 "usage" 表示按需加载
                                                "useBuiltIns":"usage"
                                            }
                                        ]
                                    ]
                                }
                            },
                           'ts-loader'
                       ],
                       // 要排除的文件
                       exclude: /node-modules/
                   }
               ]
           },
       
           // 配置Webpack插件
           plugins: [
               new HTMLWebpackPlugin({
                   // title: "这是一个自定义的title"
                   template: "./src/index.html"
               }),
           ],
       
           // 用来设置引用模块
           resolve: {
               extensions: ['.ts', '.js']
           }
       
       };
       

  4. 根目录下创建tsconfig.json，配置可以根据自己需要

     • {
           "compilerOptions": {
               "target": "ES2015",
               "module": "ES2015",
               "strict": true
           }
       }
       

  5. 修改package.json添加如下配置

     • {
         ...略...
         "scripts": {
           "test": "echo \"Error: no test specified\" && exit 1",
           "build": "webpack",
           "start": "webpack serve --open chrome.exe"
         },
         ...略...
       }
       

  6. 在src下创建ts文件，并在并命令行执行npm run build对代码进行编译，或者执行npm start来启动开发服务器

# 5.2 Babel配置

• 经过一系列的配置，使得TS和webpack已经结合到了一起，除了webpack，开发中还经常需要结合babel来对代码进行转换以使其可以兼容到更多的浏览器，在上述步骤的基础上，通过以下步骤再将babel引入到项目中。

  1. 安装依赖包：

     • npm i -D @babel/core @babel/preset-env babel-loader core-js
     • 共安装了4个包，分别是：
       • @babel/core
         • babel的核心工具
       • @babel/preset-env
         • babel的预定义环境
       • @babel-loader
         • babel在webpack中的加载器
       • core-js
         • core-js用来使老版本的浏览器支持新版ES语法

  2. 修改webpack.config.js配置文件

     • ...略...
       module: {
           rules: [
               {
                   test: /\.ts$/,
                   use: [
                       {
                           loader: "babel-loader",
                           options:{
                               presets: [
                                   [
                                       "@babel/preset-env",
                                       {
                                           "targets":{
                                               "chrome": "58",
                                               "ie": "11"
                                           },
                                           "corejs":"3",
                                           "useBuiltIns": "usage"
                                       }
                                   ]
                               ]
                           }
                       },
                       {
                           loader: "ts-loader",
       
                       }
                   ],
                   exclude: /node_modules/
               }
           ]
       }
       ...略...
       

     • 如此一来，使用ts编译后的文件将会再次被babel处理，使得代码可以在大部分浏览器中直接使用，可以在配置选项的targets中指定要兼容的浏览器版本。