指定要包含在程序中的文件白名单。如果找不到任何文件，则会发生错误。

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

当您只有少量文件并且不需要使用 glob 来引用许多文件时，这很有用。如果您需要这样做，请使用 include。

extends 的值是一个字符串，包含指向另一个要继承的配置文件的路径。该路径可以使用 Node.js 风格的解析。

首先加载来自基本文件的配置，然后由继承配置中的配置覆盖。在配置文件中找到的所有相对路径将相对于它们起源的配置文件解析。

值得注意的是，来自继承配置文件的 files、include 和 exclude 会覆盖来自基本配置文件的那些，并且不允许配置文件之间的循环引用。

目前，唯一从继承中排除的顶级属性是 references。

示例

configs/base.json:

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true
  }
}

tsconfig.json:

{
  "extends": "./configs/base",
  "files": ["main.ts", "supplemental.ts"]
}

tsconfig.nostrictnull.json:

{
  "extends": "./tsconfig",
  "compilerOptions": {
    "strictNullChecks": false
  }
}

在配置文件中找到的具有相对路径的属性（不从继承中排除）将相对于它们起源的配置文件解析。

指定要包含在程序中的文件名或模式数组。这些文件名相对于包含 tsconfig.json 文件的目录解析。

json
{
  "include": ["src/**/*", "tests/**/*"]
}

这将包括

.
├── scripts                ⨯
│   ├── lint.ts            ⨯
│   ├── update_deps.ts     ⨯
│   └── utils.ts           ⨯
├── src                    ✓
│   ├── client             ✓
│   │    ├── index.ts      ✓
│   │    └── utils.ts      ✓
│   ├── server             ✓
│   │    └── index.ts      ✓
├── tests                  ✓
│   ├── app.test.ts        ✓
│   ├── utils.ts           ✓
│   └── tests.d.ts         ✓
├── package.json
├── tsconfig.json
└── yarn.lock

include 和 exclude 支持通配符以创建 glob 模式

• * 匹配零个或多个字符（不包括目录分隔符）
• ? 匹配任何一个字符（不包括目录分隔符）
• **/ 匹配任何嵌套到任何级别的目录

如果模式中的最后一个路径段不包含文件扩展名或通配符，则它被视为目录，并且该目录中具有支持扩展名的文件将被包含（例如，默认情况下为 .ts、.tsx 和 .d.ts，如果 allowJs 设置为 true，则为 .js 和 .jsx）。

指定在解析 include 时应跳过的文件名或模式数组。

重要：exclude 仅 更改由于 include 设置而包含的文件。由 exclude 指定的文件仍然可能由于代码中的 import 语句、types 包含、/// <reference 指令或在 files 列表中指定而成为代码库的一部分。

它不是一种阻止文件包含在代码库中的机制 - 它只是更改了 include 设置找到的内容。

项目引用是将 TypeScript 程序分解成更小部分的一种方式。使用项目引用可以极大地改善构建和编辑器交互时间，强制执行组件之间的逻辑分离，并以新的改进方式组织代码。

您可以在手册的 项目引用 部分阅读有关引用工作原理的更多信息。

当

• undefined（默认）向编辑器提供建议作为警告
• true 忽略无法访问的代码
• false 针对无法访问的代码引发编译器错误

这些警告只针对由于使用 JavaScript 语法而被证明无法访问的代码，例如

ts
function fn(n: number) {
  if (n > 5) {
    return true;
  } else {
    return false;
  }
  return true;
}

使用 "allowUnreachableCode": false

ts
function fn(n: number) {
  if (n > 5) {
    return true;
  } else {
    return false;
  }
  return true;
Unreachable code detected.7027Unreachable code detected.
}Try

这不会影响由于类型分析而看起来无法访问的代码的错误。

当

• undefined（默认）向编辑器提供建议作为警告
• true 忽略未使用的标签
• false 针对未使用的标签引发编译器错误

标签在 JavaScript 中非常罕见，通常表示尝试编写对象字面量

ts
function verifyAge(age: number) {
  // Forgot 'return' statement
  if (age > 18) {
    verified: true;
Unused label.7028Unused label.
  }
}Try

确保您的文件在 ECMAScript 严格模式下解析，并为每个源文件发出“use strict”。

ECMAScript 严格 模式在 ES5 中引入，它对 JavaScript 引擎的运行时提供行为调整以提高性能，并使一组错误抛出而不是静默忽略它们。

启用 exactOptionalPropertyTypes 后，TypeScript 会对处理 type 或 interfaces 上带有 ? 前缀的属性的方式应用更严格的规则。

例如，此接口声明存在一个属性，该属性可以是两个字符串之一：“dark”或“light”，或者它不应该在对象中。

ts
interface UserDefaults {
  // The absence of a value represents 'system'
  colorThemeOverride?: "dark" | "light";
}

在未启用此标志的情况下，您可以将 colorThemeOverride 设置为三个值：“dark”、“light”和 undefined。

将值设置为 undefined 将允许大多数 JavaScript 运行时检查存在失败，这实际上是假的。但是，这并不完全准确；colorThemeOverride: undefined 与 colorThemeOverride 未定义不同。例如，"colorThemeOverride" in settings 在 undefined 作为键与未定义相比将具有不同的行为。

exactOptionalPropertyTypes 使 TypeScript 真正强制执行作为可选属性提供的定义

ts
const settings = getUserSettings();
settings.colorThemeOverride = "dark";
settings.colorThemeOverride = "light";
 
// But not:
settings.colorThemeOverride = undefined;
Type 'undefined' is not assignable to type '"dark" | "light"' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target.2412Type 'undefined' is not assignable to type '"dark" | "light"' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target.Try

