指定包含在程式中的檔案白名單。如果找不到任何指定檔案，將報錯。

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

當專案檔案數量很少且無需使用萬用字元引用大量檔案時，該選項很有用。如果需要萬用字元，請使用 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 引擎執行時的行為來提高效能，並將一些潛在的靜默錯誤改為丟擲異常。

啟用後，TypeScript 對 type 或 interfaces 中帶有 ? 字首的屬性的處理將應用更嚴格的規則。

例如，此介面聲明瞭一個屬性，該屬性可以是 'dark' 或 'light' 兩個字串之一，或者該屬性不應該存在於物件中。

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

如果不啟用此標誌，您可以將 colorThemeOverride 設定為三個值： “dark”、“light” 和 undefined。

將值設定為 undefined 會導致大多數 JavaScript 執行時檢查失敗，因為它本質上是 falsy 值。然而，這並不完全準確；colorThemeOverride: undefined 與屬性 colorThemeOverride 未定義並不相同。例如，在設定中使用 "colorThemeOverride" in settings 時，undefined 作為鍵的行為與未定義完全不同。

exactOptionalPropertyTypes 讓 TypeScript 真正強制執行可選屬性的定義。

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

報告 switch 語句中貫穿 (fallthrough) 情況的錯誤。確保 switch 語句中任何非空的 case 都包含 break、return 或 throw。這意味著您不會意外引入 case 貫穿錯誤。

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

當 'this' 表示式具有隱式的 'any' 型別時觸發錯誤。

例如，下面的類返回一個試圖訪問 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 中的一些結構。因此，該設定僅適用於以 function 語法編寫的函式，而不適用於以 method 語法編寫的函式。

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) 也不需要 linter 規則來強制執行此行為。

在 TypeScript 5.0 中，當匯入路徑以非 JavaScript 或 TypeScript 副檔名結尾時，編譯器會以 {file basename}.d.{extension}.ts 的形式查詢該路徑的宣告檔案。例如，如果您在打包專案中使用 CSS 載入器，您可能希望為這些樣式表編寫（或生成）宣告檔案。

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

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

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

預設情況下，此匯入會觸發錯誤，告知您 TypeScript 不理解該檔案型別，且您的執行時可能不支援匯入它。但是，如果您已配置執行時或打包器來處理它，可以使用新的 --allowArbitraryExtensions 編譯器選項禁止此錯誤。

請注意，歷史上透過新增名為 app.css.d.ts 而不是 app.d.css.ts 的宣告檔案通常也能達到類似效果——但這僅透過 Node 的 CommonJS require 解析規則生效。嚴格來說，前者被解釋為名為 app.css.js 的 JavaScript 檔案的宣告檔案。由於相對檔案匯入在 Node 的 ESM 支援中需要包含副檔名，TypeScript 會在 --moduleResolution node16 或 nodenext 下的 ESM 檔案中報錯。

有關更多資訊，請查閱 此功能的提案 和 對應的拉取請求 (PR)。

--allowImportingTsExtensions 允許 TypeScript 檔案使用特定的 TypeScript 副檔名（如 .ts、.mts 或 .tsx）相互匯入。

此標誌僅在開啟 --noEmit 或 --emitDeclarationOnly 時允許，因為這些匯入路徑在 JavaScript 輸出檔案中無法在執行時解析。此處的期望是，您的解析器（例如您的打包器、執行時或其他工具）將使這些 .ts 檔案之間的匯入生效。

設定為 true 時，allowUmdGlobalAccess 允許您從模組檔案內部將 UMD 匯出作為全域性變數訪問。模組檔案是具有匯入和/或匯出語句的檔案。如果沒有此標誌，使用 UMD 模組的匯出需要匯入宣告。

此標誌的一個示例用例是 Web 專案，其中您知道某個庫（如 jQuery 或 Lodash）在執行時將始終可用，但您無法透過匯入方式訪問它。

設定用於解析非相對模組名稱的基目錄。例如，在目錄結構中：

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

設定 "baseUrl": "./" 後，TypeScript 將從 tsconfig.json 所在的資料夾開始查詢檔案。

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

