never类型

typescript的never类型代表永不存在的值的类型，它只能被赋值为never。

任意类型与never交叉都得到never：

type T1 = number & never;   // never
type T2 = string & never;   // never
复制代码

可以这样理解：若type T = T1 & T2，则T类型的值可以赋给T1或T2类型的变量（类似类的继承关系）。 那么若与never交叉，则T类型的值可以赋给一个never类型的变量，那T只能是never了。

任意类型与never联合不受影响：

type T1 = number | never;   // number
type T2 = string | never;   // string
复制代码

理解与上述交叉类型情况类似： 若type T = T1 | T2，则T1或T2类型的值可以赋给T类型的变量。 由于never类型可以赋给任意变量，自然对联合类型不产生影响了。

keyof

typescript的keyof关键字，将一个类型映射为它所有成员名称的联合类型。如typescript官网上的示例:

interface Person {name: string;age: number;location: string;
}type K1 = keyof Person; // "name" | "age" | "location"
type K2 = keyof Person[];  // "length" | "push" | "pop" | "concat" | ...
type K3 = keyof { [x: string]: Person };  // string
复制代码

keyof实际给我们一个操作联合类型的途径。结合typescript的其他feature，如类型映射与索引类型，我们得以在对象类型与联合类型之间游刃有余地转换，为工程中更多变量找到最适合的类型归属。

应用

Diff Type

我们看一个来自这里的例子:

type Diff<T extends string, U extends string> = ({ [P in T]: P } & { [P in U]: never })[T];
type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>;
复制代码

下面一行不用过多解释了，在T类型中除去成员名在K中的成员。而上面一行代码特别有意思，也特别难看懂，它所做的是对于T与U两个字符串字面量类型，从T中除去包含在U中的那些字符串：

type A = Diff<"a" | "b" | "c", "a">;        // "b" | "c"
type B = Diff<"a" | "b" | "c", "b" | "d">;  // "a" | "c"
复制代码

它是如何做到的呢？我们首先看它的前面部分：

type FirstHalf<T extends string, U extends string> = { [P in T]: P } & { [P in U]: never }
type C = FirstHalf<"a" | "b" | "c", "b" | "d">;
// {//      "a": "a",
//      "b": "b",
//      "c": "c"
// } & {//      "b": never,
//      "d": never
// }
复制代码

我们再将type C做逐成员的交叉：

type C = {"a": "a","b": "b" & never,"c": "c","d": never
}
复制代码

任意类型与never交叉的结果都是never，因此

type C = {"a": "a","b": never,"c": "c","d": never
}复制代码

我们再看Diff类型：

type B = Diff<"a" | "b" | "c", "b" | "d">;= {"a": "a","b": never,"c": "c","d": never}["a" | "b" | "c"];= "a" | never | "c";= "a" | "c";
复制代码

这样就达到了前文所述的目的。

去除所有never成员

我们试图移除一个object type中所有类型为never的成员。可以这样操作：

type OmitNever<T> = Pick<T, {[P in keyof T]: T[P] extends never ? never : P}[keyof T]>;type T = {a: string,b: never,c: string,
}
type T1 = OmitNever<T>;     // { a: string, c: string }
复制代码

原理类似第一个例子。我们试图把T中所有非never成员的名称找出，从T中pick出来。所以先弄一个对象类型出来：

type OmitNeverHalf<T> = {[P in keyof T]: T[P] extends never ? never : P}type TT = OmitNeverHalf<T>;
// {
//     "a": "a",
//     "b": never,
//     "c": "c"
// }
复制代码

再用keyof T做一个索引类型，把对象类型变成联合类型，就得到了我们想要的那些成员名称。