报告 switch 语句中贯穿情况的错误。确保 switch 语句中的任何非空 case 都包含 break、return 或 throw。这意味着您不会意外地发布贯穿情况错误。

ts
const a: number = 6;
 
switch (a) {
  case 0:
Fallthrough case in switch.7029Fallthrough case in switch.
    console.log("even");
  case 1:
    console.log("odd");
    break;
}Try

在某些情况下，如果不存在类型注释，TypeScript 将在无法推断类型时将变量的类型回退到 any。

这可能会导致一些错误被忽略，例如

ts
function fn(s) {
  // No error?
  console.log(s.subtr(3));
}
fn(42);Try

启用 noImplicitAny，TypeScript 将在推断出 any 时发出错误。

ts
function fn(s) {
Parameter 's' implicitly has an 'any' type.7006Parameter 's' implicitly has an 'any' type.
  console.log(s.subtr(3));
}Try

在使用继承的类中工作时，子类可能会与它重载的函数“不同步”，当这些函数在基类中被重命名时。

例如，假设您正在模拟一个音乐专辑同步系统。

ts
class Album {
  download() {
    // Default behavior
  }
}
 
class SharedAlbum extends Album {
  download() {
    // Override to get info from many sources
  }
}Try

然后，当您添加对机器学习生成的播放列表的支持时，您将重构 Album 类以使用“setup”函数代替。

ts
class Album {
  setup() {
    // Default behavior
  }
}
 
class MLAlbum extends Album {
  setup() {
    // Override to get info from algorithm
  }
}
 
class SharedAlbum extends Album {
  download() {
    // Override to get info from many sources
  }
}Try

在这种情况下，TypeScript 没有发出警告，表明 SharedAlbum 上的 download 预期 覆盖基类中的函数。

使用 noImplicitOverride，您可以确保子类永远不会不同步，方法是确保覆盖函数包含 override 关键字。

以下示例启用了 noImplicitOverride，您可以看到当缺少 override 时收到的错误。

ts
class Album {
  setup() {}
}
 
class MLAlbum extends Album {
  override setup() {}
}
 
class SharedAlbum extends Album {
  setup() {}
This member must have an 'override' modifier because it overrides a member in the base class 'Album'.4114This member must have an 'override' modifier because it overrides a member in the base class 'Album'.
}Try

启用后，TypeScript 将检查函数中的所有代码路径，以确保它们返回一个值。

ts
function lookupHeadphonesManufacturer(color: "blue" | "black"): string {
Function lacks ending return statement and return type does not include 'undefined'.2366Function lacks ending return statement and return type does not include 'undefined'.
  if (color === "blue") {
    return "beats";
  } else {
    "bose";
  }
}Try

对具有隐式 'any' 类型的 'this' 表达式引发错误。

例如，下面的类返回一个函数，该函数尝试访问 this.width 和 this.height - 但 getAreaFunction 中函数内部的 this 上下文不是 Rectangle 的实例。

ts
class Rectangle {
  width: number;
  height: number;
 
  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }
 
  getAreaFunction() {
    return function () {
      return this.width * this.height;
'this' implicitly has type 'any' because it does not have a type annotation.
'this' implicitly has type 'any' because it does not have a type annotation.2683
2683'this' implicitly has type 'any' because it does not have a type annotation.
'this' implicitly has type 'any' because it does not have a type annotation.
    };
  }
}Try

此设置确保通过“点”(obj.key) 语法和“索引”(obj["key"]) 访问字段之间的一致性，以及在类型中声明属性的方式。

没有此标志，TypeScript 将允许您使用点语法访问未定义的字段。

ts
interface GameSettings {
  // Known up-front properties
  speed: "fast" | "medium" | "slow";
  quality: "high" | "low";
 
  // Assume anything unknown to the interface
  // is a string.
  [key: string]: string;
}
 
const settings = getSettings();
settings.speed;
          
(property) GameSettings.speed: "fast" | "medium" | "slow"
settings.quality;
           
(property) GameSettings.quality: "high" | "low"
 
// Unknown key accessors are allowed on
// this object, and are `string`
settings.username;
            
(index) GameSettings[string]: stringTry

启用此标志将引发错误，因为未知字段使用点语法而不是索引语法。

ts
const settings = getSettings();
settings.speed;
settings.quality;
 
// This would need to be settings["username"];
settings.username;
Property 'username' comes from an index signature, so it must be accessed with ['username'].4111Property 'username' comes from an index signature, so it must be accessed with ['username'].
            
(index) GameSettings[string]: stringTry

此标志的目的是在您的调用语法中表明您对该属性是否存在有多确定。

TypeScript 有一种方法可以使用索引签名来描述具有未知键但已知值的 对象。

ts
interface EnvironmentVars {
  NAME: string;
  OS: string;
 
  // Unknown properties are covered by this index signature.
  [propName: string]: string;
}
 
declare const env: EnvironmentVars;
 
// Declared as existing
const sysName = env.NAME;
const os = env.OS;
      
const os: string
 
// Not declared, but because of the index
// signature, then it is considered a string
const nodeEnv = env.NODE_ENV;
        
const nodeEnv: stringTry

启用 noUncheckedIndexedAccess 将在类型中为任何未声明的字段添加 undefined。

ts
declare const env: EnvironmentVars;
 
// Declared as existing
const sysName = env.NAME;
const os = env.OS;
      
const os: string
 
// Not declared, but because of the index
// signature, then it is considered a string
const nodeEnv = env.NODE_ENV;
        
const nodeEnv: string | undefinedTry

报告未使用的局部变量的错误。

ts
const createKeyboard = (modelID: number) => {
  const defaultModelID = 23;
'defaultModelID' is declared but its value is never read.6133'defaultModelID' is declared but its value is never read.
  return { type: "keyboard", modelID };
};Try