此解析方式的優先順序高於從 node_modules 中查詢。

此功能專為與瀏覽器中的 AMD 模組載入器結合使用而設計，不建議在任何其他環境中使用。從 TypeScript 4.1 開始，使用 paths 時不再強制要求設定 baseUrl。

--customConditions 接收一個額外的 條件 (conditions) 列表，當 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 中使用 TypeScript 的 module 輸出，而您可能也設定了 noEmit？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

指定模組解析策略

• 'node16' 或 'nodenext' 用於現代版本的 Node.js。Node.js v12 及更高版本同時支援 ECMAScript 匯入和 CommonJS require，它們使用不同的演算法進行解析。當這些 moduleResolution 值與相應的 module 值結合使用時，會根據 Node.js 在輸出的 JavaScript 程式碼中看到的是 import 還是 require，選擇正確的演算法。
• 'node10'（以前稱為 'node'）用於 v10 之前的 Node.js 版本，這些版本僅支援 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 的使用者，可以透過編寫所謂的 環境模組宣告 (ambient module declaration) 和萬用字元說明符來解決。它會位於全域性檔案中，看起來如下：

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。

--resolvePackageJsonImports 強制 TypeScript 在執行以 # 開頭的查詢時查閱 package.json 檔案的 imports 欄位，前提是執行查詢的檔案所屬的祖先目錄包含 package.json。

當 --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 為 * 將會出錯，因為它會建立一個檔案 (helpers.ts)，該檔案需要輸出到 outDir 之外 (即 ../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” 包都會包含在您的編譯中。任何包含資料夾的 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 等編輯器在執行 轉到定義 (Go to Definition) 等功能時跳轉到原始 .ts 檔案。

如果您正在使用專案引用，則應強烈考慮開啟此選項。

向下相容 (Downleveling) 是 TypeScript 中轉譯為舊版本 JavaScript 的術語。此標誌旨在啟用對現代 JavaScript 如何在舊版 JavaScript 執行時中迭代新概念的更準確實現的支援。

ECMAScript 6 增加了幾個新的迭代原語：for / of 迴圈 (for (el of arr))、陣列展開 ([a, ...b])、引數展開 (fn(...args)) 和 Symbol.iterator。downlevelIteration 允許在存在 Symbol.iterator 實現的情況下，在 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

這通常是人們所期望的，但它並不 100% 符合 ECMAScript 迭代協議。某些字串（例如表情符號 😜）的 .length 為 2（甚至更多！），但在 for-of 迴圈中應作為 1 個單位進行迭代。請參閱 Jonathan New 的這篇部落格文章 瞭解更詳細的解釋。

當啟用 downlevelIteration 時，TypeScript 將使用一個檢查 Symbol.iterator 實現（原生或 polyfill）的輔助函式。如果缺少此實現，將回退到基於索引的迭代。

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

您可以透過 importHelpers 使用 tslib 來減少內聯 JavaScript 的量

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

注意：如果執行時中不存在 Symbol.iterator，啟用 downlevelIteration 也不會提高合規性。

示例：對陣列展開的影響

這是一個數組展開：

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

根據描述，向下轉譯到 ES5 似乎很容易：

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

然而，在某些罕見情況下，這是明顯不同的。

例如，如果源陣列缺少一個或多個項（包含空洞），展開語法會將每個空項替換為 undefined，而 .concat 則會保持它們不變。

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

正如 for / of 一樣，downlevelIteration 將使用 Symbol.iterator（如果存在）來更準確地模擬 ES 6 行為。

控制 TypeScript 在編寫輸出檔案時是否輸出 位元組順序標記 (BOM)。某些執行時環境需要 BOM 才能正確解釋 JavaScript 檔案；而其他環境則要求不包含它。除非您有充分的理由更改它，否則預設值 false 通常是最好的。

僅輸出 .d.ts 檔案；不輸出 .js 檔案。

此設定在以下兩種情況下非常有用：

• 您正在使用 TypeScript 以外的轉譯器來生成 JavaScript。
• 您僅使用 TypeScript 為您的消費者生成 d.ts 檔案。

對於某些降級（downleveling）操作，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