泛型
泛型（Generics）是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。
function createArray(length: number, value: any): Array<any> {
let result = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}
createArray(3, "x"); // ['x', 'x', 'x']上面是用数组泛型来定义返回值的类型，但是一个显而易见的缺陷是，它并没有准确的定义返回值的类型：
Array<any> 允许数组的每一项都为任意类型。但是我们预期的是，数组中每一项都应该是输入的 value 的类型。
function createArray<T>(length: number, value: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}
createArray<string>(3, "x"); // ['x', 'x', 'x']其中 T 用来指代任意输入的类型。
如果在调用时不手动指定具体类型的话，也可以根据类型推论自动推断出来。
多个类型参数
function swap<T, U>(tuple: [T, U]): [U, T] {
return [tuple[1], tuple[0]];
}
swap([7, "seven"]); // ['seven', 7]泛型约束
在函数内部使用泛型变量的时候，由于事先不知道它是哪种类型，所以不能随意的操作它的属性或方法：
function loggingIdentity<T>(arg: T): T {
console.log(arg.length);
return arg;
} // error可以对泛型进行约束，只允许这个函数传入那些包含 length 属性的变量。这就是泛型约束：
interface Lengthwise {
length: number;
}
function loggingIdentity<T extends Lengthwise>(arg: T): T {
console.log(arg.length);
return arg;
}如果传入的参数不包含 length 属性，那么在编译阶段就会报错。
多个类型参数之间也可以互相约束：
function copyFields<T extends U, U>(target: T, source: U): T {
for (let id in source) {
target[id] = (<T>source)[id];
}
return target;
}
let x = { a: 1, b: 2, c: 3, d: 4 };
copyFields(x, { b: 10, d: 20 });泛型接口
使用接口的方式来定义一个函数需要符合的形状：
interface SearchFunc {
(source: string, subString: string): boolean;
}
let mySearch: SearchFunc;
mySearch = function (source: string, subString: string) {
return source.search(subString) !== -1;
};interface CreateArrayFunc {
<T>(length: number, value: T): Array<T>;
}
let createArray: CreateArrayFunc;
createArray = function <T>(length: number, value: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
};
createArray(3, "x"); // ['x', 'x', 'x']interface CreateArrayFunc<T> {
(length: number, value: T): Array<T>;
}
let createArray: CreateArrayFunc<any>;
createArray = function <T>(length: number, value: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
};
createArray(3, "x"); // ['x', 'x', 'x']泛型类
class GenericNumber<T> {
zeroValue: T;
add: (x: T, y: T) => T;
}
let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function (x, y) {
return x + y;
};泛型参数的默认类型
可以为泛型中的类型参数指定默认类型，当使用泛型时没有在代码中直接指定类型参数，从实际值参数中也无法推测出时，这个默认类型就会起作用。
function createArray<T = string>(length: number, value: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}声明合并
如果定义了两个相同名字的函数、接口或类，那么它们会合并成一个类型。
函数合并
使用重载定义多个函数类型：
function reverse(x: number): number;
function reverse(x: string): string;
function reverse(x: number | string): number | string {
if (typeof x === "number") {
return Number(x.toString().split("").reverse().join(""));
} else if (typeof x === "string") {
return x.split("").reverse().join("");
}
}接口合并
interface Alarm {
price: number;
}
interface Alarm {
price: string; // 属性名相同，但是类型不一致，会报错
weight: number;
}合并的属性的类型必须是唯一的。
接口中方法的合并，与函数的合并一样：
interface Alarm {
price: number;
alert(s: string): string;
}
interface Alarm {
weight: number;
alert(s: string, n: number): string;
}类的合并
同接口合并规则。
拓展
- Never（中文版 Types.html#never)）：永远不存在值的类型，一般用于错误处理函数
- Variable Declarations（中文版 Declarations.html)）：使用
let和const替代var，这是 ES6 的知识[this](https://zhongsp.gitbooks.io/typescript-handbook/content/doc/handbook/Functions.html#this)：箭头函数的运用，这是 ES6 的知识Using Class Types in Generics（中文版）：创建工厂函数时，需要引用构造函数的类类型 - Best common type（中文版 Inference.html#最佳通用类型)）：数组的类型推论
- Contextual Type（中文版 Inference.html#上下文类型)）：函数输入的类型推论
- Type Compatibility（中文版 Compatibility.html)）：允许不严格符合类型，只需要在一定规则下兼容即可
- Advanced Types（中文版 Types.html#交叉类型（intersection-types）)）：使用
&将多种类型的共有部分叠加成一种类型 - Type Guards and Differentiating Types（中文版 Types.html#类型保护与区分类型（type-guards-and-differentiating-types）)）：联合类型在一些情况下被识别为特定的类型
- Discriminated Unions（中文版 Types.html#可辨识联合（discriminated-unions）)）：使用
|联合多个接口的时候，通过一个共有的属性形成可辨识联合 - Polymorphic this types（中文版 Types.html#多态的 this 类型)）：父类的某个方法返回
this，当子类继承父类后，子类的实例调用此方法，返回的this能够被 TypeScript 正确的识别为子类的实例。 - Symbols（中文版）：新原生类型，这是 ES6 的知识
- Iterators and Generators（中文版 and Generators.html)）：迭代器，这是 ES6 的知识
- Namespaces（中文版）：避免全局污染，现在已被 ES6 Module 替代
- Decorators（中文版）：修饰器，这是 ES7 的一个提案
- Mixins（中文版）：一种编程模式，与 TypeScript 没有直接关系，可以参考 ES6 中 Mixin 模式的实现