报告函数中未使用的参数的错误。

ts
const createDefaultKeyboard = (modelID: number) => {
'modelID' is declared but its value is never read.6133'modelID' is declared but its value is never read.
  const defaultModelID = 23;
  return { type: "keyboard", modelID: defaultModelID };
};Try

strict 标志启用了一系列类型检查行为，这些行为可以提供更强的程序正确性保证。启用此标志等效于启用所有 *严格模式系列* 选项，这些选项在下面概述。然后，您可以根据需要关闭各个严格模式系列检查。

TypeScript 的未来版本可能会在此标志下引入更严格的检查，因此升级 TypeScript 可能会导致程序中出现新的类型错误。在适当且可能的情况下，将添加相应的标志来禁用该行为。

启用后，TypeScript 将检查函数的内置方法 call、bind 和 apply 是否以正确的参数调用了底层函数。

ts
// With strictBindCallApply on
function fn(x: string) {
  return parseInt(x);
}
 
const n1 = fn.call(undefined, "10");
 
const n2 = fn.call(undefined, false);
Argument of type 'boolean' is not assignable to parameter of type 'string'.2345Argument of type 'boolean' is not assignable to parameter of type 'string'.Try

否则，这些函数将接受任何参数并返回 any。

ts
// With strictBindCallApply off
function fn(x: string) {
  return parseInt(x);
}
 
// Note: No error; return type is 'any'
const n = fn.call(undefined, false);Try

启用此标志后，将更准确地检查函数参数。

以下是一个 strictFunctionTypes 关闭时的基本示例

ts
function fn(x: string) {
  console.log("Hello, " + x.toLowerCase());
}
 
type StringOrNumberFunc = (ns: string | number) => void;
 
// Unsafe assignment
let func: StringOrNumberFunc = fn;
// Unsafe call - will crash
func(10);Try

当 strictFunctionTypes 开启时，错误会被正确检测到

ts
function fn(x: string) {
  console.log("Hello, " + x.toLowerCase());
}
 
type StringOrNumberFunc = (ns: string | number) => void;
 
// Unsafe assignment is prevented
let func: StringOrNumberFunc = fn;
Type '(x: string) => void' is not assignable to type 'StringOrNumberFunc'.
  Types of parameters 'x' and 'ns' are incompatible.
    Type 'string | number' is not assignable to type 'string'.
      Type 'number' is not assignable to type 'string'.2322Type '(x: string) => void' is not assignable to type 'StringOrNumberFunc'.
  Types of parameters 'x' and 'ns' are incompatible.
    Type 'string | number' is not assignable to type 'string'.
      Type 'number' is not assignable to type 'string'.Try

在开发此功能期间，我们发现大量本质上不安全的类层次结构，包括 DOM 中的一些。因此，此设置仅适用于以 函数 语法编写的函数，而不适用于以 方法 语法编写的函数。

ts
type Methodish = {
  func(x: string | number): void;
};
 
function fn(x: string) {
  console.log("Hello, " + x.toLowerCase());
}
 
// Ultimately an unsafe assignment, but not detected
const m: Methodish = {
  func: fn,
};
m.func(10);Try

当 strictNullChecks 为 false 时，null 和 undefined 会被语言有效地忽略。这会导致运行时出现意外错误。

当 strictNullChecks 为 true 时，null 和 undefined 具有各自的类型，并且如果您尝试在需要具体值的地方使用它们，您将收到类型错误。

例如，对于以下 TypeScript 代码，users.find 无法保证它会真正找到用户，但您可以像它会找到一样编写代码

ts
declare const loggedInUsername: string;
 
const users = [
  { name: "Oby", age: 12 },
  { name: "Heera", age: 32 },
];
 
const loggedInUser = users.find((u) => u.name === loggedInUsername);
console.log(loggedInUser.age);Try

将 strictNullChecks 设置为 true 将引发错误，因为您没有保证 loggedInUser 存在，然后再尝试使用它。

ts
declare const loggedInUsername: string;
 
const users = [
  { name: "Oby", age: 12 },
  { name: "Heera", age: 32 },
];
 
const loggedInUser = users.find((u) => u.name === loggedInUsername);
console.log(loggedInUser.age);
'loggedInUser' is possibly 'undefined'.18048'loggedInUser' is possibly 'undefined'.Try

第二个示例失败是因为数组的 find 函数看起来有点像这种简化

ts
// When strictNullChecks: true
type Array = {
  find(predicate: (value: any, index: number) => boolean): S | undefined;
};
// When strictNullChecks: false the undefined is removed from the type system,
// allowing you to write code which assumes it always found a result
type Array = {
  find(predicate: (value: any, index: number) => boolean): S;
};

当设置为 true 时，TypeScript 会在类属性被声明但在构造函数中未设置时引发错误。

ts
class UserAccount {
  name: string;
  accountType = "user";
 
  email: string;
Property 'email' has no initializer and is not definitely assigned in the constructor.2564Property 'email' has no initializer and is not definitely assigned in the constructor.
  address: string | undefined;
 
  constructor(name: string) {
    this.name = name;
    // Note that this.email is not set
  }
}Try

在上面的例子中

• this.name 被专门设置。
• this.accountType 被默认设置。
• this.email 未设置，并引发错误。
• this.address 被声明为可能为 undefined，这意味着它不必被设置。

在 TypeScript 4.0 中，添加了支持，允许将 catch 子句中变量的类型从 any 更改为 unknown。允许使用以下代码

ts
try {
  // ...
} catch (err) {
  // We have to verify err is an
  // error before using it as one.
  if (err instanceof Error) {
    console.log(err.message);
  }
}Try

这种模式确保错误处理代码变得更加全面，因为您无法保证抛出的对象是 Error 子类。启用标志 useUnknownInCatchVariables 后，您不需要额外的语法 (: unknown) 也不需要 linter 规则来尝试强制执行此行为。

