一、交叉类型 (Intersection Types)

交叉类型是将多个类型合并为一个类型。这让我们 可以把现有的多种类型叠加到一起成为一种类型,它包含了所需要的所有类型的特性。

比如:Person & Serializable & Loggable 同时是 PersonSerializableLoggable 三种类型。就是说这个类型的对象同时拥有这三种类型的成员。

大多数使用场景是 mixins 或者其他不适合典型面向对象模型的地方看到交叉类型的使用。

function extend<T, U> (first: T, second: U) :T & U {
    let result = <T & U>{};
    for (let id in first) {
        (<any>result)[id] = (<any>first)[id];
    }
    for(let id in second) {
        (<any>result)[id] = (<any>second)[id];
    }
    return result;
}

class Person {
    constructor(public name: string){}
}

interface Loggable {
    log(): void;
}
class ConsoleLogger implements Loggable {
    log() {}
}
const jim = extend(new Person('jJm'), new ConsoleLogger());
const n = jim.name;
jim.log()

1.jpg

二、联合类型(Union Types)

联合类型和交叉类型很有关联,但是使用上却完全不同。交叉类型是 & 的关系而联合类型是 | 的关系。

function padLeft(value: string, padding: any) {
    if (typeof padding === 'number') {
        return Array(padding + 1).join(" ") + value;    
    }
    if (typeof padding === 'string') {
        return padding + value;
    }
    throw new Error('Expeted string or number, got "${padding}"');
}
padLeft("Hello world", 4); // returns "    Hello world"

上面的方法 padLeft 有个问题,参数 padding 参数的类型指定成了 any,可以传入任何类型的值,而 TypeScript 在编译期间不会报错。

再传统的面向对象的语言中,我们可能会将这两种类型抽象成层级的类型,不过也会导致类型的再次抽象也会导致过度设计。而 padLeft 原始版本的好处之一是允许我们传入原始类型。

如果使用 联合类型 代替 any 则:

function padLeft(val: string, padding: string | number) {}

padLeft('a', true);

2.jpg

联合类型表示一个值可以是几种类型之一,通过 | 来分隔每个类型,所以 number | string | boolean 表示一个值既可以是 number 也可以是 string 或者是 boolean

如果一个值是联合类型,则只能访问这个联合类型中共有的成员。

interface Bird {
    fly(): void;
    layEggs(): void;
}
interface Fish {
    swim(): void;
    layEggs(): void;
}
function getSmallPet(): Fish | Bird {}

let pet = getSmallPet();
pet.layEggs();
pet.fly(); // error

上面 Fish 和 Bird 是两个复杂的联合类型,如果调用 layEggs 方法是没问题的,因为两个类型都有这个方法,所以肯定不会出错,但是调用 fly() 方法则会有问题,如果是 Fish 则不会有 fly() 方法。

三、类型保护与区分类型(Type Guards and Differentiating Types)

类型保护适用于那些值可以为不同类型的情况,但是下面的代码在检查的时候会导致每次都会报错:

let pet = getSmallPet();

// 每一个成员访问都会报错
if (pet.swim) {
    pet.swim();
}
else if (pet.fly) {
    pet.fly();
}

为了不再编译的时候报错,需要进行类型断言:

let pet = getSmallPet();

if ((<Fish>pet).swim) {
    (<Fish>pet).swim();
}
else {
    (<Bird>pet).fly();
}

用户自定义的类型保护

一直去使用类型断言是不可取的,从某种程度上讲也违背了 TypeScript 的本质。而 TypeScript 的 类型保护机制 可以做到一旦检查过类型,就能在之后的每个分支里清楚地知道 per 的类型。

类型保护 是一些表达式,它们在运行时检查来确保在某个作用域里的类型。要定义一个类型保护,只需要简单的定义一个函数,它的返回值是一个 类型谓词

function isFist(pet: Fish | Bird): pet is Fish {
    return (<Fish>pet).swim !== undefined;
}

上面的例子中, pet is Fish 是一个类型谓词。谓词的形式是 parameterName is Type 这种形式, parameterName 必须是来自于当前函数里的一个参数名。

每当使用一些变量调用 isFish 时,TypeScript 会将变量缩减为那个具体的类型,只要这个类型与变量的原始类型是兼容的。

因此下面的调用时 OK 的:

// 'swim' 和 'fly' 调用都没有问题了

