你用過 Partial、Required、Pick 和 Readonly 這些工具類型嗎?

你知道它們內(nèi)部是如何工作的嗎?如果你想徹底掌握它們且實現(xiàn)自己的工具類型，那么本文介紹的內(nèi)容千萬不要錯過。

在日常工作中，用戶注冊是一個很常見的場景。這里我們可以使用 TS 定義一個 User 類型，在該類型中所有的鍵都是必填的。

type User = {
  name: string; // 姓名
  password: string; // 密碼
  address: string; // 地址
  phone: string; // 聯(lián)系電話
};

通常情況下，對于已注冊的用戶，我們是允許用戶只修改部分用戶信息。這時我們就可以定義一個新的 UserPartial 類型，表示用于更新的用戶對象的類型，在該類型中所有的鍵都是可選的。

type UserPartial = {
  name?: string; // 姓名
  password?: string; // 密碼
  address?: string; // 地址
  phone?: string; // 聯(lián)系電話
};

而對于查看用戶信息的場景，我們希望該用戶對象所對應(yīng)的對象類型中所有的鍵都是只讀。針對這種需求，我們可以定義 ReadonlyUser 類型。

type ReadonlyUser = {
  readonly name: string; // 姓名
  readonly password: string; // 密碼
  readonly address: string; // 地址
  readonly phone: string; // 聯(lián)系電話
};

回顧前面已定義的與用戶相關(guān)的 3 種類型，你會發(fā)現(xiàn)它們中含有很多重復(fù)的代碼。

那么如何減少以上類型中的重復(fù)代碼呢?答案是可以使用映射類型，它是一種泛型類型，可用于把原有的對象類型映射成新的對象類型。

映射類型的語法如下：

{ [ P in K ] : T }

其中 P in K 類似于 JavaScript 中的 for...in 語句，用于遍歷 K 類型中的所有類型，而 T 類型變量用于表示 TS 中的任意類型。

在映射的過程中，你還可以使用 readonly 和 ? 這兩個額外的修飾符。通過添加 + 和 - 前綴，來增加和移除對應(yīng)的修飾符。如果沒有添加任何前綴的話，默認是使用 +。

現(xiàn)在我們就可以總結(jié)出常見的映射類型語法：

{ [ 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 操作符用于獲取某種類型中的所有鍵，其返回類型是聯(lián)合類型。而類型變量 P 會隨著每次遍歷改變成不同的類型，T[P] 該語法類似于屬性訪問的語法，用于獲取對象類型某個屬性對應(yīng)值的類型。

TypeScript 4.1 版本允許我們使用 as 子句對映射類型中的鍵進行重新映射。它的語法如下：

type MappedTypeWithNewKeys<T> = {
    [K in keyof T as NewKeyType]: T[K]
    //            ^^^^^^^^^^^^^
    //            這是新的語法!
}

其中 NewKeyType 的類型必須是 string | number | symbol 聯(lián)合類型的子類型。使用 as 子句，我們可以定義一個 Getters 工具類型，用于為對象類型生成對應(yīng)的 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;
//   };

看完本文之后，相信你已經(jīng)了解映射類型的作用了，也知道 TS 內(nèi)部一些工具類型是如何實現(xiàn)的。你喜歡以這種形式學(xué) TS 么?