Typescript泛型、泛型类

考虑api支持的数据类型的可重用性，不仅支持当前的，同时还能支持未来的数据类型，通过泛型来创建可重用的组件，一个组件可以支持多种类型的数据。
泛型就是解决类/接口/方法的复用性，以及对不特性数据类型的支持

// 只能返回string类型的数据 - 期望能返回string,number两种类型
// 重复定义函数 定义两种返回值，代码冗余
function getData(value:string):string{
	return value;
}
function getData(value:number):number{
	return value;
}
// 或 (any相当于放弃了类型检查，传入什么返回什么。
function getData(value:any):any{
	return value;
}

1. 泛型
避免重复的代码以及可以支持不特定的数据类型（类型校验）。

• 要求：传入的参数和返回的参数类型一致
• T表示泛型，具体什么类型是调用这个方法决定的

// 三个字母可以是任意字母，建议用T
function getData<T>(value:T):T{
	return value				
	// 返回值不能返回固定的类型会和T冲突，解决：返回值类型设置为any
}
getData<number>(123)

2. 泛型类

// 普通类
class MinClass{
	public list:number[] = [];
	add(num:number){
		this.list.push(num)
	}
	min():number{
		var minNum = this.list[0]
		for(var i=0;i<this.list.length;i++){
			if(minNum > this.list[i]){
				minNum = this.list[i]
			}
		}
		return minNum;
	}
}
let m =new MinClass()
m.add(2)
m.min()

// 泛型类
// T 都是由传入参数类型决定
class MiniClass<T>{
	public list:T[] = [];
	add(val:T):void{
		this.list.push(val)
	}
	min():T{
		var minNum = this.list[0]
		for(var i=0;i<this.list.length;i++){
			if(minNum > this.list[i]){
				minNum = this.list[i]
			}
		}
		return minNum;
	}
}
// 实例化类，并且指定了类的T代表类型是number
var m1=new MinClass<number>() 
m1.add(3)

3. 泛型接口

函数类型接口

interface ConfigFn{
	(value:string,value2:string):string;
}
var setData:ConfigFn = function(value1:string,value2:string):string{
	return value1+value2
}
setData('name'+'zhangsan')

泛型接口

// 方法1：
interface ConfigFn{
	<T>(value:T):T;
}
var getData:ConfigFn = function<T>(value:T):T{
	return value
}
getData<string>('123')

// 方法2：
interface ConfigFn<T>{
	(value:T):T;
}
function getData<T>(value:T):T{
	return value
}
var myGetData:ComfigFn<string> = getData;
myGetData('123')

4. 泛型类作为参数
泛型类 - 把类作为参数类型的泛型类
定义一个User的类这个类的作用就是映射数据库字段，然后定义一个MysqlDb的类，这个类用于操作数据库，再把User类作为参数传入MysqlDb中

class User{
	username:string | underfined;	//	前面省略的public
	password:string | underfined;
}
class MysqlDb{
	add(user:User):boolean{
		return true
	}
}
var u = new User();
u.username = '张三'
u.password = '123456'

var Db = new MysqlDb()
Db.add(u)

// 操作数据库的泛型类
class MysqlDb<T>{
	add(user:T):boolean{
		return true
	}
}
class User{
	username:string | underfined;
	password:string | underfined;
}
var u = new User();
u.username = '张三'
u.password = '123456'

var Db = new MysqlDb<User>()	 // 验证传入数据的合法性
Db.add(u)

1.定义类和数据库进行映射

class MysqlDb<T>{
	add(info:T):boolean{
		console.log(info)
		return true
	}
	update(info:T,id:number):boolean{
		console.log(info)
		console.log(id)
		return true
	}
}
class ArticleCate{
	title:string | undefined;
	desc:string | undefined;
	status:number | underfined;
	constructor(params:{
		title:string | undefined,
		desc:string | undefined,
		status?:number | underfined
	}){
		this.title = params.title;
		this.desc = params.desc;
		this.status = params.status
	}
}

var a = new ArticleCate({
	title:"分类"，
	desc:"11111"
})
// 类当作参数的泛型类
var Db = new MysqlDb<ArticleCate>();
Db.add(a)

// updata 方法:修改数据
var a = new ArticleCate({
	title:"分类"，
	desc:"11111"
})
a.status = 0
var Db = new MysqlDb<ArticleCate>();
Db.update(a,12)

TypeScript类型、接口、类、泛型综合使用-封装统一操作Mysql Mongodb Mssql的底层库
定义一个操作数据库的库，支持Mysql Mongodb Mssql，且都有add update delete get方法
约束统一的规范以及代码重用。

interface DBI<T>:{
	add(info:T):boolean;
	update(info:T,id:number):boolean;
	delete(id:number):boolean;
	get(id:number):any[];
}

// 定义一个操作mysql数据库的类
// 要实现泛型接口这个类也应该是泛型类
class MysqlDb<T> implements DBI<T>{
	add(info:T):boolean {
		throw new Error("Method not implemented.")
	}
	update(info:T,id:number):boolean{
		throw new Error("Method not implemented.")
	}
	delete(id:number):boolean{
		throw new Error("Method not implemented.")
	}
	get(id:number):any[]{
		throw new Error("Method not implemented.")
	}
}