文章将讨论处理类型的几个高级模式，包括模拟名义类型的类型烙印、利用条件类型的分配性质在类型层面操作类型，以及安全地扩展原型。

1 函数类型

TS在推导元组的类型时会放宽要求，推导出的结果尽量宽泛，不在乎元组的长度和各位置的类型：

let a = [“hello”,false,1]; // (string | boolean | number)[]

我们有时希望推导结果更严格些，比如上面的类型应该为 [string,boolean,number]。我们可以使用类型断言或者as const来收窄推导结果，我们还可以自定义函数，来实现元组类型收窄：

function tuple<T extends unknown[]>(...t: T) {return t;
}
let t1 = tuple(2,false); // [number,boolean]

1.1 自定义类型防护措施

开发中，我们时常需要判断对象的类型，我们会写一个函数来进行判断：

function isString(input: unknown) {return typeof input === 'string';
}

但是这个函数在某些场景中，可能会达不到我们的预期效果：

function fun(input: string | number) {if (isString(input)) {input.toUpperCase();//报错 Property toUpperCase does not exist on type string | number// Property toUpperCase does not exist on type number}
}

这是因为TS类型细化能力有限，只能细化当前作用域中变量的类型，即上面代码中，TS只能在isString函数中来保证input是个string类型。

TS内置特性：类型防护措施。这是typeof和instanceof细化类型的背后机制。我们通过自定义类型防护措施来实现类型的细化在作用域之间转移：

function isString(a: unknown):a is string {return typeof a === 'string';
}
function fun(input: number | string) {if (isString(input)) {input.toUpperCase();}
}

2 条件类型

条件类型是声明一个依赖类型U和V的类型T，如果 U <: V,就把T赋值给A，否则赋值给B。例如：

type IsString<T> = T extends string ? true : false。

type A = isString<number>; // false

type A = isString<string>; // true

条件类型使用广泛，可以使用类型的地方几乎都能使用条件类型。

type WithoutArrayType<T,U> = T extends U ? never : T[];
type T1 = WithoutArrayType<string | number | boolean, boolean>; // string[] | number[]

2.1 infer 关键字声明泛型

在条件类型中不能适用尖括号(<T>)来声明范型，而是使用infer关键字。

type ElementType<T> = T extends unknown[] ? T[number] : T;
type ElementType2<T> = T extends (infer U)[] ? U : T; // 等效上面type T1 = ElementType<number[]>; // number
type T2 = ElementType2<string[][]>; //string[]

2.2 内置的条件类型

Exclude<T,U>: 返回在T中而不在U中的类型。

type ExcludeType = Exclude<string | number | boolean, number>; // string | boolean

Extract<T,U>: 返回T中可赋值给U的类型。

type ExtractType = Extract< number | boolean, string | number | 'x'>; // number

NonNullable<T>: 从T中排出null和undefined。

type A = { a? :number,b: string | null};
type aType = NonNullable<A["a"]>; // number
type A1 = NonNullable<A>; // A & {}let a1:A1 = {a:1,b:1};
let a2:A1 = {}; // Property b is missing in type {} but required in type A
let a3:A1 = {b:null};

ReturnType<F>: 计算函数的返回类型（不适用泛型和重载的函数）。

type Fun = () => string;
type T1 = ReturnType<Fun>; // string

InstanceType<C>: 返回类构造方法的实例类型。

type CustomClass = {new(): C}
type C = {name:"user"};
type T = InstanceType<CustomClass>; // {name: "user"}

3 断言

在没有足够时间把所有类型都规划好，但是我们希望TS不要因为这个而让我们程序运行不起来，我们可以使用断言的方式（但要尽量少用，如果大量依赖这些，说明项目需要重构了）。

1）类型断言。有两种方式：as 和尖括号。

function fun(input: string | number) {let str = input as string;// stringlet str2 = <string> input; // string
}

2）非空断言。

type Student = {id?: number};
let s:Student = {};
let s2: Student = {id: 2};
function fun2(id: number) {}
fun2(s.id!);
fun2(s2.id!);
fun2(s2.id); // 报错 Argument of type 'number | undefined' is not assignable to parameter of type 'number'.

3）明确赋值断言。TS通过明确赋值检查确保使用变量时已经为其赋值。

我们在定义一个变量时，如果在没有为其赋值而使用它，那么TS将报错。

class Student{name: stringshowName() {console.log(this.name);}
}let student = new Student();
student.showName(); // 报错  Property 'name' has no initializer and is not definitely assigned in the constructor.

明确赋值，是指在变量名后面加个”!“符号，来告诉TS，我已经确保，在使用这个变量之前，我已经为它赋值。

class Student{name!: stringshowName() {console.log(this.name);}
}let student = new Student();
student.showName(); // undefined

4 名义类型

TS 是结构化类型不是名义类型系统，即TS只根据类型结构来判断类型而不是类型名称。而在Java中，是根据类名来确定类型的。比如Man 和 People，在TS中，如果这两个类型的结构是一样的，那么它们是同一个类型，而在Java中，因为它们名字不同，就注定它们不是同一个类型。

虽然在TS中，通过结构类型给予了开发者很多方便，但是有时名义类型能发挥的作用是结构类型很难替代的：

定义一个函数，要求参数为一个StudentID类型的字符串。而这个StudentID本质上也是字符串类型。

我们可以使用类型烙印技术模拟实现。

4.1 类型烙印

类型烙印即给特定类型一个唯一结构，来让它从其他相似类型结构中区别开。

type StudentID = string & {readonly brand: unique symbol};
function StudentID(id:string) {return id as StudentID;
}function showStudentId(id: StudentID) {}let id = StudentID("123"); // StudentID
showStudentId(id);
showStudentId("123"); // 报错  Argument of type string is not assignable to parameter of type StudentID
//Type string is not assignable to type { readonly brand: unique symbol; }

类型烙印降低了运行时的开销，是一种编译时结构。

多数应用没必要使用这个，不过，对于大型应用或者处理容易混淆的类型时，带烙印的类型可以极大地提升程序的安全性。