在 TypeScript 5.0 中，当导入路径以非已知 JavaScript 或 TypeScript 文件扩展名结尾时，编译器将以 {file basename}.d.{extension}.ts 的形式查找该路径的声明文件。例如，如果您在捆绑器项目中使用 CSS 加载器，您可能希望为这些样式表编写（或生成）声明文件

css
/* app.css */
.cookie-banner {
  display: none;
}

ts
// app.d.css.ts
declare const css: {
  cookieBanner: string;
};
export default css;

ts
// App.tsx
import styles from "./app.css";
styles.cookieBanner; // string

默认情况下，此导入将引发错误，以告知您 TypeScript 不理解此文件类型，并且您的运行时可能不支持导入它。但是，如果您已配置运行时或捆绑器来处理它，则可以使用新的 --allowArbitraryExtensions 编译器选项来抑制错误。

请注意，从历史上看，通过添加名为 app.css.d.ts 而不是 app.d.css.ts 的声明文件，通常可以实现类似的效果 - 但是，这只是通过 Node 的 require 针对 CommonJS 的解析规则来实现的。严格来说，前者被解释为名为 app.css.js 的 JavaScript 文件的声明文件。由于相对文件导入需要在 Node 的 ESM 支持中包含扩展名，因此 TypeScript 会在 --moduleResolution node16 或 nodenext 下的 ESM 文件中针对我们的示例报错。

有关更多信息，请阅读 此功能的提案 和 其对应的拉取请求。

--allowImportingTsExtensions 允许 TypeScript 文件使用 TypeScript 特定的扩展名（如 .ts、.mts 或 .tsx）相互导入。

此标志仅在启用 --noEmit 或 --emitDeclarationOnly 时才允许，因为这些导入路径在 JavaScript 输出文件中无法在运行时解析。这里的期望是您的解析器（例如您的捆绑器、运行时或其他工具）将使这些 .ts 文件之间的导入正常工作。

当设置为 true 时，allowUmdGlobalAccess 允许您从模块文件内部以全局方式访问 UMD 导出。模块文件是包含导入和/或导出的文件。没有此标志，使用 UMD 模块的导出需要导入声明。

此标志的一个示例用例是 Web 项目，您知道特定库（如 jQuery 或 Lodash）始终在运行时可用，但您无法使用导入来访问它。

设置一个基目录，用于解析裸规范符模块名称。例如，在以下目录结构中

project
├── ex.ts
├── hello
│   └── world.ts
└── tsconfig.json

使用 "baseUrl": "./"，TypeScript 将从与 tsconfig.json 相同的文件夹开始查找文件

ts
import { helloWorld } from "hello/world";
console.log(helloWorld);

此解析优先级高于从 node_modules 中查找。

此功能旨在与浏览器中的 AMD 模块加载器结合使用，不建议在其他任何情况下使用。从 TypeScript 4.1 开始，当使用 paths 时，不再需要设置 baseUrl。

--customConditions 接受一个额外的 条件 列表，这些条件在 TypeScript 从 exports 或 imports 字段解析 package.json 时应该成功。这些条件将添加到解析器默认使用的任何现有条件中。

例如，当在 tsconfig.json 中设置此字段时

jsonc
{
  "compilerOptions": {
    "target": "es2022",
    "moduleResolution": "bundler",
    "customConditions": ["my-condition"]
  }
}

任何时候在 package.json 中引用 exports 或 imports 字段时，TypeScript 将考虑名为 my-condition 的条件。

因此，当从具有以下 package.json 的包导入时

jsonc
{
  // ...
  "exports": {
    ".": {
      "my-condition": "./foo.mjs",
      "node": "./bar.mjs",
      "import": "./baz.mjs",
      "require": "./biz.mjs"
    }
  }
}

TypeScript 将尝试查找与 foo.mjs 对应的文件。

此字段仅在 --moduleResolution 的 node16、nodenext 和 bundler 选项下有效。

设置程序的模块系统。有关更多信息，请参阅 TypeScript 的 module 选项背后的理论 和 其参考页面。对于现代 Node.js 项目，您很可能需要 "nodenext"。

更改 module 会影响 moduleResolution，它也有一个参考页面。

以下是此文件的示例输出

ts
// @filename: index.ts
import { valueOfPi } from "./constants";
 
export const twoPi = valueOfPi * 2;Try

CommonJS

ts
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.twoPi = void 0;
const constants_1 = require("./constants");
exports.twoPi = constants_1.valueOfPi * 2;
 Try

UMD

ts
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "./constants"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.twoPi = void 0;
    const constants_1 = require("./constants");
    exports.twoPi = constants_1.valueOfPi * 2;
});
 Try

AMD

ts
define(["require", "exports", "./constants"], function (require, exports, constants_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.twoPi = void 0;
    exports.twoPi = constants_1.valueOfPi * 2;
});
 Try

System

ts
System.register(["./constants"], function (exports_1, context_1) {
    "use strict";
    var constants_1, twoPi;
    var __moduleName = context_1 && context_1.id;
    return {
        setters: [
            function (constants_1_1) {
                constants_1 = constants_1_1;
            }
        ],
        execute: function () {
            exports_1("twoPi", twoPi = constants_1.valueOfPi * 2);
        }
    };
});
 Try

ESNext

ts
import { valueOfPi } from "./constants";
export const twoPi = valueOfPi * 2;
 Try

ES2015/ES6/ES2020/ES2022

ts
import { valueOfPi } from "./constants";
export const twoPi = valueOfPi * 2;
 Try

除了ES2015/ES6 的基本功能外，ES2020 还支持 动态import 和 import.meta，而 ES2022 进一步支持 顶层await。