if (isFish(pet)) {
    pet.swim();
}
else {
    pet.fly();
}

注意TypeScript不仅知道在 if分支里 petFish 类型; 它还清楚在 else 分支里,一定 不是 Fish 类型,一定是 Bird 类型。

typeof 类型保护

function isNumber(x: any): x is number {
    return typeof x === "number";
}

function isString(x: any): x is string {
    return typeof x === "string";
}

function padLeft(value: string, padding: string | number) {
    if (isNumber(padding)) {
        return Array(padding + 1).join(" ") + value;
    }
    if (isString(padding)) {
        return padding + value;
    }
    throw new Error(`Expected string or number, got '${padding}'.`);
}

上面代码中虽然通过 typeof 判断出了原始类型,但是必须要定义多个函数,将其抽象出来。不过 TypeScript 支持在代码中直接检查类型,使用 typeof X === 'number' 的语法:

function padLeft(val: string, padding: string | number) {
    if (typeof padding === 'number') {
        return Array(padding + 1).join(" ") + val;
    }
    if (typeof padding === 'string') {
        return padding + val;
    }
    throw  new Error(`Expected string or number, got '${padding}'`)
}

instanceof 类型保护

instanceof 类型保护是通过构造函数来细化类型的一种方式,比如下面的例子:

interface Padder {
    getPaddingString(): string
}

class SpaceRepeatingPadder implements Padder {
    constructor(private numSpaces: number) { }
    getPaddingString() {
        return Array(this.numSpaces + 1).join(" ");
    }
}

class StringPadder implements Padder {
    constructor(private value: string) { }
    getPaddingString() {
        return this.value;
    }
}

function getRandomPadder() {
    return Math.random() < 0.5 ?
        new SpaceRepeatingPadder(4) :
        new StringPadder("  ");
}

// 类型为SpaceRepeatingPadder | StringPadder
let padder: Padder = getRandomPadder();

if (padder instanceof SpaceRepeatingPadder) {
    padder; // 类型细化为'SpaceRepeatingPadder'
}
if (padder instanceof StringPadder) {
    padder; // 类型细化为'StringPadder'
}

instanceof 的右侧要求是一个构造函数,TypeScript 将细化为:

  • 此构造函数的 prototype 属性的类型,如果它的类型不为 any 的话
  • 构造签名所返回的类型的联合

四、可以为 null 的类型

TypeScript 有两种特殊的类型,nullundefined,值也是 nullundefined

默认情况下,类型检查器认为 nullundefined 可以赋值给任意的类型。 nullundefined 是所有其他类型的一个有效值,这是默认的情况,无法中断。

--strictNullChecks 标记可以解决此错误:当声明一个变量时,它不会自动地包含 nullundefined。 但是可以使用联合类型明确的包含它们:

let s = 'foo';
s = null; // 错误
let sn: string | null = 'bar';
sn = null; // 可以

sn = undefined; // error

3.jpg

注意,按照 JavaScript 的语义,TypeScript 会把 nullundefined 区别对待。 string | nullstring | undefinedstring | undefined | null 是不同的类型。

可选参数和可选属性

使用了 --stricNullChecks, 可选参数会被自动的加上 | undefined

function f(x:number, y?: number) {
    return x + (y || 0);
}
f(1,2);
f(1);
f(1, undefined);
f(1, null) // // error, 'null' is not assignable to 'number | undefined'

4.jpg

可选属性也会有同样的处理:

class C {
    a: number;
    b?: number;
}
let c = new C();
c.a = 12;
c.a = undefined; // error, 'undefined' is not assignable to 'number'
c.b = 13;
c.b = undefined; // ok
c.b = null; // error, 'null' is not assignable to 'number | undefined'

类型保护和类型断言

由于可以为 null 的类型是通过联合类型实现,那么需要使用类型保护来去除 null:

function f(sn: string | null): string {
    if (sn == null) {
        return "default";
    }
    else {
        return sn;
    }
}

当然也有更简洁的方式:

function f(sn: string | null): string {
    return sn || "default";
}

如果编译器不能够去除 nullundefined,可以使用类型断言手动去除。 语法是添加 ! 后缀: identifier! 意思是从 identifier 的类型里去除了 nullundefined

function broken(name: string | null): string {
  function postfix(epithet: string) {
    return name.charAt(0) + '.  the ' + epithet; // error, 'name' is possibly null
  }
  name = name || "Bob";
  return postfix("great");
}

