ts应用文档

1.什么是泛型

当我们定义一个变量不确定类型的时候有两种解决方式

使用any：

        使用any定义时存在的问题：虽然知道传入值的类型但是无法获取函数返回值的类型；另外也失去了ts类型保护的优势

使用泛型：

        泛型指的是在定义函数/接口/类型时，不预先指定具体的类型，而是在使用的时候在指定类型限制的一种特性。

    在什么时候需要使用泛型呢？通常在决定是否使用泛型时有以下两个参考标准

1.当你的函数、接口或类将处理多种数据类型时

2.当函数、接口或类在多个地方使用该数据类型时。（后续可能进行拓展不同类型）

1.这里 identity 的问题是我们将 Number 类型分配给参数和返回类型，使该函数仅可用于该原始类型。但该函数并不是可扩展或通用的，很明显这并不是我们所希望的。
function identity (value: Number) : Number {
	return value;
}
2.我们确实可以把 Number 换成 any，我们失去了定义应该返回哪种类型的能力，并且在这个过程中使编译器失去了类型保护的作用。我们的目标是让 identity 函数可以适用于任何特定的类型，为了实现这个目标，我们可以使用泛型来解决这个问题
function identity <T>(value: T) : T {
	return value;
}

console.log(identity<Number>(1)) // 1 对于刚接触 TypeScript 泛型的读者来说，首次看到 语法会感到陌生。但这没什么可担心的，就像传递参数一样，我们传递了我们想要用于特定函数调用的类型。
3.其实并不是只能定义一个类型变量，我们可以引入希望定义的任何数量的类型变量。比如我们引入一个新的类型变量 U，用于扩展我们定义的 identity 函数
function identity <T, U>(value: T, message: U) : T {
  	console.log(message);
 	return value;
}

console.log(identity<Number, string>(68, "Semlinker"));
4.相比之前定义的 identity 函数，新的 identity 函数增加了一个类型变量 U，但该函数的返回类型我们仍然使用 T。如果我们想要返回两种类型的对象该怎么办呢？针对这个问题，我们有多种方案，其中一种就是使用元组
function identity <T, U>(value: T, message: U) : [T, U] {
	return [value, message];
}
5.虽然使用元组解决了上述的问题，但有没有其它更好的方案呢？答案是有的，你可以使用泛型接口。
function test <T> (arg:T):T{
  console.log(arg);
  return arg;
}
test<number>(111);// 返回值是number类型的 111
test<string | boolean>('hahaha')//返回值是string类型的 hahaha
test<string | boolean>(true);//返回值是布尔类型的 true

6.在接口中使用泛型
interface Search {
  <T,Y>(name:T,age:Y):T
}

let fn:Search = function <T, Y>(name: T, id:Y):T {
  console.log(name, id)
  return name;
}
fn('li',11);//编译器会自动识别传入的参数，将传入的参数的类型认为是泛型指定的类型

7.为了解决刚刚上面提到的问题，首先让我们创建一个用于的 identity 函数通用 Identities 接口：
interface Identities<V, M> {
  value: V,
  message: M
}
function identity<T, U> (value: T, message: U): Identities<T, U> {
  console.log(value + ": " + typeof (value));
  console.log(message + ": " + typeof (message));
  let identities: Identities<T, U> = {
    value,
    message
  };
  return identities;
}

console.log(identity(68, "Semlinker"));

8.在类中使用泛型
class Animal<T> {
 name:T;
 constructor(name: T){
   this.name = name;
 }
 action<T>(say:T) {
   console.log(say)
 }
}
let cat = new Animal('cat');
cat.action('mimi')
9.类中使用泛型也很简单，我们只需要在类名后面，使用 <T, …> 的语法定义任意多个类型变量
interface GenericInterface<U> {
  value: U
  getIdentity: () => U
}

class IdentityClass<T> implements GenericInterface<T> {
  value: T

  constructor(value: T) {
    this.value = value
  }

  getIdentity(): T {
    return this.value
  }

}

const myNumberClass = new IdentityClass<Number>(68);
console.log(myNumberClass.getIdentity()); // 68

const myStringClass = new IdentityClass<string>("Semlinker!");
console.log(myStringClass.getIdentity()); // Semlinker!

10.泛型约束
interface Person {
  name:string;
  age:number;
}
function student<T extends Person>(arg:T):T {
  return arg;
}

student({name:'lili'});//类型 "{ name: string; }" 中缺少属性 "age"，但类型 "Person" 中需要该属性
student({ name: "lili" , age:'11'});//不能将类型“string”分配给类型“number”
student({ name: "lili" , age:11});
有时我们可能希望限制每个类型变量接受的类型数量，这就是泛型约束的作用
11.确保属性存在
function identity<T>(arg: T): T {
  console.log(arg.length); // Error
  return arg;
}
在这种情况下，编译器将不会知道 T 确实含有 length 属性，尤其是在可以将任何类型赋给类型变量 T 的情况下。我们需要做的就是让类型变量 extends 一个含有我们所需属性的接口
interface Length {
  length: number;
}

function identity<T extends Length>(arg: T): T {
  console.log(arg.length); // 可以获取length属性
  return arg;
}
T extends Length 用于告诉编译器，我们支持已经实现 Length 接口的任何类型。之后，当我们使用不含有 length 属性的对象作为参数调用 identity 函数时，TypeScript 会提示相关的错误信息
12.检查对象上的键是否存在
泛型约束的另一个常见的使用场景就是检查对象上的键是否存在
keyof 操作符是在 TypeScript 2.1 版本引入的，该操作符可以用于获取某种类型的所有键，其返回类型是联合类型
interface Person {
  name: string;
  age: number;
  location: string;
}

type K1 = keyof Person; // "name" | "age" | "location"
type K2 = keyof Person[];  // number | "length" | "push" | "concat" | ...
type K3 = keyof { [x: string]: Person };  // string | number
通过 keyof 操作符，我们就可以获取指定类型的所有键，之后我们就可以结合前面介绍的 extends 约束，即限制输入的属性名包含在 keyof 返回的联合类型中
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

13.泛型参数默认类型
在 TypeScript 2.3 以后，我们可以为泛型中的类型参数指定默认类型
interface A<T=string> {
  name: T;
}

const strA: A = { name: "Semlinker" };
const numB: A<number> = { name: 101 };
14.泛型条件类型
在 TypeScript 2.8 中引入了条件类型，使得我们可以根据某些条件得到不同的类型
T extends U ? X : Y
以上表达式的意思是：若 T 能够赋值给 U，那么类型是 X，否则为 Y
我们通常还会结合 infer 关键字
interface Dictionary<T = any> {
  [key: string]: T;
}
 
type StrDict = Dictionary<string>

type DictMember<T> = T extends Dictionary<infer V> ? V : never
type StrDictMember = DictMember<StrDict> // string
在上面示例中，当类型 T 满足 T extends Dictionary 约束时，我们会使用 infer 关键字声明了一个类型变量 V，并返回该类型，否则返回 never 类型。