node16/nodenext

从 4.7+ 开始，node16 和 nodenext 模式与 Node 的 原生 ECMAScript 模块支持 集成。生成的 JavaScript 使用 CommonJS 或 ES2020 输出，具体取决于文件扩展名和最近的 package.json 中 type 设置的值。模块解析的方式也不同。您可以在 手册 和 模块参考 中了解更多信息。

None

ts
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.twoPi = void 0;
const constants_1 = require("./constants");
exports.twoPi = constants_1.valueOfPi * 2;
 Try

指定模块解析策略

• 对于现代版本的 Node.js，使用 'node16' 或 'nodenext'。Node.js v12 及更高版本支持 ECMAScript 导入和 CommonJS require，它们使用不同的算法进行解析。这些 moduleResolution 值与相应的 module 值结合使用时，会根据 Node.js 在输出 JavaScript 代码中看到 import 或 require 来选择正确的算法。

• 对于低于 v10 的 Node.js 版本，使用 'node10'（以前称为 'node'），这些版本只支持 CommonJS require。在现代代码中，您可能不需要使用 node10。

• 对于打包器，使用 'bundler'。与 node16 和 nodenext 一样，此模式支持 package.json "imports" 和 "exports"，但与 Node.js 解析模式不同，bundler 永远不需要导入中相对路径上的文件扩展名。

  bundler 不支持解析 require 调用。在 TypeScript 文件中，这意味着 import mod = require("foo") 语法是被禁止的；在 JavaScript 文件中，require 调用不会报错，但只会返回 any 类型（或者全局 require 函数的任何环境声明被声明为 return 的类型）。

• 'classic' 在 TypeScript 1.6 版本发布之前使用。classic 不应该再使用。

有参考页面解释了 TypeScript 模块解析背后的理论 以及 每个选项的细节。

提供了一种方法来覆盖在解析模块时搜索的文件名后缀的默认列表。

{
  "compilerOptions": {
    "moduleSuffixes": [".ios", ".native", ""]
  }
}

给定上述配置，以下导入

ts
import * as foo from "./foo";

TypeScript 将查找相对文件 ./foo.ios.ts、./foo.native.ts，最后是 ./foo.ts。

请注意 moduleSuffixes 中的空字符串 ""，这是 TypeScript 也查找 ./foo.ts 所必需的。

此功能对于 React Native 项目很有用，在 React Native 项目中，每个目标平台可以使用具有不同 moduleSuffixes 的单独 tsconfig.json。

默认情况下，TypeScript 将检查初始文件集以查找 import 和 <reference 指令，并将这些解析的文件添加到您的程序中。

如果设置了 noResolve，则此过程不会发生。但是，import 语句仍然会检查以查看它们是否解析为有效的模块，因此您需要确保通过其他方式满足此条件。

一系列条目，如果设置了 baseUrl，则将导入重新映射到相对于 baseUrl 的查找位置，否则重新映射到 tsconfig 文件本身。在 moduleResolution 参考页面 中对 paths 有更广泛的介绍。

paths 允许您声明 TypeScript 应该如何解析 require/import 中的导入。

{
  "compilerOptions": {
    "paths": {
      "jquery": ["./vendor/jquery/dist/jquery"]
    }
  }
}

这将允许您编写 import "jquery"，并获得所有正确的本地类型。