function fixed(name: string | null): string {
  function postfix(epithet: string) {
    return name!.charAt(0) + '.  the ' + epithet; // ok
  }
  name = name || "Bob";
  return postfix("great");
}

上面例子中使用了嵌套函数,因为编译器无法去除嵌套函数的 null除非是立即调用的函数表达式)。

因为它无法跟踪所有对嵌套函数的调用,尤其是将内层函数做为外层函数的返回值。 如果无法知道函数在哪里被调用,就无法知道调用时 name 的类型。

四、类型别名

类型别名会给一个类型起个新名字,类型别名有时候和 interface 比较像,但是可以作用于原始值、联合类型、元组以及其他任何需要你手动写的类型。

type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;
function getName(n: NameOrResolver): Name {
    if (typeof n === 'string') {
        return n;
    }
    else {
        return n();
    }
}

起一个类型别名并非新建了一个类型,而只是创建了一个新的名字来引用那个类型。给原始类型起别名通常没什么用,尽管可以作为文档的一种形式使用。

和 interface 一样,类型别名也可以是 泛型 - 可以添加类型参数并且在别名声明的右侧传入:

type Container <T> =  {value: T};

也可以使用类型别名在属性里面引用自己:

type Tree <T> = {
    value: T;
    left: Tree <T>;   
    right: Tree <T>;
}

也可以与交叉类型一起用:

type LinkedList <T> = T & { next: LinkedList <T> };

interface Person {
    name: string
}

var people: LinkedList<Person>;

var s = people.name;
var s = people.next.name;
var s = people.next.next.name;
var s = people.next.next.next.name;

注意:类型别名不能出现在声明右侧的任何地方。

type Yikes = Array<Yikes>; // error

接口 vs. 类型别名

接口和类型别名还是有一些细微差别的。

首先,接口创建了一个新的名字,可以在其他任何地方使用。类型别名并不创建新名字。

在编译器中将鼠标悬停在 interfaced上,显示它返回的是 Interface,但悬停在 aliased上时,显示的却是对象字面量类型。

type Alias = { num: number }
interface Interface {
    num: number;
}
declare function aliased(arg: Alias): Alias;
declare function interfaced(arg: Interface): Interface;

另一个重要的区别是类型别名不能被 extendsimplements(自己也不能 extendsimplements 其他类型)。

另一方面,如果无法通过接口描述一个类型并且需要使用联合类型或者是元组类型,则通常可以选择类型别名。

五、字符串、对象字面量类型

字符串字面量类型允许你指定字符串必须的固定值。在实际的应用中,字符串字面量类型可以与联合类型、类型保护和类型别名很好的配合。

type Easing = "ease-in" | "ease-out" | "ease-in-out";
class UIElement {
    animate(dx: number, dy: number, easing: Easing) {
        if (easing === "ease-in") {
            // ...
        }
        else if (easing === "ease-out") {
        }
        else if (easing === "ease-in-out") {
        }
        else {
            // error! should not pass null or undefined.
        }
    }
}

let button = new UIElement();
button.animate(0, 0, "ease-in");
button.animate(0, 0, "uneasy"); // error: "uneasy" is not allowed here

上面代码中,只能从三种允许的字符中选择其一来做为参数传递,传入其它值则会产生错误。

Argument of type '"uneasy"' is not assignable to parameter of type '"ease-in" | "ease-out" | "ease-in-out"'

5.jpg

字符串字面量类型还可以用于区分函数重载:

function createElement(tagName: "img"): HTMLImageElement;
function createElement(tagName: "input"): HTMLInputElement;
// ... more overloads ...
function createElement(tagName: string): Element {
    // ... code goes here ...
}

六、数字字面量类型

TypeScript 具有数字字面量类型。

function rollDie(): 1 | 2 | 3 | 4 | 5 | 6 {
    // ...
}

一般很少直接这样子使用,但是可以在缩小范围调试 bug 的时候:

function foo(x: number) {
    if (x !== 1 || x !== 2) {
        // Operator '!==' cannot be applied to types '1' and '2'.
    }
}

上面代码中,因为 x !==1 || x!==2 这个条件使用是成立的,因此会报错误。

七、枚举成员类型

如果每个枚举成员都是用字面量初始化,则枚举成员是具有类型的。

