TSConfig 参考

指定要包含到程序中的文件允许列表。只要有文件找不到，就会发生错误。

{
  "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 并不相同。例如，在键为 undefined 与键未定义这两种情况下，"colorThemeOverride" in settings 的行为会有所不同。

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。这意味着你不会意外发布 case 贯穿的 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 类型。

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

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

名称以下划线（_）开头的参数声明不受未使用参数检查的约束，例如：

ts
const createDefaultKeyboard = (_modelID: number) => {
  return { type: "keyboard" };
};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: 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），也不需要 lint 规则来强制这一行为。

在 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 针对 CommonJS 的 require 解析规则。严格来说，前者被解释为名为 app.css.js 的 JavaScript 文件的声明文件。由于 Node 的 ESM 支持要求相对文件导入包含扩展名，在 --moduleResolution node16 或 nodenext 下的 ESM 文件中，TypeScript 会对我们的示例写法报错。

更多信息，请阅读此功能的提案及其对应的 pull request。

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

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

当设为 true 时，allowUmdGlobalAccess 让你可以在模块文件内部以全局变量的方式访问 UMD 导出。模块文件是包含导入和/或导出的文件。没有此标志时，使用 UMD 模块的导出需要一条导入声明。

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

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

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 从 package.json 的 exports 或 imports 字段进行解析时，这些条件应当匹配成功。这些条件会附加到解析器默认使用的既有条件之上。

例如，在 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"；对于将被打包的代码，则需要 preserve 或 esnext。

更改 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/node18/node20/nodenext

node16、node18、node20 和 nodenext 模式与 Node 的原生 ECMAScript 模块支持集成。输出的 JavaScript 会根据文件扩展名以及最近的 package.json 中 type 设置的值，输出 CommonJS 或 ES2020。模块解析的工作方式也有所不同。你可以在手册和模块参考中了解更多。

• node16 从 TypeScript 4.7 起可用
• node18 从 TypeScript 5.8 起可用，作为 node16 的替代，并新增了对导入属性的支持。
• node20 新增了对 require(ESM) 的支持。
• nodenext 从 TypeScript 4.7 起可用，但其行为会随 Node.js 的最新稳定版本而变化。--module nodenext 会隐含浮动的 --target esnext。

preserve

在 --module preserve 下（TypeScript 5.4 新增），输入文件中书写的 ECMAScript 导入和导出会保留在输出中，而 CommonJS 风格的 import x = require("...") 与 export = ... 语句则输出为 CommonJS 的 require 和 module.exports。换句话说，每个导入或导出语句各自的形式都会被保留，而不会被强制统一为整个编译（甚至整个文件）的单一格式。

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

虽然在同一个文件中混用 import 与 require 调用很少见，但这种 module 模式最能反映大多数现代打包工具以及 Bun 运行时的能力。

为什么在使用打包工具或 Bun 时（此时你很可能也设置了 noEmit）仍要关心 TypeScript 的 module 输出？TypeScript 的类型检查和模块解析行为会受到它将要输出的模块格式的影响。设置 module 能让 TypeScript 了解你的打包工具或运行时会如何处理导入与导出，从而确保你在导入值上看到的类型能准确反映运行时或打包之后的实际情况。

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 从不要求导入中的相对路径带文件扩展名。
• 'classic' 在 1.6 发布之前曾用于 TypeScript。不应再使用 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 项目很有用，其中每个目标平台都可以使用带有不同 moduleSuffixes 的独立 tsconfig.json。

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

如果设置了 noResolve，则不会执行此过程。不过，import 语句仍会被检查是否能解析到有效模块，因此你需要通过其他方式确保这一点。

在 JavaScript 中，可以 import 一个模块，而不实际从中导入任何值。

ts
import "some-module";

这类导入通常被称为副作用导入，因为它们唯一有用的行为就是执行某种副作用（例如注册全局变量，或为原型添加 polyfill）。

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

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

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

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

启用 --noUncheckedSideEffectImports 后，如果 TypeScript 找不到副作用导入对应的源文件，就会报错。

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 的用户最好编写所谓的带通配符说明符的环境模块声明。它会放在全局文件中，看起来类似下面这样：

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

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

一系列条目，用于将导入重新映射到查找位置：如果设置了 baseUrl，则相对于它；否则相对于 tsconfig 文件本身。关于 paths 的更详细内容见moduleResolution 参考页面。

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
{
    "repo": "TypeScript",
    "dry": false,
    "debug": false
}
// @filename: index.ts
import settings from "./settings.json";
Cannot find module './settings.json' or its corresponding type declarations.2307Cannot find module './settings.json' or its corresponding type declarations.
 
settings.debug === true;
settings.dry === 2;Try

启用该选项后，就可以导入 JSON，并校验该 JSON 文件中的类型。

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

--resolvePackageJsonExports 强制 TypeScript 在由于 node_modules 中的包而读取文件时，查阅 package.json 文件的 exports 字段。

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

当从祖先目录中包含 package.json 的文件发起以 # 开头的查找时，--resolvePackageJsonImports 会强制 TypeScript 查询 package.json 文件的 imports 字段。

当 --moduleResolution 为 node16、nodenext 或 bundler 时，此选项默认为 true。

将相对导入路径中的 .ts、.tsx、.mts 和 .cts 文件扩展名改写为输出文件中对应的 JavaScript 扩展名。

更多信息请参阅 TypeScript 5.7 发行说明。

默认值：所有非声明输入文件的最长公共路径。如果设置了 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.ts），即 ../helpers.js。

使用 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 被设置为 []。对于低于 TypeScript 6.0 的版本，默认情况下所有可见的“@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 数组中包含某个模块，那么它：

• 不会向你的项目添加全局变量（例如 node 中的 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 文件。

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

降级（Downleveling）是 TypeScript 对“转译为较旧版本 JavaScript”的称呼。此标志用于在较旧的 JavaScript 运行时中，支持对现代 JavaScript 如何迭代新概念进行更准确的实现。

ECMAScript 6 新增了若干迭代原语：for / of 循环（for (el of arr)）、数组展开（[a, ...b]）、参数展开（fn(...args)）以及 Symbol.iterator。如果存在 Symbol.iterator 实现，downlevelIteration 允许在 ES5 环境中更准确地使用这些迭代原语。

示例：对 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 迭代协议。某些字符串，例如 emoji（😜），其 .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

你也可以通过 tslib，借助 importHelpers 来减少内联 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 文件；另一些则要求不能存在 BOM。除非你有理由更改，否则默认值 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。

设置此选项后，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

指定调试器查找映射文件的位置，以替代默认的生成位置。此字符串会在源码映射中按原样使用，例如：

{
  "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 = 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

你可以通过此标志把它们替换为你自己的全局实现：

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