{
  "compilerOptions": {
    "paths": {
        "app/*": ["./src/app/*"],
        "config/*": ["./src/app/_config/*"],
        "environment/*": ["./src/environments/*"],
        "shared/*": ["./src/app/_shared/*"],
        "helpers/*": ["./src/helpers/*"],
        "tests/*": ["./src/tests/*"]
    },
}

在这种情况下，您可以告诉 TypeScript 文件解析器支持许多自定义前缀来查找代码。

请注意，此功能不会更改 tsc 发出的导入路径，因此 paths 仅应用于告知 TypeScript 另一个工具具有此映射，并在运行时或捆绑时使用它。

允许导入扩展名为 .json 的模块，这在 Node 项目中是一种常见做法。这包括根据静态 JSON 形状生成 import 的类型。

TypeScript 默认不支持解析 JSON 文件。

ts
// @filename: settings.json
Cannot find module './settings.json'. Consider using '--resolveJsonModule' to import module with '.json' extension.2732Cannot find module './settings.json'. Consider using '--resolveJsonModule' to import module with '.json' extension.
{
    "repo": "TypeScript",
    "dry": false,
    "debug": false
}
// @filename: index.ts
import settings from "./settings.json";
 
settings.debug === true;
settings.dry === 2;Try

启用此选项允许导入 JSON，并验证该 JSON 文件中的类型。

ts
// @filename: settings.json
{
    "repo": "TypeScript",
    "dry": false,
This comparison appears to be unintentional because the types 'boolean' and 'number' have no overlap.2367This comparison appears to be unintentional because the types 'boolean' and 'number' have no overlap.
    "debug": false
}
// @filename: index.ts
import settings from "./settings.json";
 
settings.debug === true;
settings.dry === 2;Try

--resolvePackageJsonExports 强制 TypeScript 在读取 node_modules 中的包时，始终参考 package.json 文件的 exports 字段。

对于 --moduleResolution 的 node16、nodenext 和 bundler 选项，此选项默认值为 true。

--resolvePackageJsonImports 强制 TypeScript 在执行从包含 package.json 的祖先目录的某个文件开始的查找时，始终参考 package.json 文件的 imports 字段。

对于 --moduleResolution 的 node16、nodenext 和 bundler 选项，此选项默认值为 true。

默认值：所有非声明输入文件的最大公共路径。如果设置了 composite，则默认值为包含 tsconfig.json 文件的目录。

当 TypeScript 编译文件时，它会在输出目录中保留与输入目录中相同的目录结构。

例如，假设您有一些输入文件

MyProj
├── tsconfig.json
├── core
│   ├── a.ts
│   ├── b.ts
│   ├── sub
│   │   ├── c.ts
├── types.d.ts

rootDir 的推断值为所有非声明输入文件的最大公共路径，在本例中为 core/。

如果您的 outDir 为 dist，TypeScript 将写入此树

MyProj
├── dist
│   ├── a.js
│   ├── b.js
│   ├── sub
│   │   ├── c.js

但是，您可能希望将core作为输出目录结构的一部分。通过在tsconfig.json中设置rootDir: "."，TypeScript 将写入此树

MyProj
├── dist
│   ├── core
│   │   ├── a.js
│   │   ├── b.js
│   │   ├── sub
│   │   │   ├── c.js

重要的是，rootDir **不会影响哪些文件成为编译的一部分**。它与include、exclude 或 files tsconfig.json 设置没有交互。

请注意，TypeScript 永远不会将输出文件写入 outDir 之外的目录，也不会跳过发出文件。因此，rootDir 还强制执行所有需要发出的文件都位于 rootDir 路径下。

例如，假设您有以下树

MyProj
├── tsconfig.json
├── core
│   ├── a.ts
│   ├── b.ts
├── helpers.ts

将 rootDir 指定为 core 以及 include 指定为 * 将是一个错误，因为它会创建一个需要在 outDir 之外发出（即 ../helpers.js）的文件（helpers.ts）。

使用 rootDirs，您可以告知编译器存在许多充当单个根的“虚拟”目录。这允许编译器解析这些“虚拟”目录中的相对模块导入，就好像它们合并到一个目录中一样。

例如

 src
 └── views
     └── view1.ts (can import "./template1", "./view2`)
     └── view2.ts (can import "./template1", "./view1`)

 generated
 └── templates
         └── views
             └── template1.ts (can import "./view1", "./view2")

{
  "compilerOptions": {
    "rootDirs": ["src/views", "generated/templates/views"]
  }
}

这不会影响 TypeScript 如何发出 JavaScript，它只模拟了它们能够在运行时通过这些相对路径工作的假设。

rootDirs 可用于为不是 TypeScript 或 JavaScript 的文件提供单独的“类型层”，方法是在另一个文件夹中为生成的 .d.ts 文件提供一个位置。此技术对于捆绑应用程序很有用，在这些应用程序中，您使用不是代码的 import 文件

sh
 src
 └── index.ts
 └── css
     └── main.css
     └── navigation.css
 generated
 └── css
     └── main.css.d.ts
     └── navigation.css.d.ts

{
  "compilerOptions": {
    "rootDirs": ["src", "generated"]
  }
}

此技术允许您提前为非代码源文件生成类型。然后，导入将根据源文件的位置自然地工作。例如，./src/index.ts 可以导入文件 ./src/css/main.css，TypeScript 将通过相应的生成声明文件了解捆绑程序对该文件类型的行为。

ts
// @filename: index.ts
import { appClass } from "./main.css";Try

默认情况下，所有可见的“@types”包都包含在您的编译中。任何包含文件夹中的 node_modules/@types 中的包都被视为可见。例如，这意味着 ./node_modules/@types/、../node_modules/@types/、../../node_modules/@types/ 等文件夹中的包。

如果指定了 typeRoots，则仅包含 typeRoots 下的包。例如

{
  "compilerOptions": {
    "typeRoots": ["./typings", "./vendor/types"]
  }
}

此配置文件将包含 ./typings 和 ./vendor/types 下的所有包，而不会包含来自 ./node_modules/@types 的任何包。所有路径相对于 tsconfig.json。

默认情况下，所有可见的“@types”包都包含在您的编译中。任何包含文件夹中的 node_modules/@types 中的包都被视为可见。例如，这意味着 ./node_modules/@types/、../node_modules/@types/、../../node_modules/@types/ 等文件夹中的包。

如果指定了 types，则仅包含列出的包将包含在全局范围内。例如

{
  "compilerOptions": {
    "types": ["node", "jest", "express"]
  }
}

此 tsconfig.json 文件将仅包含 ./node_modules/@types/node、./node_modules/@types/jest 和 ./node_modules/@types/express。node_modules/@types/* 下的其他包将不会被包含。

此选项会影响什么？

此选项不会影响 @types/* 如何包含在您的应用程序代码中，例如，如果您有上述 compilerOptions 示例，代码如下

ts
import * as moment from "moment";
moment().format("MMMM Do YYYY, h:mm:ss a");

moment 导入将被完全类型化。

当您设置此选项时，通过不将模块包含在 types 数组中，它

• 不会向您的项目添加全局变量（例如，节点中的 process 或 Jest 中的 expect）
• 不会将导出显示为自动导入建议

此功能与 typeRoots 不同，它只指定要包含的精确类型，而 typeRoots 支持指定要包含的特定文件夹。

为项目中的每个 TypeScript 或 JavaScript 文件生成 .d.ts 文件。这些 .d.ts 文件是类型定义文件，描述了模块的外部 API。使用 .d.ts 文件，像 TypeScript 这样的工具可以为未类型化的代码提供智能感知和准确的类型。

当 declaration 设置为 true 时，使用此 TypeScript 代码运行编译器

ts
export let helloWorld = "hi";Try

将生成一个像这样的 index.js 文件

ts
export let helloWorld = "hi";
 Try

以及相应的 helloWorld.d.ts

ts
export declare let helloWorld: string;
 Try

在使用 JavaScript 文件的 .d.ts 文件时，您可能需要使用 emitDeclarationOnly 或使用 outDir 来确保 JavaScript 文件不被覆盖。

提供了一种配置声明文件发出位置的根目录的方法。

example
├── index.ts
├── package.json
└── tsconfig.json

使用此 tsconfig.json

{
  "compilerOptions": {
    "declaration": true,
    "declarationDir": "./types"
  }
}

将把 index.ts 的 d.ts 放置在 types 文件夹中

example
├── index.js
├── index.ts
├── package.json
├── tsconfig.json
└── types
    └── index.d.ts

为 .d.ts 文件生成源映射，这些源映射映射回原始 .ts 源文件。这将允许像 VS Code 这样的编辑器在使用“转到定义”等功能时转到原始 .ts 文件。

如果您使用项目引用，强烈建议您启用此选项。

下级转换是 TypeScript 用于将代码转换为旧版 JavaScript 的术语。此标志用于启用对更准确实现现代 JavaScript 如何在旧版 JavaScript 运行时中迭代新概念的支持。

ECMAScript 6 添加了几个新的迭代原语：for / of 循环 (for (el of arr))、数组展开 ([a, ...b])、参数展开 (fn(...args)) 和 Symbol.iterator。downlevelIteration 允许在 ES5 环境中更准确地使用这些迭代原语，前提是存在 Symbol.iterator 实现。

示例：对 for / of 的影响

使用以下 TypeScript 代码

ts
const str = "Hello!";
for (const s of str) {
  console.log(s);
}Try

如果未启用 downlevelIteration，则对任何对象的 for / of 循环将被下级转换为传统的 for 循环

ts
"use strict";
var str = "Hello!";
for (var _i = 0, str_1 = str; _i < str_1.length; _i++) {
    var s = str_1[_i];
    console.log(s);
}
 Try

这通常是人们所期望的，但它并不完全符合 ECMAScript 迭代协议。某些字符串，例如表情符号 (😜)，其 .length 为 2（甚至更多！），但在 for-of 循环中应迭代为 1 个单元。有关更详细的说明，请参阅 Jonathan New 的这篇博文。

启用 downlevelIteration 后，TypeScript 将使用一个辅助函数来检查 Symbol.iterator 实现（本机或 polyfill）。如果此实现不存在，您将回退到基于索引的迭代。

ts
"use strict";
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var e_1, _a;
var str = "Hello!";
try {
    for (var str_1 = __values(str), str_1_1 = str_1.next(); !str_1_1.done; str_1_1 = str_1.next()) {
        var s = str_1_1.value;
        console.log(s);
    }
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
    try {
        if (str_1_1 && !str_1_1.done && (_a = str_1.return)) _a.call(str_1);
    }
    finally { if (e_1) throw e_1.error; }
}
 Try

您可以通过 importHelpers 使用 tslib 来减少内联 JavaScript 的数量

ts
"use strict";
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var e_1, _a;
var str = "Hello!";
try {
    for (var str_1 = __values(str), str_1_1 = str_1.next(); !str_1_1.done; str_1_1 = str_1.next()) {
        var s = str_1_1.value;
        console.log(s);
    }
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
    try {
        if (str_1_1 && !str_1_1.done && (_a = str_1.return)) _a.call(str_1);
    }
    finally { if (e_1) throw e_1.error; }
}
 Try

注意：如果运行时中不存在 Symbol.iterator，则启用 downlevelIteration 不会提高兼容性。

示例：数组展开的影响

这是一个数组展开

js
// Make a new array whose elements are 1 followed by the elements of arr2
const arr = [1, ...arr2];

根据描述，它听起来很容易降级到 ES5

js
// The same, right?
const arr = [1].concat(arr2);

但是，在某些罕见情况下，这明显不同。

例如，如果源数组缺少一个或多个项（包含空洞），则展开语法将用undefined替换每个空项，而.concat将保持它们不变。

js
// Make an array where the element at index 1 is missing
let arrayWithHole = ["a", , "c"];
let spread = [...arrayWithHole];
let concatenated = [].concat(arrayWithHole);
console.log(arrayWithHole);
// [ 'a', <1 empty item>, 'c' ]
console.log(spread);
// [ 'a', undefined, 'c' ]
console.log(concatenated);
// [ 'a', <1 empty item>, 'c' ]

就像for / of一样，downlevelIteration将使用Symbol.iterator（如果存在）更准确地模拟 ES 6 行为。

控制 TypeScript 在写入输出文件时是否导出字节顺序标记 (BOM)。一些运行时环境需要 BOM 才能正确解释 JavaScript 文件；其他环境则要求它不存在。默认值为false通常是最好的，除非你有理由更改它。

仅导出.d.ts文件；不要导出.js文件。

此设置在两种情况下很有用

• 您正在使用除 TypeScript 之外的转译器来生成您的 JavaScript。
• 您正在使用 TypeScript 仅为您的消费者生成d.ts文件。

对于某些降级操作，TypeScript 使用一些帮助程序代码来执行扩展类、展开数组或对象以及异步操作等操作。默认情况下，这些帮助程序将插入使用它们的代码文件中。如果在许多不同的模块中使用相同的帮助程序，这会导致代码重复。

如果 importHelpers 标志开启，这些辅助函数将从 tslib 模块导入。您需要确保 tslib 模块能够在运行时被导入。这只会影响模块；全局脚本文件不会尝试导入模块。

例如，使用以下 TypeScript 代码

ts
export function fn(arr: number[]) {
  const arr2 = [1, ...arr];
}

开启 downlevelIteration，但 importHelpers 仍然为 false

ts
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
export function fn(arr) {
    var arr2 = __spreadArray([1], __read(arr), false);
}
 Try

然后同时开启 downlevelIteration 和 importHelpers

ts
import { __read, __spreadArray } from "tslib";
export function fn(arr) {
    var arr2 = __spreadArray([1], __read(arr), false);
}
 Try

当您提供这些函数的自定义实现时，可以使用 noEmitHelpers。

已弃用，建议使用 verbatimModuleSyntax。

此标志控制 import 的工作方式，有 3 种不同的选项

• remove：默认行为是删除仅引用类型的 import 语句。

• preserve：保留所有其值或类型从未使用过的 import 语句。这会导致导入/副作用被保留。

• error：保留所有导入（与 preserve 选项相同），但当值导入仅用作类型时会报错。如果您想确保没有值被意外导入，但仍然使副作用导入显式，这可能很有用。

此标志有效是因为您可以使用 import type 来显式创建永远不会被发射到 JavaScript 中的 import 语句。

设置后，TypeScript 不会写入 .js.map 文件来提供源映射，而是将源映射内容嵌入到 .js 文件中。虽然这会导致更大的 JS 文件，但在某些情况下可能很方便。例如，您可能希望在不允许提供 .map 文件的 Web 服务器上调试 JS 文件。

与 sourceMap 互斥。

例如，使用以下 TypeScript 代码

ts
const helloWorld = "hi";
console.log(helloWorld);

转换为以下 JavaScript 代码

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
 Try

然后启用使用inlineSourceMap构建它，文件底部有一个注释，其中包含该文件的源映射。

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDO0FBQ3hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLENBQUMifQ==Try

设置后，TypeScript 会将.ts 文件的原始内容作为嵌入字符串包含在源映射中（使用源映射的sourcesContent 属性）。这在与inlineSourceMap相同的情况下通常很有用。

需要设置sourceMap 或 inlineSourceMap。

例如，使用以下 TypeScript 代码

ts
const helloWorld = "hi";
console.log(helloWorld);Try

默认情况下转换为以下 JavaScript

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
 Try

然后启用使用inlineSources 和 inlineSourceMap 构建它，文件底部有一个注释，其中包含该文件的源映射。请注意，结尾与 inlineSourceMap 中的示例不同，因为源映射现在还包含原始源代码。

ts
"use strict";
const helloWorld = "hi";
console.log(helloWorld);
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDO0FBQ3hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJjb25zdCBoZWxsb1dvcmxkID0gXCJoaVwiO1xuY29uc29sZS5sb2coaGVsbG9Xb3JsZCk7Il19Try

指定调试器应查找映射文件的位置，而不是生成的 location。此字符串在源映射中逐字处理，例如

{
  "compilerOptions": {
    "sourceMap": true,
    "mapRoot": "https://my-website.com/debug/sourcemaps/"
  }
}

将声明index.js 的源映射位于https://my-website.com/debug/sourcemaps/index.js.map。

指定在发出文件时使用的行尾序列：‘CRLF’ (dos) 或 ‘LF’ (unix)。

不要发出编译器输出文件，例如 JavaScript 源代码、源映射或声明。

这为其他工具（如 Babel 或 swc）提供了空间，以处理将 TypeScript 文件转换为可以在 JavaScript 环境中运行的文件。

然后，您可以将 TypeScript 用作提供编辑器集成和作为源代码类型检查器的工具。

您可以通过在全局范围内提供您使用的助手的实现，而不是使用 importHelpers 导入助手，并完全关闭助手函数的发出。

例如，在 ES5 中使用此async 函数需要一个await 类函数和一个generator 类函数来运行

ts
const getAPI = async (url: string) => {
  // Get API
  return {};
};Try

这会创建很多 JavaScript

ts
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (g && (g = 0, op[0] && (_ = 0)), _) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var getAPI = function (url) { return __awaiter(void 0, void 0, void 0, function () {
    return __generator(this, function (_a) {
        // Get API
        return [2 /*return*/, {}];
    });
}); };
 Try