“单例类型” 多数是指枚举成员类型和数字/字符串字面量类型,尽管大多数用户会互换使用“单例类型”和“字面量类型”

八、可辨识联合(Discriminated Unions)

合并单例类型、联合类型、类型保护和类型别名来创建一个叫做 可辨识联合 的高级模式,它也称做 标签联合代数数据类型

可辨识联合在函数式编程很有用处。 一些语言会自动地为你辨识联合;而 TypeScript 则基于已有的 JavaScript 模式。 它具有3个要素:

  1. 具有普通的单例类型属性 — 可辨识的特征。
  2. 一个类型别名包含了那些类型的联合 — 联合。
  3. 此属性上的类型保护。
interface Square {
    kind: "square";
    size: number;
}
interface Rectangle {
    kind: "rectangle";
    width: number;
    height: number;
}
interface Circle {
    kind: "circle";
    radius: number;
}

首先声明了将要联合的接口。 每个接口都有 kind 属性但有不同的字符串字面量类型。 kind属性称做 可辨识的特征标签。 其它的属性则特定于各个接口。 注意,目前各个接口间是没有联系的。 下面把它们联合到一起:

type Shape = Square | Rectangle | Circle;

现在使用可辨识联合:

function area(s: Shape) {
    switch (s.kind) {
        case "square": return s.size * s.size;
        case "rectangle": return s.height * s.width;
        case "circle": return Math.PI * s.radius ** 2;
    }
}

完整性检查

当没有涵盖所有可辨识联合的变化时,我们想让编译器可以通知我们。

比如,如果添加了 TriangleShape,我们同时还需要更新 area:

type Shape = Square | Rectangle | Circle | Triangle;
function area(s: Shape) {
    switch (s.kind) {
        case "square": return s.size * s.size;
        case "rectangle": return s.height * s.width;
        case "circle": return Math.PI * s.radius ** 2;
    }
    // should error here - we didn't handle case "triangle"
}

有两种方式可以实现。 首先是启用 --strictNullChecks 并且指定一个返回值类型:

function area(s: Shape): number { // error: returns number | undefined
    switch (s.kind) {
        case "square": return s.size * s.size;
        case "rectangle": return s.height * s.width;
        case "circle": return Math.PI * s.radius ** 2;
    }
}

因为 switch 没有包涵所有情况,所以 TypeScript 认为这个函数有时候会返回 undefined
如果明确地指定了返回值类型为 number,那么会看到一个错误,因为实际上返回值的类型为 number | undefined。 然而,这种方法存在些微妙之处且 --strictNullChecks对旧代码支持不好。

第二种方法使用 never类型,编译器用它来进行完整性检查:

function assertNever(x: never): never {
    throw new Error("Unexpected object: " + x);
}
function area(s: Shape) {
    switch (s.kind) {
        case "square": return s.size * s.size;
        case "rectangle": return s.height * s.width;
        case "circle": return Math.PI * s.radius ** 2;
        default: return assertNever(s); // error here if there are missing cases
    }
}

这里, assertNever 检查 s 是否为 never类型即为除去所有可能情况后剩下的类型。 如果你忘记了某个case,那么 s将具有一个真实的类型并且你会得到一个错误。 这种方式需要你定义一个额外的函数,但是在你忘记某个 case 的时候也更加明显。

九、多态的 this类型

多态的 this 类型表示的是某个包含类或接口的 子类型。 这被称做 F-bounded多态性。 它能很容易的表现连贯接口间的继承,比如在计算器的例子里,在每个操作之后都返回 this类型:

class BasicCalculator {
    public constructor(protected value: number = 0) { }
    public currentValue(): number {
        return this.value;
    }
    public add(operand: number): this {
        this.value += operand;
        return this;
    }
    public multiply(operand: number): this {
        this.value *= operand;
        return this;
    }
    // ... other operations go here ...
}

let v = new BasicCalculator(2)
            .multiply(5)
            .add(1)
            .currentValue();

由于这个类使用了 this类型,你可以继承它,新的类可以直接使用之前的方法,不需要做任何的改变。

class ScientificCalculator extends BasicCalculator {
    public constructor(value = 0) {
        super(value);
    }
    public sin() {
        this.value = Math.sin(this.value);
        return this;
    }
    // ... other operations go here ...
}

let v = new ScientificCalculator(2)
        .multiply(5)
        .sin()
        .add(1)
        .currentValue();

