指定要包含在程序中的文件的允许列表。如果找不到任何文件，则会发生错误。

¥Specifies an allowlist of files to include in the program. An error occurs if any of the files can’t be found.

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

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

¥This is useful when you only have a small number of files and don’t need to use a glob to reference many files. If you need that then use include.

extends 的值是一个字符串，其中包含要继承的另一个配置文件的路径。路径可以使用 Node.js 样式解析。

¥The value of extends is a string which contains a path to another configuration file to inherit from. The path may use Node.js style resolution.

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

¥The configuration from the base file are loaded first, then overridden by those in the inheriting config file. All relative paths found in the configuration file will be resolved relative to the configuration file they originated in.

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

¥It’s worth noting that files, include, and exclude from the inheriting config file overwrite those from the base config file, and that circularity between configuration files is not allowed.

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

¥Currently, the only top-level property that is excluded from inheritance is references.

示例

¥Example

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
  }
}

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

¥Properties with relative paths found in the configuration file, which aren’t excluded from inheritance, will be resolved relative to the configuration file they originated in.

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

¥Specifies an array of filenames or patterns to include in the program. These filenames are resolved relative to the directory containing the tsconfig.json file.

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

将包括：

¥Which would include:

.
├── 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 模式：

¥include and exclude support wildcard characters to make glob patterns:

• * 匹配零个或多个字符（不包括目录分隔符）

  ¥* matches zero or more characters (excluding directory separators)

• ? 匹配任何一个字符（不包括目录分隔符）

  ¥? matches any one character (excluding directory separators)

• **/ 匹配嵌套到任何级别的任何目录

  ¥**/ matches any directory nested to any level

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

¥If the last path segment in a pattern does not contain a file extension or wildcard character, then it is treated as a directory, and files with supported extensions inside that directory are included (e.g. .ts, .tsx, and .d.ts by default, with .js and .jsx if allowJs is set to true).

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

¥Specifies an array of filenames or patterns that should be skipped when resolving include.

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

¥Important: exclude only changes which files are included as a result of the include setting. A file specified by exclude can still become part of your codebase due to an import statement in your code, a types inclusion, a /// <reference directive, or being specified in the files list.

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

¥It is not a mechanism that prevents a file from being included in the codebase - it simply changes what the include setting finds.

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

¥Project references are a way to structure your TypeScript programs into smaller pieces. Using Project References can greatly improve build and editor interaction times, enforce logical separation between components, and organize your code in new and improved ways.

你可以在手册的 项目引用 部分中阅读有关引用如何工作的更多信息

¥You can read more about how references works in the Project References section of the handbook

当：

¥When:

• undefined（默认）向编辑者提供建议作为警告

  ¥undefined (default) provide suggestions as warnings to editors

• true 无法访问的代码被忽略

  ¥true unreachable code is ignored

• false 引发有关无法访问代码的编译器错误

  ¥false raises compiler errors about unreachable code

这些警告仅与由于使用 JavaScript 语法而无法访问的代码有关，例如：

¥These warnings are only about code which is provably unreachable due to the use of JavaScript syntax, for example:

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

使用 "allowUnreachableCode": false：

¥With "allowUnreachableCode": false:

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

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

¥This does not affect errors on the basis of code which appears to be unreachable due to type analysis.

当：

¥When:

• undefined（默认）向编辑者提供建议作为警告

  ¥undefined (default) provide suggestions as warnings to editors

• true 未使用的标签被忽略

  ¥true unused labels are ignored

• false 引发有关未使用标签的编译器错误

  ¥false raises compiler errors about unused labels

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

¥Labels are very rare in JavaScript and typically indicate an attempt to write an object literal:

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

确保你的文件在 ECMAScript 严格模式下解析，并为每个源文件触发 “使用严格”。

¥Ensures that your files are parsed in the ECMAScript strict mode, and emit “use strict” for each source file.

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

¥ECMAScript strict mode was introduced in ES5 and provides behavior tweaks to the runtime of the JavaScript engine to improve performance, and makes a set of errors throw instead of silently ignoring them.

启用 exactOptionalPropertyTypes 后，TypeScript 将应用更严格的规则来处理具有 ? 前缀的 type 或 interfaces 上的属性。

¥With exactOptionalPropertyTypes enabled, TypeScript applies stricter rules around how it handles properties on type or interfaces which have a ? prefix.

例如，这个接口声明有一个属性可以是两个字符串之一：‘dark’ 或 ‘light’，否则它不应该在对象中。

¥For example, this interface declares that there is a property which can be one of two strings: ‘dark’ or ‘light’ or it should not be in the object.

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

不启用此标志时，你可以将 colorThemeOverride 设置为三个值：“dark”、“light” 和 undefined。

¥Without this flag enabled, there are three values which you can set colorThemeOverride to be: “dark”, “light” and undefined.

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