可以通过此标志用您自己的全局变量替换它

ts
"use strict";
var getAPI = function (url) { return __awaiter(void 0, void 0, void 0, function () {
    return __generator(this, function (_a) {
        // Get API
        return [2 /*return*/, {}];
    });
}); };
 Try

如果报告了任何错误，则不发出编译器输出文件，例如 JavaScript 源代码、源映射或声明。

默认值为 false，这使得在类似于监视的环境中使用 TypeScript 变得更容易，在该环境中，您可能希望在确保解决所有错误之前在另一个环境中查看代码更改的结果。

如果指定，.js（以及 .d.ts、.js.map 等）文件将被发出到此目录中。原始源文件的目录结构将被保留；如果计算出的根目录不是您想要的，请参见 rootDir。

如果未指定，.js 文件将被发出到与生成它们的 .ts 文件相同的目录中

sh
$ tsc
example
├── index.js
└── index.ts

使用这样的 tsconfig.json

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

使用这些设置运行 tsc 会将文件移动到指定的 dist 文件夹中

sh
$ tsc
example
├── dist
│   └── index.js
├── index.ts
└── tsconfig.json

如果指定，所有全局（非模块）文件将被连接到指定的单个输出文件中。

如果 module 是 system 或 amd，所有模块文件也将被连接到此文件中，在所有全局内容之后。

注意：除非 module 是 None、System 或 AMD，否则 outFile 无法使用。此选项不能用于捆绑 CommonJS 或 ES6 模块。

不要在生成的代码中删除 const enum 声明。const enum 提供了一种方法，通过发出枚举值而不是引用来减少应用程序在运行时的总体内存占用。

例如，使用此 TypeScript

ts
const enum Album {
  JimmyEatWorldFutures = 1,
  TubRingZooHypothesis = 2,
  DogFashionDiscoAdultery = 3,
}
 
const selectedAlbum = Album.JimmyEatWorldFutures;
if (selectedAlbum === Album.JimmyEatWorldFutures) {
  console.log("That is a great choice.");
}Try