如果没有 this类型ScientificCalculator 就不能够在继承BasicCalculator 的同时还保持接口的连贯性。 multiply 将会返回 BasicCalculator,它并没有 sin方法。 然而,使用 this类型multiply 会返回 this,在这里就是 ScientificCalculator

十、索引类型(Index types)

使用索引类型,编译器就能够检查使用了动态属性名的代码。 例如,一个常见的JavaScript模式是从对象中选取属性的子集。

function pluck(o, names) {
    return names.map(n => o[n]);
}

下面是如何在 TypeScript 里使用此函数,通过 索引类型查询索引访问操作符

function pluck<T, K extends keyof T>(o: T, names: K[]): T[K][] {
  return names.map(n => o[n]);
}

interface Person {
    name: string;
    age: number;
}
let person: Person = {
    name: 'Jarid',
    age: 35
};
let strings: string[] = pluck(person, ['name']); // ok, string[]

编译器会检查 name 是否真的是 Person 的一个属性。 本例还引入了几个新的类型操作符。 首先是 keyof T索引类型查询操作符。 对于任何类型 T, keyof T 的结果为 T 上已知的公共属性名的联合。 例如:

let personProps: keyof Person; // 'name' | 'age'

keyof Person 是完全可以与 'name' | 'age' 互相替换的。 不同的是如果添加了其它的属性到 Person,例如 address: string,那么 keyof Person 会自动变为 'name' | 'age' | 'address'

可以在像 pluck 函数这类上下文里使用 keyof,因为在使用之前并不清楚可能出现的属性名。

但编译器会检查是否传入了正确的属性名给 pluck:

pluck(person, ['age', 'unknown']); // error, 'unknown' is not in 'name' | 'age'

第二个操作符是 T[K]索引访问操作符

在这里,类型语法反映了表达式语法。 这意味着 person['name'] 具有类型 Person['name'] — 在上面的例子里则为 string 类型。

然而,就像索引类型查询一样,可以在普通的上下文里使用 T[K],这正是它的强大所在。

只要确保类型变量 K extends keyof T 就可以了。 例如下面 getProperty 函数的例子:

function getProperty<T, K extends keyof T>(o: T, name: K): T[K] {
    return o[name]; // o[name] is of type T[K]
}

getProperty 里的 o: T和 name: K ,意味着 o[name]: T[K]。 当你返回 T[K] 的结果,编译器会实例化键的真实类型,因此 getProperty 的返回值类型会随着你需要的属性改变。

let name: string = getProperty(person, 'name');
let age: number = getProperty(person, 'age');
let unknown = getProperty(person, 'unknown'); // error, 'unknown' is not in 'name' | 'age'

索引类型和字符串索引签名

keyofT[K] 与字符串索引签名进行交互。 如果你有一个带有字符串索引签名的类型,那么 keyof T 会是 string。 并且 T[string] 为索引签名的类型:

interface Map<T> {
    [key: string]: T;
}
let keys: keyof Map<number>; // string
let value: Map<number>['foo']; // number

十一、映射类型

一个常见的任务是将一个已知的类型每个属性都变为可选的:

interface PersonPartial {
    name?: string;
    age?: number;
}

或者想要一个只读版本:

interface PersonReadonly {
    readonly name: string;
    readonly age: number;
}

这在 JavaScript 里经常出现,TypeScript 提供了从旧类型中创建新类型的一种方式 — 映射类型

在映射类型里,新类型以相同的形式去转换旧类型里每个属性。 例如,可以令每个属性成为 readonly类型或可选的。 下面是一些例子:

type Readonly<T> = {
    readonly [P in keyof T]: T[P];
}
type Partial<T> = {
    [P in keyof T]?: T[P];
}

像下面这样使用:

type PersonPartial = Partial<Person>;
type ReadonlyPerson = Readonly<Person>;

下面是最简单的映射类型和它的组成部分:

type Keys = 'option1' | 'option2';
type Flags = { [K in Keys]: boolean };

它的语法与索引签名的语法类型,内部使用了 for ... in。 具有三个部分:

  1. 类型变量 K,它会依次绑定到每个属性。
  2. 字符串字面量联合的 Keys,它包含了要迭代的属性名的集合。
  3. 属性的结果类型。

