在 TypeScript 中，內置工具類型（utility types）是一組預定義的類型，用于在類型層面上進行各種操作。對于 ts 開發者來說，開始使用這類工具是一個走出新手村的重要標志。截止至 2024 年 8 月，ts 官方共提供了 22 個內置的工具類型。大家可以在官網查看具體的文檔。當然，本文并不是來集中介紹這些類型的用法，我們要更近一步，來看看如何用更底層的類型方法來實現這些工具類型。
Record
我們先從最簡單的入手
Record<K, T> 將 K 中的每個屬性值轉化為 T 類型，例如：
type Animal = 'Dog' | 'Cat';
type AnimalRecord = Record<Animal, string>;
// type AnimalRecord = {
// Dog: string;
// Cat: string;
// }
Record 的實現如下：
type Record<K extends keyof any, T> = {
[P in K]: T;
};
type K = keyof any; // string | number | symbol
Record 是最最常用的一個工具類型，實現也極其簡單，只需要用到我們在上期中介紹的類型映射。簡單遍歷第一個泛型 K 的每一個屬性，并將屬性值都轉成第二個泛型 T 類型。 這里對 K 做了限制，就是它只能是 string、 number 和 symbol 的一種。我們再簡單展開一下， keyof any 等價于聯合類型string | number | symbol；如果是老手，你可能還會知道 ts 定義了一個原生類型 type PropertyKey = string | number | symbol，有時候偷個懶不想寫一大串string | number | symbol，可以直接使用PropertyKey秀一把。
Partial & Required & Readonly
Partial<T>： 將 T 的所有屬性變為可選，例如：
type Vegetable = {
Onion: string;
Garlic: number;
};
type PartialVegetable = Partial<Vegetable>;
// type PartialVegetable = {
// Onion?: string;
// Garlic?: number;
// }
Partial 的實現如下：
type Partial<T> = {
[P in keyof T]?: T[P];
};
這里有個知識點： 在冒號前加個 ? （等價于+?）就表示該鍵值的類型是可選類型（即有可能是 undefined）.
Required<T>： 把所有屬性變成必選
有 +? 操作，自然也有 -?，Required 就是Partial的反向操作：
type Required<T> = {
[P in keyof T]-?: T[P];
};
type Vegetable = {
Onion？: string;
Garlic？: number;
};
type RequiredVegetable = Required<Vegetable>;
// type RequiredVegetable = {
// Onion: string;
// Garlic: number;
// }
Readonly<T>： 將所有屬性變成只讀
類似加減 ? 的操作還有一個就是：加減 readonly，只不過 readonly 要放在屬性的最前面。
再看看 Readonly 的實現（這里readonly等價于+readonly）：
type Readonly<T> = {
readonly [P in keyof T]: T[P];
};
正好，我們再做個練習題： Mutable
實現通用的
Mutable<T>, 使得T中的所有屬性都是可變的(不是只讀的)
interface Todo {
readonly title: string;
readonly completed: boolean;
}
type MutableTodo = Mutable<Todo>; // { title: string; completed: boolean; }
很簡單，-readonly 就行
type Mutable<T extends object> = {
-readonly [K in keyof T]: T[K];
};
Exclude & Extract & Pick & Omit
我們稍增加一點難度，實現一些有兩個泛型的類型
Exclude<T, U>: 從T中剔除那些可賦值給U的類型
Exclude主要用戶聯合類型的造作。如下所示從聯合類型 a' | 'b' 中剔除c ( c 是 'a' | 'c'的子集 ) 得到 b
type C = Exclude<'a' | 'b', 'a' | 'c'>; // 'b'
答案很簡單直接用 extends 判斷就行了：
type Exclude<T, U> = T extends U ? never : T;
不過這里要補充個 extends 的知識點，
T extends U ? never : T 實際執行時是對聯合類型T里的每一個元素分別進行條件判斷，然后對每一個條件判斷的結果再組裝成新的聯合類型。以 Exclude<'a' | 'b', 'a' | 'c'> 為例：實際執行時
- 等于
('a' extends 'a' | 'c' ? never : 'a') | ('b' extends 'a' | 'c' ? never: 'b')； - 等于
(never) | ('b')； - 等于
'b'（任何元素和never的聯合類型等于其本身）
聯合類型的條件判斷本質上在進行“遍歷”，這是個很有趣的語法特性。我們這里暫不展開了，之后我會在實際的案例中解釋如何用這個特性解決一些需要依靠遍歷來破解的問題。
Extract<T, U>： 從T中提取可賦值給U的類型
Exclude的反向操作就是Extract，就是剔除不包含在U里的類型。這個太簡單了，一筆帶過：
type Extract<T, U> = T extends U ? T : never;
Pick<T, K>： 從 T 中，提取出所有鍵值在聯合類型 K 中的屬性
如下所示，我只想保留 Todo 類型里的 title 和 completed鍵值對：
interface Todo {
title: string;
description: string;
completed: boolean;
}
type TodoPreview = Pick<Todo, 'title' | 'completed'>;
// type TodoPreview = {
// title: string,
// completed: boolean
// }
對Pick<T, K>，這里有兩個考點:
-
K的取值：K應該是T里已經存在的鍵值，比如你傳個hello需要拋錯 -
K是個聯合類型，所以需要遍歷
我們看看實現：
type Pick<T, K extends keyof T> = {
[P in K]: T[P];
};
答案還是一個簡單的類型映射：
- 通過
K extends keyof T限定 K 必須是T的所有鍵值的子集 - 用個
in遍歷K就行了 （in keyof不是固定組合……）
Omit<T, K>: 構造一個除類型K以外具有T屬性的類型。
Omit是Pick的反向操作，排除對象 T 中的 K 鍵值。 Omit在名字上容易和Exclude搞混。記住 Exclude 主要用在聯合類型，而Omit主要用于對象類型上。如下所示，我要剔除Todo里的description和title兩個鍵值對：
type TodoPreview = Omit<Todo, 'description' | 'title'>;
// type TodoPreview = {
// completed: false,
// }
Omit<T, K> 對K沒有特別限制，只需要是正常的JS對象鍵類型（string | number | symbol）就是了。實現上正好活用一下上面剛提到的方法類型——Pick和Exclude：
- 從T的所有鍵中剔除(
Exclude)掉聯合類型K（Exclude<keyof T, K>） - 提取（
Pick）出所有鍵值在上一步得到的結果中的屬性
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
小結
由于篇幅所限，我們暫時先介紹8個最簡單，但又是最貼近實戰的工具方法。當你開始使用這些工具類型時，你的新手村小伙伴們一定會眼前一亮的。之后的文章，我會進一步介紹剩下的內置工具類型，當然他們更加復雜也更能幫助我們提升認知。敬請期待。
文章同步發布于an-Onion 的 Github。碼字不易，歡迎點贊。