¥Setting the value to undefined will allow most JavaScript runtime checks for the existence to fail, which is effectively falsy. However, this isn’t quite accurate; colorThemeOverride: undefined is not the same as colorThemeOverride not being defined. For example, "colorThemeOverride" in settings would have different behavior with undefined as the key compared to not being defined.

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

¥exactOptionalPropertyTypes makes TypeScript truly enforce the definition provided as an optional property:

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 语句中 fallthrough 情况的错误。确保 switch 语句中的任何非空情况都包含 break、return 或 throw。这意味着你不会意外发送 case fallthrough 错误。

¥Report errors for fallthrough cases in switch statements. Ensures that any non-empty case inside a switch statement includes either break, return, or throw. This means you won’t accidentally ship a case fallthrough bug.

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 类型。

¥In some cases where no type annotations are present, TypeScript will fall back to a type of any for a variable when it cannot infer the type.

这可能会导致一些错误被遗漏，例如：

¥This can cause some errors to be missed, for example:

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

打开 noImplicitAny 但是 TypeScript 会在推断 any 时触发错误：

¥Turning on noImplicitAny however TypeScript will issue an error whenever it would have inferred 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

使用使用继承的类时，子类可以在基类中重命名时使用其重载的函数获取 “不同步”。

¥When working with classes which use inheritance, it’s possible for a sub-class to get “out of sync” with the functions it overloads when they are renamed in the base class.

例如，假设你正在建模音乐专辑同步系统：

¥For example, imagine you are modeling a music album syncing system:

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

然后，当你添加对机器学习生成的播放列表的支持时，你可以重构 Album 类以改为使用 ‘setup’ 函数：

¥Then when you add support for machine-learning generated playlists, you refactor the Album class to have a ‘setup’ function instead:

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 预计会覆盖基类中的函数。

¥In this case, TypeScript has provided no warning that download on SharedAlbum expected to override a function in the base class.

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

¥Using noImplicitOverride you can ensure that the sub-classes never go out of sync, by ensuring that functions which override include the keyword override.

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

¥The following example has noImplicitOverride enabled, and you can see the error received when override is missing:

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 将检查函数中的所有代码路径以确保它们返回值。

¥When enabled, TypeScript will check all code paths in a function to ensure they return a value.

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’ 表达式引发错误。

¥Raise error on ‘this’ expressions with an implied ‘any’ type.

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

¥For example, the class below returns a function which tries to access this.width and this.height – but the context for this inside the function inside getAreaFunction is not the instance of the 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

此设置可确保通过 “dot”（obj.key）语法和 “indexed”（obj["key"]）访问字段与在类型中声明属性的方式之间的一致性。

¥This setting ensures consistency between accessing a field via the “dot” (obj.key) syntax, and “indexed” (obj["key"]) and the way which the property is declared in the type.

不启用此标志时，TypeScript 将允许你使用点语法访问未定义的字段：

¥Without this flag, TypeScript will allow you to use the dot syntax to access fields which are not defined:

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

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

¥Turning the flag on will raise an error because the unknown field uses dot syntax instead of indexed syntax.

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

此标志的目的是在你的调用语法中触发信号，表明你有多确定此属性存在。

¥The goal of this flag is to signal intent in your calling syntax about how certain you are this property exists.

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

¥TypeScript has a way to describe objects which have unknown keys but known values on an object, via index signatures.

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 添加到类型中任何未声明的字段。

¥Turning on noUncheckedIndexedAccess will add undefined to any un-declared field in the type.

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

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

¥Report errors on unused local variables.

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

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

¥Report errors on unused parameters in functions.

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 标志启用了广泛的类型检查行为，从而更有力地保证了程序的正确性。打开此功能相当于启用所有严格模式系列选项，如下所述。然后，你可以根据需要关闭单独的严格模式系列检查。

¥The strict flag enables a wide range of type checking behavior that results in stronger guarantees of program correctness. Turning this on is equivalent to enabling all of the strict mode family options, which are outlined below. You can then turn off individual strict mode family checks as needed.

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

¥Future versions of TypeScript may introduce additional stricter checking under this flag, so upgrades of TypeScript might result in new type errors in your program. When appropriate and possible, a corresponding flag will be added to disable that behavior.

设置后，TypeScript 将检查函数 call、bind 和 apply 的内置方法是否使用底层函数的正确参数调用：

¥When set, TypeScript will check that the built-in methods of functions call, bind, and apply are invoked with correct argument for the underlying function:

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：

¥Otherwise, these functions accept any arguments and will return 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

内置迭代器使用未定义的 TReturn 类型实例化，而不是 any。

¥Built-in iterators are instantiated with a TReturn type of undefined instead of any.

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

¥When enabled, this flag causes functions parameters to be checked more correctly.

这是关闭 strictFunctionTypes 的基本示例：