在个简单的例子里, Keys 是硬编码的的属性名列表并且属性类型永远是 boolean,因此这个映射类型等同于:

type Flags = {
    option1: boolean;
    option2: boolean;
}

在真正的应用里,可能不同于上面的 ReadonlyPartial 。 它们会基于一些已存在的类型,且按照一定的方式转换字段。 这就是 keyof索引访问类型要做的事情:

type NullablePerson = { [P in keyof Person]: Person[P] | null }
type PartialPerson = { [P in keyof Person]?: Person[P] }

但它更有用的地方是可以有一些通用版本。

type Nullable<T> = { [P in keyof T]: T[P] | null }
type Partial<T> = { [P in keyof T]?: T[P] }

在这些例子里,属性列表是 keyof T 且结果类型是 T[P] 的变体。 这是使用通用映射类型的一个好模版。

因为这类转换是 同态的,映射只作用于 T 的属性而没有其它的。

编译器知道在添加任何新属性之前可以拷贝所有存在的属性修饰符。

例如,假设 Person.name 是只读的,那么 Partial<Person>.name 也将是只读的且为可选的。

下面是另一个例子, T[P] 被包装在 Proxy<T> 类里:

type Proxy<T> = {
    get(): T;
    set(value: T): void;
}
type Proxify<T> = {
    [P in keyof T]: Proxy<T[P]>;
}
function proxify<T>(o: T): Proxify<T> {
   // ... wrap proxies ...
}
let proxyProps = proxify(props);

注意 Readonly<T>Partial<T> 用处不小,因此它们与 PickRecord同被包含进了TypeScript的标准库里

type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
}
type Record<K extends string, T> = {
    [P in K]: T;
}

ReadonlyPartialPick同态的,但 Record 不是。 因为 Record 并不需要输入类型来拷贝属性,所以它不属于同态:

type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>

非同态类型本质上会创建新的属性,因此它们不会从它处拷贝属性修饰符。

由映射类型进行推断

现在了解了如何包装一个类型的属性,那么接下来就是如何拆包。 其实这也非常容易:

function unproxify<T>(t: Proxify<T>): T {
    let result = {} as T;
    for (const k in t) {
        result[k] = t[k].get();
    }
    return result;
}

let originalProps = unproxify(proxyProps);

注意这个拆包推断只适用于同态的映射类型。 如果映射类型不是同态的,那么需要给拆包函数一个明确的类型参数。

预定义的有条件类型

TypeScript 2.8 在 lib.d.ts 里增加了一些预定义的有条件类型:

  • Exclude<T, U> -- 从 T 中剔除可以赋值给 U 的类型。
  • Extract<T, U> -- 提取 T 中可以赋值给 U 的类型。
  • NonNullable<T> -- 从 T 中剔除 null 和 undefined 。
  • ReturnType<T> -- 获取函数返回值类型。
  • InstanceType<T> -- 获取构造函数类型的实例类型。

示例:

type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "b" | "d"
type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "a" | "c"

type T02 = Exclude<string | number | (() => void), Function>;  // string | number
type T03 = Extract<string | number | (() => void), Function>;  // () => void

type T04 = NonNullable<string | number | undefined>;  // string | number
type T05 = NonNullable<(() => string) | string[] | null | undefined>;  // (() => string) | string[]

function f1(s: string) {
    return { a: 1, b: s };
}

class C {
    x = 0;
    y = 0;
}

type T10 = ReturnType<() => string>;  // string
type T11 = ReturnType<(s: string) => void>;  // void
type T12 = ReturnType<(<T>() => T)>;  // {}
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;  // number[]
type T14 = ReturnType<typeof f1>;  // { a: number, b: string }
type T15 = ReturnType<any>;  // any
type T16 = ReturnType<never>;  // any
type T17 = ReturnType<string>;  // Error
type T18 = ReturnType<Function>;  // Error

type T20 = InstanceType<typeof C>;  // C
type T21 = InstanceType<any>;  // any
type T22 = InstanceType<never>;  // any
type T23 = InstanceType<string>;  // Error
type T24 = InstanceType<Function>;  // Error

注意:Exclude 类型是建议的 Diff 类型的一种实现。使用 Exclude 这个名字是为了避免破坏已经定义了 Diff 的代码,并且这个名字能更好地表达类型的语义。没有增加 Omit<T, K> 类型,因为它可以很容易的用 Pick<T, Exclude> `来表示。