日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
TypeScript中高級應用與完美實踐

 當我們討論 TypeScript 時，我們在討論什么？

主要從事網(wǎng)頁設計、PC網(wǎng)站建設（電腦版網(wǎng)站建設）、wap網(wǎng)站建設（手機版網(wǎng)站建設）、成都響應式網(wǎng)站建設公司、程序開發(fā)、微網(wǎng)站、小程序定制開發(fā)等，憑借多年來在互聯(lián)網(wǎng)的打拼，我們在互聯(lián)網(wǎng)網(wǎng)站建設行業(yè)積累了豐富的網(wǎng)站設計制作、成都網(wǎng)站設計、網(wǎng)絡營銷經(jīng)驗，集策劃、開發(fā)、設計、營銷、管理等多方位專業(yè)化運作于一體，具備承接不同規(guī)模與類型的建設項目的能力。

TypeScript 的定位

  • JavaScript 的超集
  • 編譯期行為
  • 不引入額外開銷
  • 不改變運行時行為
  • 始終與 ESMAScript 語言標準一致 (stage 3 語法)

TypeScript 中的 Decorator 較為特殊，為 Angular 團隊和 TypeScript 團隊交易的結(jié)果，有興趣可自行搜索相關資料。而且近期 EcmaScript 規(guī)范中的 decorator 提案內(nèi)容發(fā)生了劇烈變動，建議等此語法標準完全穩(wěn)定后再在生產(chǎn)項目中使用。

本文只討論圖中藍色部分。

類型的本質(zhì)是契約

JSDoc 也能標注類型，為什么要用 TypeScript？

  • JSDoc 只是注釋，其標注沒有約束作用
  • TS 有—checkJs 選項，但不好用

TS 會自動推斷函數(shù)返回值類型，為什么要多此一舉標注出來？

  • 契約高于實現(xiàn)
  • 檢查返回值是否寫錯
  • 寫 return 時獲得提醒

開始之前

幾組 VSCode 快捷鍵

  • 代碼補全 control + 空格 ctrl + 空格
  • 快速修復 command + . ctrl + .
  • 重構(gòu)（重命名） fn + f2 f2

一個網(wǎng)站

TypeScript Playground

初始化項目

自行配置

 
 
 
 
    
  
  
  
  
  1. "compilerOptions": { 
    2.   
  
  
  
  2.     "esModuleInterop": true, 
    3.   
  
  
  
  3.     "allowSyntheticDefaultImports": true, 
    4.   
  
  
  
  4.     "noImplicitAny": true, 
    5.   
  
  
  
  5.     "strictNullChecks": true, 
    6.   
  
  
  
  6.     "noImplicitThis": true, 
    7.   
  
  
  
  7.     "moduleResolution": "node" 
    8.   
  
  
  
  8. } 
    9.   
  
  
  
  9.   
    10.

react 項目運行 create-react-app ${項目名} —scripts-version=react-scripts-ts

小試牛刀

&和 | 操作符

雖然在寫法上，這兩個操作符與位運算邏輯操作符相同。但在語義上，它們與位運算剛好相反。

位運算的表現(xiàn)：

 
 
 
 
    
  
  
  
  
  1. 1001 | 1010 = 1011    // 合并1 
    2.   
  
  
  
  2. 1001 & 1010 = 1000    // 只保留共有1 
    3.