¥Here’s a basic example with strictFunctionTypes off:

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 后，错误被正确检测到：

¥With strictFunctionTypes on, the error is correctly detected:

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 中的一些。因此，该设置仅适用于以函数语法编写的函数，而不适用于以方法语法编写的函数：

¥During development of this feature, we discovered a large number of inherently unsafe class hierarchies, including some in the DOM. Because of this, the setting only applies to functions written in function syntax, not to those in method syntax:

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。这可能导致运行时出现意外错误。

¥When strictNullChecks is false, null and undefined are effectively ignored by the language. This can lead to unexpected errors at runtime.

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

¥When strictNullChecks is true, null and undefined have their own distinct types and you’ll get a type error if you try to use them where a concrete value is expected.

例如，使用此 TypeScript 代码，users.find 无法保证它确实会找到用户，但你可以编写代码，就好像它会找到用户一样：

¥For example with this TypeScript code, users.find has no guarantee that it will actually find a user, but you can write code as though it will:

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 之前未保证其存在。

¥Setting strictNullChecks to true will raise an error that you have not made a guarantee that the loggedInUser exists before trying to use it.

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 函数看起来有点像这个简化：

¥The second example failed because the array’s find function looks a bit like this simplification:

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 会引发错误。

¥When set to true, TypeScript will raise an error when a class property was declared but not set in the constructor.

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

在上述情况下：

¥In the above case:

• this.name 是专门设置的。

  ¥this.name is set specifically.

• this.accountType 默认设置。

  ¥this.accountType is set by default.

• this.email 未设置并引发错误。

  ¥this.email is not set and raises an error.

• this.address 被声明为潜在 undefined，这意味着它不必设置。

  ¥this.address is declared as potentially undefined which means it does not have to be set.

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

¥In TypeScript 4.0, support was added to allow changing the type of the variable in a catch clause from any to unknown. Allowing for code like:

