用了 TS 映射類型，同事直呼內行！
你用過 Partial、Required、Pick 和 Readonly 這些工具類型嗎?
你知道它們內部是如何工作的嗎?如果你想徹底掌握它們且實現自己的工具類型，那么本文介紹的內容千萬不要錯過。
在日常工作中，用戶注冊是一個很常見的場景。這里我們可以使用 TS 定義一個 User 類型，在該類型中所有的鍵都是必填的。
type User = {
name: string; // 姓名
password: string; // 密碼
address: string; // 地址
phone: string; // 聯系電話
};
通常情況下，對于已注冊的用戶，我們是允許用戶只修改部分用戶信息。這時我們就可以定義一個新的 UserPartial 類型，表示用于更新的用戶對象的類型，在該類型中所有的鍵都是可選的。
type UserPartial = {
name?: string; // 姓名
password?: string; // 密碼
address?: string; // 地址
phone?: string; // 聯系電話
};
而對于查看用戶信息的場景，我們希望該用戶對象所對應的對象類型中所有的鍵都是只讀。針對這種需求，我們可以定義 ReadonlyUser 類型。
type ReadonlyUser = {
readonly name: string; // 姓名
readonly password: string; // 密碼
readonly address: string; // 地址
readonly phone: string; // 聯系電話
};
回顧前面已定義的與用戶相關的 3 種類型，你會發現它們中含有很多重復的代碼。
那么如何減少以上類型中的重復代碼呢?答案是可以使用映射類型，它是一種泛型類型，可用于把原有的對象類型映射成新的對象類型。
映射類型的語法如下：
{ [ P in K ] : T }其中 P in K 類似于 JavaScript 中的 for...in 語句，用于遍歷 K 類型中的所有類型，而 T 類型變量用于表示 TS 中的任意類型。
在映射的過程中，你還可以使用 readonly 和 ? 這兩個額外的修飾符。通過添加 + 和 - 前綴，來增加和移除對應的修飾符。如果沒有添加任何前綴的話，默認是使用 +。
現在我們就可以總結出常見的映射類型語法：
{ [ P in K ] : T }
{ [ P in K ] ?: T }
{ [ P in K ] -?: T }
{ readonly [ P in K ] : T }
{ readonly [ P in K ] ?: T }
{ -readonly [ P in K ] ?: T }介紹完映射類型的語法，我們來看一些具體的例子：
type Item = { a: string; b: number; c: boolean };
type T1 = { [P in "x" | "y"]: number }; // { x: number, y: number }
type T2 = { [P in "x" | "y"]: P }; // { x: "x", y: "y" }
type T3 = { [P in "a" | "b"]: Item[P] }; // { a: string, b: number }
type T4 = { [P in keyof Item]: Item[P] }; // { a: string, b: number, c: boolean }
下面我們來看一下如何利用映射類型來重新定義 UserPartial 類型：
type MyPartial<T> = {
[P in keyof T]?: T[P];
};
type UserPartial = MyPartial<User>;
在以上代碼中，我們定義了 MyPartial 映射類型，然后利用該類型把 User 類型映射成 UserPartial 類型。
其中 keyof 操作符用于獲取某種類型中的所有鍵，其返回類型是聯合類型。而類型變量 P 會隨著每次遍歷改變成不同的類型，T[P] 該語法類似于屬性訪問的語法，用于獲取對象類型某個屬性對應值的類型。
TypeScript 4.1 版本允許我們使用 as 子句對映射類型中的鍵進行重新映射。它的語法如下：
type MappedTypeWithNewKeys<T> = {
[K in keyof T as NewKeyType]: T[K]
// ^^^^^^^^^^^^^
// 這是新的語法!
}
其中 NewKeyType 的類型必須是 string | number | symbol 聯合類型的子類型。使用 as 子句，我們可以定義一個 Getters 工具類型，用于為對象類型生成對應的 Getter 類型：
type Getters<T> = {
[K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
interface Person {
name: string;
age: number;
location: string;
}
type LazyPerson = Getters<Person>;
// {
// getName: () => string;
// getAge: () => number;
// getLocation: () => string;
// }
在以上代碼中，因為 keyof T 返回的類型可能會包含 symbol 類型，而 Capitalize 工具類型要求處理的類型需要是 string 類型的子類型，所以需要通過交叉運算符進行類型過濾。
此外，在對鍵進行重新映射的過程中，我們可以通過返回 never 類型對鍵進行過濾：
// Remove the 'kind' property
type RemoveKindField<T> = {
[K in keyof T as Exclude<K, "kind">]: T[K]
};
interface Circle {
kind: "circle";
radius: number;
}
type KindlessCircle = RemoveKindField<Circle>;
// type KindlessCircle = {
// radius: number;
// };
看完本文之后，相信你已經了解映射類型的作用了，也知道 TS 內部一些工具類型是如何實現的。你喜歡以這種形式學 TS 么?
