指定要包含在程式中的檔案允許清單。如果找不到任何檔案，就會發生錯誤。

{
  "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 嚴格模式進行剖析，並為每個原始檔發出「使用嚴格模式」。

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` 不同。例如，`settings` 中的 `"colorThemeOverride"` 會有不同的行為，其中 `undefined` 作為金鑰，與未定義不同。

exactOptionalPropertyTypes 使 TypeScript 真正強制執行提供為選用屬性的定義

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

回報 switch 陳述式中穿透案例的錯誤。確保 switch 陳述式中的任何非空案例都包含 `break`、`return` 或 `throw`。這表示你不會意外地傳送案例穿透錯誤。

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

在某些沒有類型註解的情況下，當 TypeScript 無法推斷類型時，會將變數的類型設為 `any`。

這可能會導致錯過一些錯誤，例如

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

不過，開啟 `noImplicitAny` 後，TypeScript 會在推斷為 `any` 時發出錯誤

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

使用繼承的類別時，子類別可能會與其覆寫的函式「不同步」，當這些函式在基底類別中重新命名時。

例如，想像您正在建構音樂專輯同步系統的模型

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

當您新增對機器學習產生的播放清單支援時，您會將 Album 類別重構為改用「設定」函式

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

在這種情況下，TypeScript 沒有提供任何警告，表示 SharedAlbum 上的 download 預期會覆寫基底類別中的函式。

使用 noImplicitOverride，您可以確保子類別永遠不會不同步，方法是確保覆寫函式的函式包含關鍵字 override。

下列範例啟用了 noImplicitOverride，當 override 遺失時，您可以看到收到的錯誤

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

啟用時，TypeScript 會檢查函式中的所有程式碼路徑，以確保它們傳回值。

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

對具有隱含「any」類型的「this」表達式提出錯誤。

例如，下方的類別傳回一個函式，嘗試存取 this.width 和 this.height，但 getAreaFunction 內部函式中的 this 的內容不是 Rectangle 的執行個體。

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

此設定確保透過「點號」(obj.key) 語法和「索引」(obj["key"]) 存取欄位，以及在類型中宣告屬性的方式之間的一致性。

沒有這個旗標，TypeScript 會允許您使用點號語法存取未定義的欄位

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

開啟旗標會提出錯誤，因為未知欄位使用點號語法，而不是索引語法。

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

此標記的目標是針對您呼叫語法中的意圖發出訊號，表示您對於這個屬性存在的確定性。

TypeScript 有種方式可以透過索引簽章描述具有未知金鑰但已知物件值的物件。

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

開啟 noUncheckedIndexedAccess 會將 undefined 新增至類型中任何未宣告的欄位。

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

報告未使用的區域變數錯誤。

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

報告函式中未使用的參數錯誤。

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

strict 標記會啟用廣泛的類型檢查行為，進而產生更強的程式正確性保證。開啟此標記等同於啟用所有嚴格模式系列選項，如下所述。您之後可以視需要關閉個別嚴格模式系列檢查。

未來版本的 TypeScript 可能會在此標記下引入其他更嚴格的檢查，因此升級 TypeScript 可能會導致程式中出現新的類型錯誤。在適當且可行的情況下，會新增對應的標記來停用該行為。

設定後，TypeScript 會檢查函式 call、bind 和 apply 的內建方法是否以正確的引數呼叫底層函式

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

否則，這些函式會接受任何引數並傳回 any

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

啟用時，此旗標會導致函式參數接受更正確的檢查。

以下是關閉 strictFunctionTypes 的基本範例

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

開啟 strictFunctionTypes 後，錯誤會正確偵測到

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

在開發此功能期間，我們發現大量本質上不安全的類別階層，包括 DOM 中的一些類別。因此，此設定只套用在以 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 中，新增支援將捕捉子句中變數的型別從 any 變更為 unknown。允許使用類似下列的程式碼

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

此模式可確保錯誤處理程式碼更全面，因為您無法預先保證擲出的物件是錯誤子類別。如果啟用旗標 useUnknownInCatchVariables，則不需要額外的語法 (: unknown) 或 linter 規則來嘗試強制執行此行為。

在 TypeScript 5.0 中，當匯入路徑以非已知的 JavaScript 或 TypeScript 檔案副檔名結尾時，編譯器會以 {檔案基礎檔名}.d.{副檔名}.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 檔案中對我們的範例產生錯誤。

如需更多資訊，請閱讀 此功能的提案 和 其對應的拉取請求。

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

此旗標僅在啟用 --noEmit 或 --emitDeclarationOnly 時才允許，因為這些匯入路徑無法在 JavaScript 輸出檔案中於執行階段解析。此處的預期是你的解析器（例如你的打包器、執行階段或其他工具）將使這些 .ts 檔案之間的匯入運作。

設定為 true 時，allowUmdGlobalAccess 可讓您從模組檔案內部以全域方式存取 UMD 匯出。模組檔案是一個具有匯入和/或匯出的檔案。沒有這個旗標，使用 UMD 模組的匯出需要一個匯入宣告。

此旗標的一個範例使用案例會是一個網頁專案，您知道特定函式庫（例如 jQuery 或 Lodash）在執行階段總是可用，但您無法透過匯入存取它。

設定一個基礎目錄，用於解析裸露的指定符號模組名稱。例如，在目錄結構中

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

使用 "baseUrl": "./"，TypeScript 會從與 tsconfig.json 相同的資料夾開始尋找檔案

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

此解析優先於從 node_modules 的查詢。

此功能設計為與瀏覽器中的 AMD 模組載入器結合使用，不建議在任何其他情況下使用。從 TypeScript 4.1 開始，使用 paths 時不再需要設定 baseUrl。

--customConditions 會取得一個額外的 條件 清單，這些條件應該在 TypeScript 從 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"。

變更 module 會影響 moduleResolution，其 也有參考頁面。

以下是此檔案的一些範例輸出

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

CommonJS

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

UMD

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

AMD

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

System

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

ESNext

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

ES2015/ES6/ES2020/ES2022

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

除了 ES2015/ES6 的基本功能外，ES2020 還增加了對 動態 import 和 import.meta 的支援，而 ES2022 則進一步增加了對 頂層 await 的支援。

node16/nodenext

從 4.7+ 開始，node16 和 nodenext 模式與 Node 的 原生 ECMAScript 模組支援 整合。發出的 JavaScript 會根據檔案副檔名和最近 package.json 中 type 設定的值，使用 CommonJS 或 ES2020 輸出。模組解析也以不同的方式運作。您可以在 手冊 和 模組參考 中了解更多資訊。

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 永遠不需要匯入中的相對路徑上的檔案副檔名。

  bundler 不支援解析 require 呼叫。在 TypeScript 檔案中，這表示禁止使用 import mod = require("foo") 語法；在 JavaScript 檔案中，require 呼叫並非錯誤，但只會傳回 any 類型（或宣告為 return 的全域 require 函式的環境宣告）。

• 在 1.6 發行之前，TypeScript 使用 'classic'。不應使用 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 陳述式，以查看它們是否解析為有效的模組，因此您需要確定透過其他方式滿足此需求。

一系列條目，如果設定 baseUrl，會將輸入重新對應至相對於 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
Cannot find module './settings.json'. Consider using '--resolveJsonModule' to import module with '.json' extension.2732Cannot find module './settings.json'. Consider using '--resolveJsonModule' to import module with '.json' extension.
{
    "repo": "TypeScript",
    "dry": false,
    "debug": false
}
// @filename: index.ts
import settings from "./settings.json";
 
settings.debug === true;
settings.dry === 2;Try

啟用此選項允許導入 JSON，並驗證該 JSON 檔案中的型別。

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

--resolvePackageJsonExports 強制 TypeScript 查詢 package.json 檔案的 exports 欄位，如果它曾經從 node_modules 中的套件讀取。

此選項在 --moduleResolution 的 node16、nodenext 和 bundler 選項下預設為 true。

--resolvePackageJsonImports 強制 TypeScript 查詢 package.json 檔案的 imports 欄位，當從一個祖先目錄包含 package.json 的檔案開始執行以 # 開頭的查詢時。

此選項在 --moduleResolution 的 node16、nodenext 和 bundler 選項下預設為 true。

預設值：所有非宣告輸入檔案的最長共用路徑。如果設定 composite，預設值改為包含 tsconfig.json 檔案的目錄。

當 TypeScript 編譯檔案時，它會在輸出目錄中保留與輸入目錄相同的目錄結構。

例如，假設您有一些輸入檔案

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

rootDir 的推論值是所有非宣告輸入檔案的最長共用路徑，在本例中為 core/。

如果您的 outDir 是 dist，TypeScript 會寫入這個樹狀結構

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

不過，您可能希望 core 成為輸出目錄結構的一部分。透過在 tsconfig.json 中設定 rootDir: "."，TypeScript 會寫入這個樹狀結構

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

重要的是，rootDir 不會影響哪些檔案會成為編譯的一部分。它不會與 include、exclude 或 files tsconfig.json 設定互動。

請注意，TypeScript 永遠不會將輸出檔案寫入 outDir 外的目錄，而且永遠不會略過發射檔案。因此，rootDir 也會強制執行所有需要發射的檔案都位於 rootDir 路徑下方。

例如，假設您有這個樹狀結構

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

指定 rootDir 為 core 和 include 為 * 會是一個錯誤，因為它會建立一個檔案 (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 陣列中的模組，它

• 不會將全域變數新增至您的專案（例如，節點中的 process 或 Jest 中的 expect）
• 不會讓匯出顯示為自動匯入建議

此功能與 typeRoots 不同，在於它只會指定您要包含的確切類型，而 typeRoots 支援表示您想要特定資料夾。

為專案中的每個 TypeScript 或 JavaScript 檔案產生 .d.ts 檔案。這些 .d.ts 檔案是類型定義檔案，用於描述模組的外部 API。透過 .d.ts 檔案，例如 TypeScript 等工具可以為未鍵入的程式碼提供 IntelliSense 和精確的類型。

當 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

當使用 .d.ts 檔案搭配 JavaScript 檔案時，您可能想要使用 emitDeclarationOnly 或使用 outDir 來確保 JavaScript 檔案不會被覆寫。

提供一種方式來設定宣告檔案發布的根目錄。

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

使用這個 tsconfig.json

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

會將 index.ts 的 d.ts 放置在 types 資料夾中

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

為 .d.ts 檔案產生一個原始碼對應，用於對應回原始的 .ts 原始碼檔案。這將允許像 VS Code 這樣的編輯器在使用像「轉到定義」等功能時，轉到原始的 .ts 檔案。

如果您正在使用專案參考，您應該強烈考慮啟用這個選項。

降級是 TypeScript 將較新版本的 JavaScript 轉譯為較舊版本的 JavaScript 的術語。這個旗標是用於啟用對在較舊 JavaScript 執行時期中，現代 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

這通常是人們的預期，但它並未 100% 符合 ECMAScript 迭代協定。某些字串，例如表情符號 (😜)，其 .length 為 2（甚至更多！），但在 for-of 迴圈中應迭代為 1 個單位。請參閱 Jonathan New 的這篇部落格文章，以取得更詳細的說明。

啟用 downlevelIteration 時，TypeScript 將使用輔助函式來檢查 Symbol.iterator 實作（原生或多重載入）。如果缺少此實作，您將會降回至基於索引的迭代。

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

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

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

注意：如果執行時期中不存在 Symbol.iterator，啟用 downlevelIteration 並不會改善相容性。

範例：陣列散佈的影響

這是一個陣列散佈

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

根據說明，它聽起來很輕易就能降級到 ES5

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

然而，這在某些罕見的情況下，觀察到的結果是不同的。

例如，如果來源陣列缺少一或多個項目（包含一個空洞），散佈語法會將每個空項目替換為 undefined，而 .concat 會將它們保留原樣。

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

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

控制 TypeScript 在寫入輸出檔案時是否會發出 位元組順序標記 (BOM)。有些執行時間環境需要 BOM 來正確地詮釋 JavaScript 檔案；其他環境則需要它不存在。false 的預設值通常是最棒的，除非你有理由要變更它。

只發出 .d.ts 檔案；不要發出 .js 檔案。

此設定在兩種情況下很有用

• 你正在使用 TypeScript 以外的轉譯器來產生你的 JavaScript。
• 你正在使用 TypeScript 來只為你的使用者產生 d.ts 檔案。

對於某些降級作業，TypeScript 使用一些 Helper 程式碼進行作業，例如延伸類別、散布陣列或物件，以及非同步作業。預設情況下，這些 Helper 會插入到使用它們的檔案中。如果在許多不同的模組中使用相同的 Helper，這可能會導致程式碼重複。

如果 importHelpers 旗標開啟，這些 Helper 函式會從 tslib 模組匯入。您需要確保可以在執行階段匯入 tslib 模組。這只會影響模組；全域指令碼檔案不會嘗試匯入模組。

例如，使用這個 TypeScript

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

開啟 downlevelIteration，而 importHelpers 仍然為 false

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

然後同時開啟 downlevelIteration 和 importHelpers

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

當您提供這些函式的自訂實作時，可以使用 noEmitHelpers。

已棄用，建議使用 verbatimModuleSyntax。

此旗標控制 import 的運作方式，有 3 個不同的選項

• remove：僅參考型別的 import 陳述式的預設行為是移除。

• preserve：保留所有值或型別從未使用的 import 陳述式。這可能會導致保留匯入/副作用。

• 錯誤：這會保留所有匯入（與保留選項相同），但當值匯入僅用作類型時會產生錯誤。如果您想要確保沒有意外匯入任何值，但仍使副作用匯入明確，這可能會很有用。

此標記運作是因為您可以使用 import type 明確建立 import 陳述式，該陳述式不應發射到 JavaScript 中。

設定後，TypeScript 會將來源地圖內容嵌入到 .js 檔案中，而不是寫出 .js.map 檔案來提供來源地圖。雖然這會導致較大的 JS 檔案，但在某些情況下可能會很方便。例如，您可能想要在不允許提供 .map 檔案的網路伺服器上偵錯 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;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (g && (g = 0, op[0] && (_ = 0)), _) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var getAPI = function (url) { return __awaiter(void 0, void 0, void 0, function () {
    return __generator(this, function (_a) {
        // Get API
        return [2 /*return*/, {}];
    });
}); };
 Try

可透過此旗標切換為你自己的全域變數

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

如果報告任何錯誤，請勿發出編譯器輸出檔案，例如 JavaScript 原始碼、原始碼對應和宣告。

這預設為 false，這讓在類似監控的環境中使用 TypeScript 變得更容易，在這種環境中，你可能希望在確保所有錯誤都已解決之前，在另一個環境中查看程式碼變更的結果。

如果指定，.js（以及 .d.ts、.js.map 等）檔案將發出到此目錄。原始原始檔的目錄結構會保留；如果計算出的根目錄不是你想要的，請參閱 rootDir。

如果未指定，.js 檔案將發出到與產生它們的 .ts 檔案相同的目錄中

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

使用類似這樣的 tsconfig.json

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

使用這些設定執行 tsc 會將檔案移至指定的 dist 資料夾

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

如果指定，所有全域（非模組）檔案都將串接成指定的單一輸出檔案。

如果 module 是 system 或 amd，所有模組檔案也會在所有全域內容後串接至這個檔案。

注意：除非 module 是 None、System 或 AMD，否則無法使用 outFile。此選項無法用於組合 CommonJS 或 ES6 模組。

不要在產生的程式碼中清除 const enum 宣告。const enum 提供一種方式，可以在執行階段透過發出 enum 值，而不是參考，來減少應用程式的整體記憶體使用量。

例如，使用此 TypeScript

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

預設的 const enum 行為是將任何 Album.Something 轉換為對應的數字文字，並從 JavaScript 中完全移除對 enum 的參考。