TypeScript-泛型篇

１. 什么是泛型

泛型：软件工程中，我们不仅要创建一致的定义良好的API，同时也要考虑可重用性。 

组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能。

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

这样用户就可以以自己的数据类型来使用组件。

通俗理解：泛型就是解决 类 接口 方法的复用性、以及对不特定数据类型的支持(类型校验)

	//<任意字母即可> 一般使用T  形参的类型和返回值一般也是T 
	function getDate<T>(name: T, value: T): T {
	    console.log(name);
	    console.log(value);
	    return value
	}
	getDate<number>(123, 456);//调用后面加<类型> 后面调用的时候
	getDate<string>("missing", "kissing")

２. 泛型类的实现

	函数最小堆功能，要求同时支持返回number和string
	class MyComputed {
	    public list: number[] = [];
	    add(num: number) {
	        this.list.push(num);
	    };
	    min() {
	        let minNum = this.list[0];
	        let len = this.list.length
	        for (let index = 0; index < len; index++) {
	            if (minNum > this.list[index]) {
	                minNum = this.list[index]
	            }
	        };
	        return minNum;
	    }
	}
	let myComputed = new MyComputed();
	myComputed.add(20);
	myComputed.add(10);
	myComputed.add(30);
	myComputed.add(40);
	let minMax = myComputed.min();
	console.log(minMax)//10
	以上代码有局限性例如只能传入number类型的值 不便于使用
	以下使用泛型进行改造
	class minNumber<T> {
	    public list: T[] = []
	    add(value: T): void {
	        this.list.push(value)
	};
	minMyNumber(): T {
	        let minNum = this.list[0];
	        let len = this.list.length
	        for (let index = 0; index < len; index++) {
	            if (minNum > this.list[index]) {
	                minNum = this.list[index]
	            }
	 };
	    return minNum;
	 }
	}
	let minNumber1 = new minNumber<number>();
	minNumber1.add(20);
	minNumber1.add(10);
	minNumber1.add(30);
	let min = minNumber1.minMyNumber();
	console.log(min);//10
	let minNumber2 = new minNumber<string>();
	minNumber2.add('a');
	minNumber2.add('b');
	minNumber2.add('c');
	let strNumber = minNumber2.minMyNumber();
	console.log(strNumber);//a通过对比ascll码表

３. 泛型接口

定义泛型接口有两种方式
		第一种
		interface myConfig {
		    <T>(value: T): T
		};
		const getData1: myConfig = function <T>(value: T): T {
		    return value;
		}
		const data1 = getData1<string>('miss');
		console.log(data1);//miss
		
		第二种写法
		interface Config<T> {
		    (value: T): T;
		}
		function getData<T>(value: T): T {
		    console.log(value);
		    return value;
		}
		let myData: Config<string> = getData;
		myData("Missing");
		
		把类当做参数来约束传入的类型
		class MuSqlDB <T> {
		    add(info:T):boolean{
		        console.log(info);
		        return true;
		    }
		};
		
		
		class ArticleCate {
		    title : string | undefined;
		    name : string | undefined;
		    age :number | undefined;
		    constructor(params : {
		        title : string | undefined;
		        name : string | undefined;
		        age : number | undefined;
		    }) {
		        this.title = params.title;
		        this.name = params.name;
		        this.age = params.age;
		    }
		}
		let articleCate = new ArticleCate({
		    title : 'Title',
		    name : "Loki",
		    age : 200,
		});
		
		let muSqlDB = new MuSqlDB <ArticleCate> ();
		muSqlDB.add(articleCate);

谢谢观看 ！！！ 如有不足，敬请指教