typescript泛型(学习笔记非干货)

软件工程中，我们不仅要创建一致的定义良好的API，同时也要考虑可重用性。 组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，

这在创建大型系统时为你提供了十分灵活的功能。

In software engineering, we should not only create well-defined APIs, but also consider reusability. Components can support not only

current data types, but also future data types.This provides you with very flexible functionality when creating large systems.

在像C#和Java这样的语言中，可以使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。 这样用户就可以以自己的数据类型来使用组件。

In languages like C# and Java, generics can be used to create reusable components, and a component can support multiple types of data.

This allows users to use components with their own data types.

泛型之Generic

Generic Generic

identity函数。 这个函数会返回任何传入它的值。 你可以把这个函数当成是echo命令。

identity Function. This function returns any value passed in. You can think of this function as echo command.

不用泛型的话，这个函数可能是下面这样：

Without generics, this function might be as follows:
function identity(arg:number):number{
    return arg;
}
function identity(arg:any):any{
    return arg;//传入的类型与返回的类型应该是相同的。
}

我们需要一种方法使返回值的类型与传入参数的类型是相同的。 这里，我们使用了 类型变量，它是一种特殊的变量，只用于表示类型而不是值。

We need a way to make the type of the return value the same as the type of the incoming parameter. Here, we use a type variable,

which is a special variable and is used only to represent a type rather than a value.

function identity<T>(arg:T):T{
    return arg;
}

我们定义了泛型函数后，可以用两种方法使用。 第一种是，传入所有的参数，包含类型参数：

After we define generic functions, we can use them in two ways. The first is to pass in all parameters, including type parameters:

let output=identity<string>("myString");//string

第二种方法更普遍。利用了类型推论 -- 即编译器会根据传入的参数自动地帮助我们确定T的类型：

The second method is more common. Using type inference, the compiler automatically helps

us determine the type of T based on the parameters passed in:

let output=identity("mySomething");//string

使用泛型变量

Using generic variables

function identity<T>(arg:T):T{
    return arg;
}

如果我们想同时打印出arg的长度。 我们很可能会这样做：

If we want to print the length of Arg at the same time. We are likely to do so:

function identity<T>(arg:T[]):T[]{
    console.log(arg.length);
    return arg;
}
function loggingIdentity<T>(arg:Array<T>):Array<T>{
    console.log(arg.length);
    return arg;
}

泛型类型

generic types

function identity<T>(arg:T):T{
    return arg;
}
let myIdentity:<T>(arg:T)=>T=identity;

我们也可以使用不同的泛型参数名，只要在数量上和使用方式上能对应上就可以。

We can also use different generic parameter names as long as they correspond quantitatively and in terms of usage.

function identity<T>(arg:T):T{
    return arg;
}
let myIdentity:<U>(arg:U)=>U=identity;

我们还可以使用带有调用签名的对象字面量来定义泛型函数：

We can also use object literals with call signatures to define generic functions:

function identity<T>(arg:T):T{
    return arg;
}
let myIdentity:{<T>(arg:T):T}=identity;

这引导我们去写第一个泛型接口了。 我们把上面例子里的对象字面量拿出来做为一个接口：

This leads us to write the first generic interface. Let's take the literal quantities of the

objects in the example above as an interface:

interface GenericIdentityFn{
    <T>(arg:T):T;
}
function identity<T>(arg:T):T{
    return arg;
}
let myIdentity:GenericIdentityFn=identity;

一个相似的例子，我们可能想把泛型参数当作整个接口的一个参数。 这样我们就能清楚的知道使用的具体是哪个泛型类型。

For a similar example, we might want to consider generic parameters as a parameter of the entire interface. In this way,

we can clearly know which generic type we are using.

这样接口里的其它成员也能知道这个参数的类型了。

So that other members of the interface can also know the type of this parameter.

interface GenericIdentityFn<T>{
    (arg:T):T;
}
function identity<T>(arg:T):T{
    return arg;
}
let myIdentity:GeneratorFunction<number>=identity;//把非泛型函数签名作为泛型类型一部分

除了泛型接口，我们还可以创建泛型类。 注意，无法创建泛型枚举和泛型命名空间。

In addition to generic interfaces, we can also create generic classes. Note that generic enumerations and generic namespaces cannot be created.

泛型类

generic class

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;};

与接口一样，直接把泛型类型放在类后面，可以帮助我们确认类的所有属性都在使用相同的类型。

Just like interfaces, placing generic types directly behind classes can help us confirm that all attributes of classes use the same type.

泛型约束

Generic constraints

function loggingIdentity<T>(arg:T):T{
    console.log(arg.length);
    return arg;
}

我们定义一个接口来描述约束条件。 创建一个包含 .length属性的接口，使用这个接口和extends关键字还实现约束：

We define an interface to describe constraints. Create an interface with. length attributes, and use this interface

and extends keywords to implement constraints:

interface Lengthwise{
    length:number;
}
function loggingIdentity<T extends Lengthwise>:T{
    console.log(arg.length);
    return arg;
}

在泛型约束中使用类型参数

Using type parameters in generic constraints

你可以声明一个类型参数，且它被另一个类型参数所约束。比如，

You can declare a type parameter and it is constrained by another type parameter. For example,

function find<T,U extends Findable>>(n:Text,s:U){

}
find(giraffe,myAnimals);

在泛型里使用类类型

Use class types in generics

function create<T>(c:{new():T;}):T{
    return new c();
}

使用原型属性推断并约束构造函数与类实例的关系。

Use prototype attributes to infer and constrain the relationship between constructors and class instances.

class BeeKeeper {
    hasMask: boolean;
}

class ZooKeeper {
    nametag: string;
}

class Animal {
    numLegs: number;
}
class Bee extends Animal {
    keeper: BeeKeeper;
}

class Lion extends Animal {
    keeper: ZooKeeper;
}

function findKeeper<A extends Animal, K> (a: {new(): A;
    prototype: {keeper: K}}): K {

    return a.prototype.keeper;
}

findKeeper(Lion).nametag;

by泛型这个不好懂啊，感觉也不好用啊