/* * 泛型 * 使用泛型创建可重用的组件，一个组件可以支持多种类型的数据 * 【自我理解】把参数的类型也设置为类似函数形参一样的形式，可以根据开发者的意愿随时改变参数的类型----<类型变量> * 包括:传入类型 和 返回类型【学习程度】学了一遍，感觉知识点模模糊糊，还是需要练习和多加复习！！ * */// 示例
//identity函数叫做泛型
function identity<T>(arg: T): T {
return arg;
}
//定义泛型的两种方法 1.类型变量 2.类型推断
let output = identity<string>('string 泛型示例');
// let output = identity("myString"); // type of output will be 'string'
console.log(output)//使用泛型变量
//数组 两种写作形式
function loggingIdentity<T>(arg: Array<T>): Array<T> {
console.log(arg.length); // Array has a .length, so no more errorreturn arg;
}
loggingIdentity<string>(['1','2','3']);
loggingIdentity<number>([1,2,3]);
function loggingIdentity1<T>(arg: T[]): T[] {
console.log(arg.length); // Array has a .length, so no more errorreturn arg;
}//泛型类型
//泛型接口
interface GenericIdentityFn {
<T>(arg: T): T;
}function identity2<T>(arg: T): T {
return arg;
}
//使用带有调用签名的对象字面量来定义泛型函数
let myIdentity: GenericIdentityFn = identity;
console.log(myIdentity(1))//泛型类
//【备注】类有两部分：静态部分和实例部分。 泛型类指的是实例部分的类型，所以类的静态属性不能使用这个泛型类型。
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; };//泛型约束
//【注】定义一个接口来描述约束条件，被约束之后的函数不再适用于任意类型
//定义一个包含.length属性的接口，使用这个接口和extends关键字来实现约束
interface Lengthwise {
length: number;
}function loggingIdentity2<T extends Lengthwise>(arg: T): T {
console.log(arg.length); // Now we know it has a .length property, so no more errorreturn arg;
}
loggingIdentity2('string');
// loggingIdentity2(3); //报错 Argument of type '3' is not assignable to parameter of type 'Lengthwise'.//在泛型约束中使用参数
function getProperty<T, K extends keyof T>(obj: T, key: K) {
//官网写法不全。。。return obj[key];
}let x = {
a: 100, b: 2, c: 3, d: 4 };console.log(getProperty(x, "a")); // okay
// getProperty(x, "m"); // error: Argument of type 'm' isn't assignable to 'a' | 'b' | 'c' | 'd'.//在泛型里使用类类型
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 createInstance<A extends Animal>(c: new () => A): A {
return new c();
}createInstance(Lion).keeper.nametag; // typechecks!
createInstance(Bee).keeper.hasMask; // typechecks!
不确定性和未知的魅力，因为不确定，所以有希望，因为未知，所以期待！