在 TypeScript 中的表現(xiàn)：

 
 
 
 
    
  
  
  
  
  1. interface IA { 
    2.   
  
  
  
  2.     a: string 
    3.   
  
  
  
  3.     b: number 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5.   
    6.   
  
  
  
  6. type TB = { 
    7.   
  
  
  
  7.     b: number 
    8.   
  
  
  
  8.     c: number[] 
    9.   
  
  
  
  9. } 
    10.   
  
  
  
  10.   
    11.   
  
  
  
  11. type TC = IA | TB;    // TC類型的變量的鍵只需包含ab或bc即可，當然也可以abc都有 
    12.   
  
  
  
  12. type TD = IA & TB;    // TD類型的變量的鍵必需包含abc 
    13.

對于這種表現(xiàn)，可以這樣理解： & 表示必須同時滿足多個契約， | 表示滿足任意一個契約即可。

interface 和 type 關鍵字

interface 和 type 兩個關鍵字因為其功能比較接近，常常引起新手的疑問：應該在什么時候用 type，什么時候用 interface？

interface 的特點如下：

  • 同名 interface 自動聚合，也可以和已有的同名 class 聚合，適合做 polyfill
  • 自身只能表示 object/class/function 的類型

建議庫的開發(fā)者所提供的公共 api 應該盡量用 interface/class，方便使用者自行擴展。舉個例子，我之前在給騰訊云 Cloud Studio 在線編輯器開發(fā)插件時，因為查閱到的 monaco 文檔是 0.15.5 版本（當時的最新版本）的，而 Cloud Studio 使用的 monaco 版本為 0.14.3，缺失了一些我需要的 API，所以需要手動 polyfill 一下。

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * Cloud Studio使用的monaco版本較老0.14.3，和官方文檔相比缺失部分功能 
    3.   
  
  
  
  3.  * 另外vscode有一些特有的功能，必須適配 
    4.   
  
  
  
  4.  * 故在這里手動實現(xiàn)作為補充 
    5.   
  
  
  
  5.  */ 
    6.   
  
  
  
  6. declare module monaco { 
    7.   
  
  
  
  7.   interface Position { 
    8.   
  
  
  
  8.     delta(deltaLineNumber?: number, deltaColumn?: number): Position 
    9.   
  
  
  
  9.   } 
    10.   
  
  
  
  10. } 
    11.   
  
  
  
  11.   
    12.   
  
  
  
  12. // monaco 0.15.5 
    13.   
  
  
  
  13. monaco.Position.prototype.delta = function (this: monaco.Position, deltaLineNumber = 0, deltaColumn = 0) { 
    14.   
  
  
  
  14.   return new monaco.Position(this.lineNumber + deltaLineNumber, this.column + deltaColumn); 
    15.   
  
  
  
  15. } 
    16.   
  
  
  
  16.   
    17.

與 interface 相比，type 的特點如下：

  • 表達功能更強大，不局限于 object/class/function
  • 要擴展已有 type 需要創(chuàng)建新 type，不可以重名
  • 支持更復雜的類型操作
 
 
 
 
    
  
  
  
  
  1. type Tuple = [number, string]; 
    2.   
  
  
  
  2. const a: Tuple = [2, 'sir']; 
    3.   
  
  
  
  3. type Size = 'small' | 'default' | 'big' | number; 
    4.   
  
  
  
  4. const b: Size = 24; 
    5.

基本上所有用 interface 表達的類型都有其等價的 type 表達。但我在實踐的過程中，也發(fā)現(xiàn)了一種類型只能用 interface 表達，無法用 type 表達，那就是往函數(shù)上掛載屬性。

 
 
 
 
    
  
  
  
  
  1. interface FuncWithAttachment { 
    2.   
  
  
  
  2.     (param: string): boolean; 
    3.   
  
  
  
  3.     someProperty: number; 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5.   
    6.   
  
  
  
  6. const testFunc: FuncWithAttachment = ...; 
    7.   
  
  
  
  7. const result = testFunc('mike');    // 有類型提醒 
    8.   
  
  
  
  8. testFunc.someProperty = 3;    // 有類型提醒 
    9.

extends 關鍵字

extends 本意為 “拓展”，也有人稱其為 “繼承”。在 TypeScript 中，extends 既可當作一個動詞來擴展已有類型；也可當作一個形容詞來對類型進行條件限定（例如用在泛型中）。在擴展已有類型時，不可以進行類型沖突的覆蓋操作。例如，基類型中鍵 a 為 string，在擴展出的類型中無法將其改為 number。

 
 
 
 
    
  
  
  
  
  1. type A = { 
    2.   
  
  
  
  2.     a: number 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4.   
    5.   
  
  
  
  5. interface AB extends A { 
    6.   
  
  
  
  6.     b: string 
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8. // 與上一種等價 
    9.   
  
  
  
  9. type TAB = A & { 
    10.   
  
  
  
  10.     b: string 
    11.   
  
  
  
  11. } 
    12.

泛型

在前文我們已經(jīng)看到類型實際上可以進行一定的運算，要想寫出的類型適用范圍更廣，不妨讓它像函數(shù)一樣可以接受參數(shù)。TS 的泛型便是起到這樣的作用，你可以把它當作類型的參數(shù)。它和函數(shù)參數(shù)一樣，可以有默認值。除此之外，還可以用 extends 對參數(shù)本身需要滿足的條件進行限制。

在定義一個函數(shù)、type、interface、class 時，在名稱后面加上<> 表示即接受類型參數(shù)。而在實際調(diào)用時，不一定需要手動傳入類型參數(shù)，TS 往往能自行推斷出來。在 TS 推斷不準時，再手動傳入?yún)?shù)來糾正。

 
 
 
 
    
  
  
  
  
  1. // 定義 
    2.   
  
  
  
  2. class React.Component { ... } 
    3.   
  
  
  
  3. interface IShowConfig { ... } 
    4.   
  
  
  
  4. // 調(diào)用 
    5.   
  
  
  
  5. class Modal extends React.Component { ... } 
    6.

條件類型

除了與、或等基本邏輯，TS 的類型也支持條件運算，其語法與三目運算符相同，為 T extends U ? X : Y 。這里先舉一個簡單的例子。在后文中我們會看到很多復雜類型的實現(xiàn)都需要借助條件類型。

 
 
 
 
    
  
  
  
  
  1. type IsEqualType = A extends B ? (B extends A ? true : false) : false; 
    2.   
  
  
  
  2. type NumberEqualsToString = IsEqualType;   // false 
    3.   
  
  
  
  3. type NumberEqualsToNumber = IsEqualType;    // true 
    4.

環(huán)境 Ambient Modules

在實際應用開發(fā)時有一種場景，當前作用域下可以訪問某個變量，但這個變量并不由開發(fā)者控制。例如通過 Script 標簽直接引入的第三方庫 CDN、一些宿主環(huán)境的 API 等。這個時候可以利用 TS 的環(huán)境聲明功能，來告訴 TS 當前作用域可以訪問這些變量，以獲得類型提醒。

具體有兩種方式，declare 和三斜線指令。

 
 
 
 
    
  
  
  
  
  1. declare const IS_MOBILE = true;    // 編譯后此行消失 
    2.   
  
  
  
  2. const wording = IS_MOBILE ? '移動端' : 'PC端'; 
    3.

用三斜線指令可以一次性引入整個類型聲明文件。

 
 
 
 
    
  
  
  
  
  1. ///  
    2.   
  
  
  
  2. const range = new monaco.Range(2, 3, 6, 7); 
    3.

深入類型系統(tǒng)

基本類型

基本類型，也可以理解為原子類型。包括 number、boolean、string、null、undefined、function、array、字面量（true，false，1，2，‘a(chǎn)’）等。它們無法再細分。

復合類型

TypeScript 的復合類型可以分為兩類： set 和 map 。set 是指一個無序的、無重復元素的集合。而 map 則和 JS 中的對象一樣，是一些沒有重復鍵的鍵值對。

 
 
 
 
    
  
  
  
  
  1. // set 
    2.   
  
  
  
  2. type Size = 'small' | 'default' | 'big' | 'large'; 
    3.   
  
  
  
  3. // map 
    4.   
  
  
  
  4. interface IA { 
    5.   
  
  
  
  5.     a: string 
    6.   
  
  
  
  6.     b: number 
    7.   
  
  
  
  7. } 
    8.

復合類型間的轉(zhuǎn)換

 
 
 
 
    
  
  
  
  
  1. // map => set 
    2.   
  
  
  
  2. type IAKeys = keyof IA;    // 'a' | 'b' 
    3.   
  
  
  
  3. type IAValues = IA[keyof IA];    // string | number 
    4.   
  
  
  
  4.   
    5.   
  
  
  
  5. // set => map 
    6.   
  
  
  
  6. type SizeMap = { 
    7.   
  
  
  
  7.     [k in Size]: number 
    8.   
  
  
  
  8. } 
    9.   
  
  
  
  9. // 等價于 
    10.   
  
  
  
  10. type SizeMap2 = { 
    11.   
  
  
  
  11.     small: number 
    12.   
  
  
  
  12.     default: number 
    13.   
  
  
  
  13.     big: number 
    14.   
  
  
  
  14.     large: number 
    15.   
  
  
  
  15. } 
    16.

map 上的操作

 
 
 
 
    
  
  
  
  
  1. // 索引取值 
    2.   
  
  
  
  2. type SubA = IA['a'];    // string     
    3.   
  
  
  
  3.   
    4.   
  
  
  
  4. // 屬性修飾符 
    5.   
  
  
  
  5. type Person = { 
    6.   
  
  
  
  6.     age: number 
    7.   
  
  
  
  7.     readonly name: string    // 只讀屬性，初始化時必須賦值 
    8.   
  
  
  
  8.     nickname?: string    // 可選屬性，相當于 | undefined 
    9.   
  
  
  
  9. } 
    10.

映射類型和同態(tài)變換

在 TypeScript 中，有以下幾種常見的映射類型。它們的共同點是只接受一個傳入類型，生成的類型中 key 都來自于 keyof 傳入的類型，value 都是傳入類型的 value 的變種。

 
 
 
 
    
  
  
  
  
  1. type Partial = { [P in keyof T]?: T[P] }    // 將一個map所有屬性變?yōu)榭蛇x的 
    2.   
  
  
  
  2. type Required = { [P in keyof T]-?: T[P] }    // 將一個map所有屬性變?yōu)楸剡x的 
    3.   
  
  
  
  3. type Readonly = { readonly [P in keyof T]: T[P] }    // 將一個map所有屬性變?yōu)橹蛔x的 
    4.   
  
  
  
  4. type Mutable = { -readonly [P in keyof T]: T[P] }    // ts標準庫未包含，將一個map所有屬性變?yōu)榭蓪懙?nbsp;
    5.

此類變換，在 TS 中被稱為同態(tài)變換。在進行同態(tài)變換時，TS 會先復制一遍傳入?yún)?shù)的屬性修飾符，再應用定義的變換。

 
 
 
 
    
  
  
  
  
  1. interface Fruit { 
    2.   
  
  
  
  2.     readonly name: string 
    3.   
  
  
  
  3.     size: number 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5. type PF = Partial;    // PF.name既只讀又可選，PF.size只可選 
    6.

其他常用工具類型

由 set 生成 map

 
 
 
 
    
  
  
  
  
  1. type Record = { [P in K]: T }; 
    2.   
  
  
  
  2.   
    3.   
  
  
  
  3. type Size = 'small' | 'default' | 'big'; 
    4.   
  
  
  
  4. /* 
    5.   
  
  
  
  5. { 
    6.   
  
  
  
  6.     small: number 
    7.   
  
  
  
  7.     default: number 
    8.   
  
  
  
  8.     big: number 
    9.   
  
  
  
  9. } 
    10.   
  
  
  
  10.  */ 
    11.   
  
  
  
  11. type SizeMap = Record; 
    12.

保留 map 的一部分

 
 
 
 
    
  
  
  
  
  1. type Pick = { [P in K]: T[P] }; 
    2.   
  
  
  
  2. /* 
    3.   
  
  
  
  3. { 
    4.   
  
  
  
  4.     default: number 
    5.   
  
  
  
  5.     big: number 
    6.   
  
  
  
  6. } 
    7.   
  
  
  
  7.  */ 
    8.   
  
  
  
  8. type BiggerSizeMap = Pick; 
    9.   
  
  
  
  9.   
    10.

刪除 map 的一部分

 
 
 
 
    
  
  
  
  
  1. type Omit = Pick>; 
    2.   
  
  
  
  2. /* 
    3.   
  
  
  
  3. { 
    4.   
  
  
  
  4.     default: number 
    5.   
  
  
  
  5. } 
    6.   
  
  
  
  6.  */ 
    7.   
  
  
  
  7. type DefaultSizeMap = Omit; 
    8.

保留 set 的一部分

 
 
 
 
    
  
  
  
  
  1. type Extract = T extends U ? T : never; 
    2.   
  
  
  
  2.   
    3.   
  
  
  
  3. type Result = 1 | 2 | 3 | 'error' | 'success'; 
    4.   
  
  
  
  4. type StringResult = Extract;    // 'error' | 'success 
    5.

刪除 set 的一部分

 
 
 
 
    
  
  
  
  
  1. type Exclude = T extends U ? never : T; 
    2.   
  
  
  
  2. type NumericResult = Exclude;    // 1 | 2 | 3 
    3.

獲取函數(shù)返回值的類型。但要注意不要濫用這個工具類型，應該盡量多手動標注函數(shù)返回值類型。理由開篇時提過， 契約高于實現(xiàn) 。用 ReturnType 是由實現(xiàn)反推契約，而實現(xiàn)往往容易變且容易出錯，契約則相對穩(wěn)定。另一方面，ReturnType 過多也會降低代碼可讀性。

 
 
 
 
    
  
  
  
  
  1. type ReturnType = T extends (...args: any[]) => infer R ?  R : any; 
    2.   
  
  
  
  2.   
    3.   
  
  
  
  3. function f() { return { a: 3, b: 2}; } 
    4.   
  
  
  
  4. /* 
    5.   
  
  
  
  5. { 
    6.   
  
  
  
  6.     a: number 
    7.   
  
  
  
  7.     b: number 
    8.   
  
  
  
  8. } 
    9.   
  
  
  
  9.  */ 
    10.   
  
  
  
  10. type FReturn = ReturnType; 
    11.

以上這些工具類型都已經(jīng)包含在了 TS 標準庫中，在應用中直接輸入名字進行使用即可。另外，在這些工具類型的實現(xiàn)中，出現(xiàn)了 infer、never、typeof 等關鍵字，在后文我會詳細解釋它們的作用。

類型的遞歸

TS 原生的 Readonly 只會限制一層寫入操作，我們可以利用遞歸來實現(xiàn)深層次的 Readonly。但要注意，TS 對最大遞歸層數(shù)做了限制，最多遞歸 5 層。

 
 
 
 
    
  
  
  
  
  1. type DeepReadony = { 
    2.   
  
  
  
  2.     readonly [P in keyof T]: DeepReadony 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4.   
    5.   
  
  
  
  5. interface SomeObject { 
    6.   
  
  
  
  6.   a: { 
    7.   
  
  
  
  7.     b: { 
    8.   
  
  
  
  8.       c: number; 
    9.   
  
  
  
  9.     }; 
    10.   
  
  
  
  10.   }; 
    11.   
  
  
  
  11. } 
    12.   
  
  
  
  12.   
    13.   
  
  
  
  13. const obj: Readonly = { a: { b: { c: 2 } } }; 
    14.   
  
  
  
  14. obj.a.b.c = 3;    // TS不會報錯 
    15.   
  
  
  
  15.   
    16.   
  
  
  
  16. const obj2: DeepReadony = { a: { b: { c: 2 } } }; 
    17.   
  
  
  
  17. obj2.a.b.c = 3;    // Cannot assign to 'c' because it is a read-only property. 
    18.

never infer typeof 關鍵字

never 是 | 運算的幺元，即 x | never = x 。例如之前的 Exclude 運算過程如下：

infer 的作用是讓 TypeScript 自己推斷，并將推斷的結(jié)果存儲到一個臨時名字中，并且只能用于 extends 語句中。它與泛型的區(qū)別在于，泛型是聲明一個 “參數(shù)”，而 infer 是聲明一個 “中間變量”。infer 我用得比較少，這里借用一下官方的示例。

 
 
 
 
    
  
  
  
  
  1. type Unpacked = 
    2.   
  
  
  
  2.     T extends (infer U)[] ? U : 
    3.   
  
  
  
  3.     T extends (...args: any[]) => infer U ? U : 
    4.   
  
  
  
  4.     T extends Promise ? U : 
    5.   
  
  
  
  5.     T; 
    6.   
  
  
  
  6.   
    7.   
  
  
  
  7. type T0 = Unpacked;  // string 
    8.   
  
  
  
  8. type T1 = Unpacked;  // string 
    9.   
  
  
  
  9. type T2 = Unpacked<() => string>;  // string 
    10.   
  
  
  
  10. type T3 = Unpacked>;  // string 
    11.   
  
  
  
  11. type T4 = Unpacked[]>;  // Promise 
    12.   
  
  
  
  12. type T5 = Unpacked[]>>;  // string 
    13.

typeof 用于獲取一個 “常量” 的類型，這里的 “常量” 是指任何可以在編譯期確定的東西，例如 const、function、class 等。它是從 實際運行代碼 通向 類型系統(tǒng) 的單行道。理論上，任何運行時的符號名想要為類型系統(tǒng)所用，都要加上 typeof。但是 class 比較特殊不需要加，因為 ts 的 class 出現(xiàn)得比 js 早，現(xiàn)有的為兼容性解決方案。

在使用 class 時， class 名 表示實例類型， typeof class 表示 class 本身類型。沒錯，這個關鍵字和 js 的 typeof 關鍵字重名了 :)。

 
 
 
 
    
  
  
  
  
  1. const config = { width: 2, height: 2 }; 
    2.   
  
  
  
  2. function getLength(str: string) { return str.length; } 
    3.   
  
  
  
  3.   
    4.   
  
  
  
  4. type TConfig = typeof config;    // { width: number, height: number } 
    5.   
  
  
  
  5. type TGetLength = typeof getLength;    // (str: string) => number 
    6.

實戰(zhàn)演練

我在項目中遇到這樣一種場景，需要獲取一個類型中所有 value 為指定類型的 key。例如，已知某個 React 組件的 props 類型，我需要 “知道”（編程意義上）哪些參數(shù)是 function 類型。

 
 
 
 
    
  
  
  
  
  1. interface SomeProps { 
    2.   
  
  
  
  2.     a: string 
    3.   
  
  
  
  3.     b: number 
    4.   
  
  
  
  4.     c: (e: MouseEvent) => void 
    5.   
  
  
  
  5.     d: (e: TouchEvent) => void 
    6.   
  
  
  
  6. } 
    7.   
  
  
  
  7. // 如何得到 'c' | 'd' ？  
    8.

分析一下這里的思路，我們需要從一個 map 得到一個 set，而這個 set 是 map 的 key 的 子集，篩選子集的 條件 是 value 的類型。要構(gòu)造 set 的子集，需要用到 never ；要實現(xiàn)條件判斷，需要用到 extends ；而要實現(xiàn) key 到 value 的訪問，則需要索引取值。經(jīng)過一些嘗試后，解決方案如下。

 
 
 
 
    
  
  
  
  
  1. type GetKeyByValueType = { 
    2.   
  
  
  
  2.     [K in keyof T]: T[K] extends Condition ? K : never 
    3.   
  
  
  
  3. } [keyof T]; 
    4.   
  
  
  
  4.   
    5.   
  
  
  
  5. type FunctionPropNames =  GetKeyByValueType;    // 'c' | 'd' 
    6.

這里的運算過程如下：

 
 
 
 
    
  
  
  
  
  1. // 開始 
    2.   
  
  
  
  2. { 
    3.   
  
  
  
  3.     a: string 
    4.   
  
  
  
  4.     b: number 
    5.   
  
  
  
  5.     c: (e: MouseEvent) => void 
    6.   
  
  
  
  6.     d: (e: TouchEvent) => void 
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8. // 第一步，條件映射 
    9.   
  
  
  
  9. { 
    10.   
  
  
  
  10.     a: never 
    11.   
  
  
  
  11.     b: never 
    12.   
  
  
  
  12.     c: 'c' 
    13.   
  
  
  
  13.     d: 'd' 
    14.   
  
  
  
  14. } 
    15.   
  
  
  
  15. // 第二步，索引取值 
    16.   
  
  
  
  16. never | never | 'c' | 'd' 
    17.   
  
  
  
  17. // never的性質(zhì) 
    18.   
  
  
  
  18. 'c' | 'd' 
    19.

編譯提示 Compiler Hints

TypeScript 只發(fā)生在編譯期，因此我們可以在代碼中加入一些符號，來給予編譯器一些提示，使其按我們要求的方式運行。

類型轉(zhuǎn)換

類型轉(zhuǎn)換的語法為 < 類型名> xxx 或 xxx as 類型名 。推薦始終用 as 語法，因為第一種語法無法在 tsx 文件使用，而且容易和泛型混淆。一般只有這幾種場景需要使用類型轉(zhuǎn)換：自動推斷不準；TS 報錯，想不出更好的類型編寫方法，手動抄近路；臨時 “放飛自我”。

在使用類型轉(zhuǎn)換時，應該遵守幾個原則：

  • 若要放松限制，只可放松到能運行的最嚴格類型上
  • 如果不知道一個變量的精確類型，只標注到大概類型（例如 any[]）也比 any 好
  • 任何一段 “放飛自我”（完全沒有類型覆蓋）區(qū)代碼不應超過 2 行，應在出現(xiàn)第一個可以確定類型的變量時就補上標注

在編寫 TS 程序時，我們的目標是讓類型覆蓋率無限接近 100%。

! 斷言

! 的作用是斷言某個變量不會是 null / undefined，告訴編譯器停止報錯。這里由用戶確保斷言的正確。它和剛剛進入 EcmaScript 語法提案 stage 3 的 Optional Chaining 特性不同。Optional Chaining 特性可以保證訪問的安全性，即使在 undefined 上訪問某個鍵也不會拋出異常。而 ! 只是消除編譯器報錯，不會對運行時行為造成任何影響。

 
 
 
 
    
  
  
  
  
  1. // TypeScript 
    2.   
  
  
  
  2. mightBeUndefined!.a = 2 
    3.   
  
  
  
  3. // 編譯為 
    4.   
  
  
  
  4. mightBeUndefined.a = 2 
    5.

// @ts-ignore

用于忽略下一行的報錯，盡量少用。

其他

我為什么不提 enum

enum 在 TS 中出現(xiàn)的比較早，它引入了 JavaScript 沒有的數(shù)據(jù)結(jié)構(gòu)（編譯成一個雙向 map），入侵了運行時，與 TypeScript 宗旨不符。用 string literal union（'small' | 'big' | 'large'）可以做到相同的事，且在 debug 時可讀性更好。如果很在意條件比較的性能，應該用二進制 flag 加位運算。

 
 
 
 
    
  
  
  
  
  1. // TypeScript 
    2.   
  
  
  
  2. enum Size { 
    3.   
  
  
  
  3.     small = 3, 
    4.   
  
  
  
  4.     big, 
    5.   
  
  
  
  5.     large 
    6.   
  
  
  
  6. } 
    7.   
  
  
  
  7. const a:Size = Size.large;    // 5 
    8.   
  
  
  
  8.   
    9.   
  
  
  
  9. // 編譯為 
    10.   
  
  
  
  10. var Size; 
    11.   
  
  
  
  11. (function (Size) { 
    12.   
  
  
  
  12.     Size[Size["small"] = 3] = "small"; 
    13.   
  
  
  
  13.     Size[Size["big"] = 4] = "big"; 
    14.   
  
  
  
  14.     Size[Size["large"] = 5] = "large"; 
    15.   
  
  
  
  15. })(Size || (Size = {})); 
    16.   
  
  
  
  16. const a = Size.large; // 5 
    17.

寫在最后

應該以什么心態(tài)來編寫 TypeScript

我們應該編寫有類型系統(tǒng)的 JavaScript，而不是能編譯成 JavaScript 的 Java/C#。任何一個 TypeScript 程序，在手動刪去類型部分，將后綴改成 .js 后，都應能夠正常運行。


本文標題：TypeScript中高級應用與完美實踐
文章地址：http://www.dlmjj.cn/article/djeehcg.html