ts
try {
  // ...
} catch (err: unknown) {
  // 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 规则来尝试强制执行此行为。

¥This pattern ensures that error handling code becomes more comprehensive because you cannot guarantee that the object being thrown is a Error subclass ahead of time. With the flag useUnknownInCatchVariables enabled, then you do not need the additional syntax (: unknown) nor a linter rule to try enforce this behavior.

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

¥In TypeScript 5.0, when an import path ends in an extension that isn’t a known JavaScript or TypeScript file extension, the compiler will look for a declaration file for that path in the form of {file basename}.d.{extension}.ts. For example, if you are using a CSS loader in a bundler project, you might want to write (or generate) declaration files for those stylesheets:

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 编译器选项抑制错误。

¥By default, this import will raise an error to let you know that TypeScript doesn’t understand this file type and your runtime might not support importing it. But if you’ve configured your runtime or bundler to handle it, you can suppress the error with the new --allowArbitraryExtensions compiler option.

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

¥Note that historically, a similar effect has often been achievable by adding a declaration file named app.css.d.ts instead of app.d.css.ts - however, this just worked through Node’s require resolution rules for CommonJS. Strictly speaking, the former is interpreted as a declaration file for a JavaScript file named app.css.js. Because relative files imports need to include extensions in Node’s ESM support, TypeScript would error on our example in an ESM file under --moduleResolution node16 or nodenext.

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

¥For more information, read up the proposal for this feature and its corresponding pull request.

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

¥--allowImportingTsExtensions allows TypeScript files to import each other with a TypeScript-specific extension like .ts, .mts, or .tsx.

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

¥This flag is only allowed when --noEmit or --emitDeclarationOnly is enabled, since these import paths would not be resolvable at runtime in JavaScript output files. The expectation here is that your resolver (e.g. your bundler, a runtime, or some other tool) is going to make these imports between .ts files work.

设置为 true 时，allowUmdGlobalAccess 允许你从模块文件内部以全局变量形式访问 UMD 导出。模块文件是具有导入和/或导出的文件。不启用此标志时，使用 UMD 模块的导出需要导入声明。

¥When set to true, allowUmdGlobalAccess lets you access UMD exports as globals from inside module files. A module file is a file that has imports and/or exports. Without this flag, using an export from a UMD module requires an import declaration.

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

¥An example use case for this flag would be a web project where you know the particular library (like jQuery or Lodash) will always be available at runtime, but you can’t access it with an import.

设置用于解析裸说明符模块名称的基本目录。例如，在目录结构中：

¥Sets a base directory from which to resolve bare specifier module names. For example, in the directory structure:

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

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

¥With "baseUrl": "./", TypeScript will look for files starting at the same folder as the tsconfig.json:

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

此解析比从 node_modules 查找具有更高的优先级。

¥This resolution has higher priority than lookups from node_modules.

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

¥This feature was designed for use in conjunction with AMD module loaders in the browser, and is not recommended in any other context. As of TypeScript 4.1, baseUrl is no longer required to be set when using paths.

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

¥--customConditions takes a list of additional conditions that should succeed when TypeScript resolves from an exports or imports field of a package.json. These conditions are added to whatever existing conditions a resolver will use by default.

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

¥For example, when this field is set in a tsconfig.json as so:

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

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

¥Any time an exports or imports field is referenced in package.json, TypeScript will consider conditions called my-condition.

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

¥So when importing from a package with the following package.json

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

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

¥TypeScript will try to look for files corresponding to foo.mjs.

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

¥This field is only valid under the node16, nodenext, and bundler options for --moduleResolution.

设置程序的模块系统。有关更多信息，请参阅 TypeScript module 选项背后的理论 和 其参考页面。你很可能希望现代 Node.js 项目使用 "nodenext"，而将要打包的代码使用 preserve 或 esnext。

¥Sets the module system for the program. See the theory behind TypeScript’s module option and its reference page for more information. You very likely want "nodenext" for modern Node.js projects and preserve or esnext for code that will be bundled.

更改 module 会影响 moduleResolution 和 也有参考页面。

¥Changing module affects moduleResolution which also has a reference page.

这是此文件的一些示例输出：

¥Here’s some example output for this file:

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 的支持。

¥In addition to the base functionality of ES2015/ES6, ES2020 adds support for dynamic imports, and import.meta while ES2022 further adds support for top level await.

node16/nodenext

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

¥Available from 4.7+, the node16 and nodenext modes integrate with Node’s native ECMAScript Module support. The emitted JavaScript uses either CommonJS or ES2020 output depending on the file extension and the value of the type setting in the nearest package.json. Module resolution also works differently. You can learn more in the handbook and Modules Reference.

preserve

在 --module preserve（TypeScript 5.4 中的 added）中，在输入文件中编写的 ECMAScript 导入和导出将保留在输出中，并且 CommonJS 样式的 import x = require("...") 和 export = ... 语句将作为 CommonJS require 和 module.exports 触发。换句话说，每个单独的导入或导出语句的格式都会被保留，而不是被强制转换为整个编译（甚至整个文件）的单一格式。

¥In --module preserve (added in TypeScript 5.4), ECMAScript imports and exports written in input files are preserved in the output, and CommonJS-style import x = require("...") and export = ... statements are emitted as CommonJS require and module.exports. In other words, the format of each individual import or export statement is preserved, rather than being coerced into a single format for the whole compilation (or even a whole file).

ts
import { valueOfPi } from "./constants";
const constants = require("./constants");
export const piSquared = valueOfPi * constants.valueOfPi;
 Try

虽然很少需要在同一文件中混合导入和 require 调用，但这种 module 模式最好地反映了大多数现代打包器以及 Bun 运行时的功能。

¥While it’s rare to need to mix imports and require calls in the same file, this module mode best reflects the capabilities of most modern bundlers, as well as the Bun runtime.

为什么要关心 TypeScript 使用打包器或 Bun 触发的 module，你可能还会设置 noEmit？TypeScript 的类型检查和模块解析行为受到其触发的模块格式的影响。设置 module 为 TypeScript 提供有关打包程序或运行时如何处理导入和导出的信息，这确保你在导入值上看到的类型准确反映运行时或打包后将发生的情况。

¥Why care about TypeScript’s module emit with a bundler or with Bun, where you’re likely also setting noEmit? TypeScript’s type checking and module resolution behavior are affected by the module format that it would emit. Setting module gives TypeScript information about how your bundler or runtime will process imports and exports, which ensures that the types you see on imported values accurately reflect what will happen at runtime or after bundling.

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

指定模块解析策略：

¥Specify the module resolution strategy:

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

  ¥'node16' or 'nodenext' for modern versions of Node.js. Node.js v12 and later supports both ECMAScript imports and CommonJS require, which resolve using different algorithms. These moduleResolution values, when combined with the corresponding module values, picks the right algorithm for each resolution based on whether Node.js will see an import or require in the output JavaScript code.

• 'node10'（以前称为 'node'）适用于 v10 之前的 Node.js 版本，仅支持 CommonJS require。你可能不需要在现代代码中使用 node10。

  ¥'node10' (previously called 'node') for Node.js versions older than v10, which only support CommonJS require. You probably won’t need to use node10 in modern code.

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

  ¥'bundler' for use with bundlers. Like node16 and nodenext, this mode supports package.json "imports" and "exports", but unlike the Node.js resolution modes, bundler never requires file extensions on relative paths in imports.

• 'classic' 在 1.6 发布之前在 TypeScript 中使用。不应使用 classic。

  ¥'classic' was used in TypeScript before the release of 1.6. classic should not be used.

有参考页面解释 TypeScript 模块解析背后的理论 和 每个选项的详细信息。

¥There are reference pages explaining the theory behind TypeScript’s module resolution and the details of each option.

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

¥Provides a way to override the default list of file name suffixes to search when resolving a module.

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

给定上述配置，导入如下：

¥Given the above configuration, an import like the following:

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

TypeScript 将查找相关文件 ./foo.ios.ts、./foo.native.ts 和最后的 ./foo.ts。

¥TypeScript will look for the relative files ./foo.ios.ts, ./foo.native.ts, and finally ./foo.ts.

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

¥Note the empty string "" in moduleSuffixes which is necessary for TypeScript to also look-up ./foo.ts.

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

¥This feature can be useful for React Native projects where each target platform can use a separate tsconfig.json with differing moduleSuffixes.

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

¥By default, TypeScript will examine the initial set of files for import and <reference directives and add these resolved files to your program.

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

¥If noResolve is set, this process doesn’t happen. However, import statements are still checked to see if they resolve to a valid module, so you’ll need to make sure this is satisfied by some other means.

在 JavaScript 中，可以 import 模块而无需实际从中导入任何值。

¥In JavaScript it’s possible to import a module without actually importing any values from it.

ts
import "some-module";

这些导入通常被称为副作用导入，因为它们可以提供的唯一有用的行为是执行一些副作用（例如注册全局变量或向原型添加 polyfill）。

¥These imports are often called side effect imports because the only useful behavior they can provide is by executing some side effect (like registering a global variable, or adding a polyfill to a prototype).

默认情况下，TypeScript 不会检查这些导入的有效性。如果导入解析为有效的源文件，TypeScript 将加载并检查该文件。如果未找到源文件，TypeScript 将默默忽略导入。

¥By default, TypeScript will not check these imports for validity. If the import resolves to a valid source file, TypeScript will load and check the file. If no source file is found, TypeScript will silently ignore the import.

这是一种令人惊讶的行为，但它部分源于 JavaScript 生态系统中的建模模式。例如，此语法还已与打包器中的特殊加载器一起使用，以加载 CSS 或其他资源。你的打包器可能配置为你可以通过编写类似以下内容来包含特定的 .css 文件：

¥This is surprising behavior, but it partially stems from modeling patterns in the JavaScript ecosystem. For example, this syntax has also been used with special loaders in bundlers to load CSS or other assets. Your bundler might be configured in such a way where you can include specific .css files by writing something like the following:

tsx
import "./button-component.css";
export function Button() {
  // ...
}

不过，这掩盖了副作用导入中的潜在拼写错误。

¥Still, this masks potential typos on side effect imports.

启用 --noUncheckedSideEffectImports 后，如果 TypeScript 找不到副作用导入的源文件，它将出错。

¥When --noUncheckedSideEffectImports is enabled, TypeScript will error if it can’t find a source file for a side effect import.

ts
import "oops-this-module-does-not-exist";
//     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// error: Cannot find module 'oops-this-module-does-not-exist' or its corresponding type declarations.

启用此选项后，某些工作代码现在可能会收到错误，如上面的 CSS 示例。为了解决这个问题，只想为资源编写副作用 import 的用户可能最好通过编写带有通配符说明符的环境模块声明来提供服务。它将进入全局文件并看起来像下面这样：

¥When enabling this option, some working code may now receive an error, like in the CSS example above. To work around this, users who want to just write side effect imports for assets might be better served by writing what’s called an ambient module declaration with a wildcard specifier. It would go in a global file and look something like the following:

ts
// ./src/globals.d.ts
// Recognize all CSS files as module imports.
declare module "*.css" {}

事实上，你的项目中可能已经有这样的文件了！例如，运行类似 vite init 的程序可能会创建类似的 vite-env.d.ts。

¥In fact, you might already have a file like this in your project! For example, running something like vite init might create a similar vite-env.d.ts.

一系列条目，如果设置，则将导入重新映射到相对于 baseUrl 的查找位置，否则映射到 tsconfig 文件本身。moduleResolution 参考页面 中对 paths 的覆盖范围更大。

¥A series of entries which re-map imports to lookup locations relative to the baseUrl if set, or to the tsconfig file itself otherwise. There is a larger coverage of paths in the moduleResolution reference page.

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

¥paths lets you declare how TypeScript should resolve an import in your require/imports.

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

这将使你能够编写 import "jquery"，并在本地获取所有正确的类型。

¥This would allow you to be able to write import "jquery", and get all of the correct typing locally.

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

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

¥In this case, you can tell the TypeScript file resolver to support a number of custom prefixes to find code.

请注意，此功能不会改变 tsc 触发导入路径的方式，因此 paths 应该仅用于通知 TypeScript 另一个工具具有此映射并将在运行时或打包时使用它。

¥Note that this feature does not change how import paths are emitted by tsc, so paths should only be used to inform TypeScript that another tool has this mapping and will use it at runtime or when bundling.

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

¥Allows importing modules with a .json extension, which is a common practice in node projects. This includes generating a type for the import based on the static JSON shape.

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

¥TypeScript does not support resolving JSON files by default:

ts
// @filename: settings.json
{
    "repo": "TypeScript",
    "dry": false,
    "debug": false
}
// @filename: index.ts
import settings from "./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.
 
settings.debug === true;
settings.dry === 2;Try

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

¥Enabling the option allows importing JSON, and validating the types in that JSON file.

ts
// @filename: settings.json
{
    "repo": "TypeScript",
    "dry": false,
    "debug": false
}
// @filename: index.ts
import settings from "./settings.json";
 
settings.debug === true;
settings.dry === 2;
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.Try

如果 TypeScript 从 node_modules 中的包中读取，--resolvePackageJsonExports 会强制 TypeScript 咨询 package.json 文件的 exports 字段。

¥--resolvePackageJsonExports forces TypeScript to consult the exports field of package.json files if it ever reads from a package in node_modules.

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

¥This option defaults to true under the node16, nodenext, and bundler options for --moduleResolution.

--resolvePackageJsonImports 强制 TypeScript 在从祖级目录包含 package.json 的文件中执行以 # 开头的查找时咨询 package.json 文件的 imports 字段。

¥--resolvePackageJsonImports forces TypeScript to consult the imports field of package.json files when performing a lookup that starts with # from a file whose ancestor directory contains a package.json.

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

¥This option defaults to true under the node16, nodenext, and bundler options for --moduleResolution.

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

¥Default: The longest common path of all non-declaration input files. If composite is set, the default is instead the directory containing the tsconfig.json file.

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

¥When TypeScript compiles files, it keeps the same directory structure in the output directory as exists in the input directory.

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

¥For example, let’s say you have some input files:

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

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

¥The inferred value for rootDir is the longest common path of all non-declaration input files, which in this case is core/.

如果你的 outDir 是 dist，TypeScript 将编写此树：

¥If your outDir was dist, TypeScript would write this tree:

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

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

¥However, you may have intended for core to be part of the output directory structure. By setting rootDir: "." in tsconfig.json, TypeScript would write this tree:

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

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

¥Importantly, rootDir does not affect which files become part of the compilation. It has no interaction with the include, exclude, or files tsconfig.json settings.

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

¥Note that TypeScript will never write an output file to a directory outside of outDir, and will never skip emitting a file. For this reason, rootDir also enforces that all files which need to be emitted are underneath the rootDir path.

例如，假设你有这棵树：

¥For example, let’s say you had this tree:

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

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

¥It would be an error to specify rootDir as core and include as * because it creates a file (helpers.ts) that would need to be emitted outside the outDir (i.e. ../helpers.js).

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

¥Using rootDirs, you can inform the compiler that there are many “virtual” directories acting as a single root. This allows the compiler to resolve relative module imports within these “virtual” directories, as if they were merged in to one directory.

例如：

¥For example:

 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 的方式，它仅模拟了它们能够在运行时通过这些相对路径工作的假设。

¥This does not affect how TypeScript emits JavaScript, it only emulates the assumption that they will be able to work via those relative paths at runtime.

rootDirs 可用于为非 TypeScript 或 JavaScript 的文件提供单独的 “类型层”，方法是在另一个文件夹中为生成的 .d.ts 文件提供主目录。此技术对于打包应用很有用，在这些应用中，你使用的文件的 import 不一定是代码：

¥rootDirs can be used to provide a separate “type layer” to files that are not TypeScript or JavaScript by providing a home for generated .d.ts files in another folder. This technique is useful for bundled applications where you use import of files that aren’t necessarily code:

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 将通过相应生成的声明文件了解该文件类型的打包器行为。

¥This technique lets you generate types ahead of time for the non-code source files. Imports then work naturally based off the source file’s location. For example ./src/index.ts can import the file ./src/css/main.css and TypeScript will be aware of the bundler’s behavior for that filetype via the corresponding generated declaration file.

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

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

¥By default all visible ”@types” packages are included in your compilation. Packages in node_modules/@types of any enclosing folder are considered visible. For example, that means packages within ./node_modules/@types/, ../node_modules/@types/, ../../node_modules/@types/, and so on.

如果指定了 typeRoots，则只会包含 typeRoots 下的包。例如：

¥If typeRoots is specified, only packages under typeRoots will be included. For example:

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

此配置文件将包含 ./typings 和 ./vendor/types 下的所有包，但不包含 ./node_modules/@types 中的包。所有路径均相对于 tsconfig.json。

¥This config file will include all packages under ./typings and ./vendor/types, and no packages from ./node_modules/@types. All paths are relative to the tsconfig.json.

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

¥By default all visible ”@types” packages are included in your compilation. Packages in node_modules/@types of any enclosing folder are considered visible. For example, that means packages within ./node_modules/@types/, ../node_modules/@types/, ../../node_modules/@types/, and so on.

如果指定了 types，则只有列出的包才会包含在全局范围内。例如：

¥If types is specified, only packages listed will be included in the global scope. For instance:

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

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

¥This tsconfig.json file will only include ./node_modules/@types/node, ./node_modules/@types/jest and ./node_modules/@types/express. Other packages under node_modules/@types/* will not be included.

这会产生什么影响？

¥What does this affect?

此选项不会影响 @types/* 在你的应用代码中的包含方式，例如，如果你有上述 compilerOptions 示例，其代码如下：

¥This option does not affect how @types/* are included in your application code, for example if you had the above compilerOptions example with code like:

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

moment 导入将完全类型化。

¥The moment import would be fully typed.

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

¥When you have this option set, by not including a module in the types array it:

• 不会将全局变量添加到你的项目（例如节点中的 process 或 Jest 中的 expect）

  ¥Will not add globals to your project (e.g process in node, or expect in Jest)

• 不会将导出显示为自动导入建议

  ¥Will not have exports appear as auto-import recommendations

此功能与 typeRoots 的不同之处在于它只指定你想要包含的确切类型，而 typeRoots 支持指定你想要特定的文件夹。

¥This feature differs from typeRoots in that it is about specifying only the exact types you want included, whereas typeRoots supports saying you want particular folders.

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

¥Generate .d.ts files for every TypeScript or JavaScript file inside your project. These .d.ts files are type definition files which describe the external API of your module. With .d.ts files, tools like TypeScript can provide intellisense and accurate types for un-typed code.

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

¥When declaration is set to true, running the compiler with this TypeScript code:

ts
export let helloWorld = "hi";Try

将生成如下 index.js 文件：

¥Will generate an index.js file like this:

ts
export let helloWorld = "hi";
 Try

使用相应的 helloWorld.d.ts：

¥With a corresponding helloWorld.d.ts:

ts
export declare let helloWorld: string;
 Try

使用 .d.ts 文件作为 JavaScript 文件时，你可能需要使用 emitDeclarationOnly 或使用 outDir 来确保 JavaScript 文件不会被覆盖。

¥When working with .d.ts files for JavaScript files you may want to use emitDeclarationOnly or use outDir to ensure that the JavaScript files are not overwritten.

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

¥Offers a way to configure the root directory for where declaration files are emitted.

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

使用这个 tsconfig.json：

¥with this tsconfig.json:

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

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

¥Would place the d.ts for the index.ts in a types folder:

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

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

¥Generates a source map for .d.ts files which map back to the original .ts source file. This will allow editors such as VS Code to go to the original .ts file when using features like Go to Definition.

如果你正在使用项目引用，则应该强烈考虑启用此功能。

¥You should strongly consider turning this on if you’re using project references.

降级是 TypeScript 的术语，表示转换为旧版本的 JavaScript。此标志用于支持更准确地实现现代 JavaScript 如何在旧 JavaScript 运行时中迭代新概念。

¥Downleveling is TypeScript’s term for transpiling to an older version of JavaScript. This flag is to enable support for a more accurate implementation of how modern JavaScript iterates through new concepts in older JavaScript runtimes.

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

¥ECMAScript 6 added several new iteration primitives: the for / of loop (for (el of arr)), Array spread ([a, ...b]), argument spread (fn(...args)), and Symbol.iterator. downlevelIteration allows for these iteration primitives to be used more accurately in ES5 environments if a Symbol.iterator implementation is present.

示例：对 for / of 的影响

¥Example: Effects on for / of

使用此 TypeScript 代码：

¥With this TypeScript code:

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

如果不启用 downlevelIteration，任何对象上的 for / of 循环都会降级为传统的 for 循环：

¥Without downlevelIteration enabled, a for / of loop on any object is downleveled to a traditional for loop:

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

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

¥This is often what people expect, but it’s not 100% compliant with ECMAScript iteration protocol. Certain strings, such as emoji (😜), have a .length of 2 (or even more!), but should iterate as 1 unit in a for-of loop. See this blog post by Jonathan New for a longer explanation.

启用 downlevelIteration 后，TypeScript 将使用辅助函数检查 Symbol.iterator 实现（原生或 polyfill）。如果缺少此实现，你将退回到基于索引的迭代。

¥When downlevelIteration is enabled, TypeScript will use a helper function that checks for a Symbol.iterator implementation (either native or polyfill). If this implementation is missing, you’ll fall back to index-based iteration.

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 的数量：

¥You can use tslib via importHelpers to reduce the amount of inline JavaScript too:

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 不会提高合规性。

¥Note: enabling downlevelIteration does not improve compliance if Symbol.iterator is not present in the runtime.

示例：对数组扩展的影响

¥Example: Effects on Array Spreads

这是一个数组展开：

¥This is an array spread:

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

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

¥Based on the description, it sounds easy to downlevel to ES5:

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

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

¥However, this is observably different in certain rare cases.

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

¥For example, if a source array is missing one or more items (contains a hole), the spread syntax will replace each empty item with undefined, whereas .concat will leave them intact.

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 行为。

¥Just as with for / of, downlevelIteration will use Symbol.iterator (if present) to more accurately emulate ES 6 behavior.

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

¥Controls whether TypeScript will emit a byte order mark (BOM) when writing output files. Some runtime environments require a BOM to correctly interpret a JavaScript files; others require that it is not present. The default value of false is generally best unless you have a reason to change it.

仅触发 .d.ts 文件；不要触发 .js 文件。

¥Only emit .d.ts files; do not emit .js files.

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

¥This setting is useful in two cases:

• 你正在使用 TypeScript 以外的转译器来生成 JavaScript。

  ¥You are using a transpiler other than TypeScript to generate your JavaScript.

• 你正在使用 TypeScript 仅为你的消费者生成 d.ts 文件。

  ¥You are using TypeScript to only generate d.ts files for your consumers.

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

¥For certain downleveling operations, TypeScript uses some helper code for operations like extending class, spreading arrays or objects, and async operations. By default, these helpers are inserted into files which use them. This can result in code duplication if the same helper is used in many different modules.

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

¥If the importHelpers flag is on, these helper functions are instead imported from the tslib module. You will need to ensure that the tslib module is able to be imported at runtime. This only affects modules; global script files will not attempt to import modules.

例如，使用此 TypeScript：

¥For example, with this TypeScript:

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

打开 downlevelIteration 和 importHelpers 仍然为假：

¥Turning on downlevelIteration and importHelpers is still 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：

¥Then turning on both downlevelIteration and importHelpers:

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

当你提供这些函数的自己的实现时，可以使用 noEmitHelpers。

¥You can use noEmitHelpers when you provide your own implementations of these functions.

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

¥When set, instead of writing out a .js.map file to provide source maps, TypeScript will embed the source map content in the .js files. Although this results in larger JS files, it can be convenient in some scenarios. For example, you might want to debug JS files on a webserver that doesn’t allow .map files to be served.

与 sourceMap 互斥。

¥Mutually exclusive with sourceMap.

例如，使用此 TypeScript：

¥For example, with this TypeScript:

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

转换为此 JavaScript：

¥Converts to this JavaScript:

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

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

¥Then enable building it with inlineSourceMap enabled there is a comment at the bottom of the file which includes a source-map for the file.

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

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

¥When set, TypeScript will include the original content of the .ts file as an embedded string in the source map (using the source map’s sourcesContent property). This is often useful in the same cases as inlineSourceMap.

需要设置 sourceMap 或 inlineSourceMap。

¥Requires either sourceMap or inlineSourceMap to be set.

例如，使用此 TypeScript：

¥For example, with this TypeScript:

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

默认情况下转换为此 JavaScript：

¥By default converts to this JavaScript:

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

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

¥Then enable building it with inlineSources and inlineSourceMap enabled there is a comment at the bottom of the file which includes a source-map for the file. Note that the end is different from the example in inlineSourceMap because the source-map now contains the original source code also.

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

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

¥Specify the location where debugger should locate map files instead of generated locations. This string is treated verbatim inside the source-map, for example:

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

将声明 index.js 将在 https://my-website.com/debug/sourcemaps/index.js.map 处有源映射。

¥Would declare that index.js will have sourcemaps at https://my-website.com/debug/sourcemaps/index.js.map.

指定在触发文件时要使用的行尾序列：‘CRLF’（dos）或 ‘LF’（unix）。

¥Specify the end of line sequence to be used when emitting files: ‘CRLF’ (dos) or ‘LF’ (unix).

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

¥Do not emit compiler output files like JavaScript source code, source-maps or declarations.

这为另一个工具（如 Babel 或 swc）腾出了空间，用于将 TypeScript 文件转换为可以在 JavaScript 环境中运行的文件。

¥This makes room for another tool like Babel, or swc to handle converting the TypeScript file to a file which can run inside a JavaScript environment.

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

¥You can then use TypeScript as a tool for providing editor integration, and as a source code type-checker.

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

¥Instead of importing helpers with importHelpers, you can provide implementations in the global scope for the helpers you use and completely turn off emitting of helper functions.

例如，在 ES5 中使用此 async 函数需要运行类似 await 的函数和类似 generator 的函数：

¥For example, using this async function in ES5 requires a await-like function and generator-like function to run:

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

这会创建相当多的 JavaScript：

¥Which creates quite a lot of 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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
    return g.next = verb(0), g["throw"] = verb(1), g["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