泛型就是解决类、接口等方法的复用性问题,以及对不特定数据的支持问题的类型
如:我们想通过传入不同类型的值而返回对应类型的值,在TypeScript
中可以通过any
类型的返回值解决返回值的不同,但是不能解决规定同一个函数传入指定不同类型参数的问题,而且用any
作为返回类型性能没有泛型高,并且不符合规范
1. 泛型函数
可以使用TypeScript
中的泛型来支持函数传入不特定的数据类型,要求传入的参数和返回的参数一致
function fun<T>(value: T): T { // 一般用T代表泛型,当然也可以是其他的非关键字和保留字,可以在函数内用
let data: T; // T就代表着泛型函数要使用的泛型,通过后期的传入来使用
data = value;
return data;
}
console.log(fun<boolean>(true));
console.log(fun(123)); // 如果不对泛型函数指定泛型,默认为any类型
2. 泛型类
通过泛型类可以实现对类内部不同类型变量的分别管理
// 如:有个最小堆算法,需要同时支持返回数字和字符串两种类型,可以通过类的泛型来实现
class MinNum<T> {
public list: T[] = [];
add(value: T): void {
this.list.push(value);
}
min(): T {
let minNum = this.list[0];
for (let i in this.list) {
if (minNum > this.list[i]) {
minNum = this.list[i];
}
}
return minNum;
}
}
let min1 = new MinNum<number>(); // 通过泛型实现类不同变量类型的内部算法,比any类型效率更高
min1.add(1);
min1.add(2);
min1.add(996);
min1.add(7);
console.log(min1.min()); // 1
let min2 = new MinNum<string>();
min2.add("a");
min2.add("c");
min2.add("e");
console.log(min2.min()); // a
2.1 把类当做参数的泛型类
// 将类当做传参的约束条件,只允许指定的类的实例作为参数传入
class Person {
name: string | undefined;
// 这里如果没有写或者为undefined时会报错,因为TypeScript怕定义了却不赋值,除非在construct中进行了赋值
age: number | undefined;
}
class Student {
show(info: Person): boolean { // 参数只允许传入Person类的对象
console.log(info);
return true;
}
}
let per = new Person();
per.name = "张三";
per.age = 18;
let stu = new Student();
stu.show(per);
// 使用泛型类可以手动的对不同种类的条件进行约束
// 将类当做传参的约束条件,只允许指定的类的实例作为参数传入
class Person {
name: string | undefined;
age: number | undefined;
}
class User {
userName: string | undefined;
password: string | undefined;
}
class Student<T> {
show(info: T): void {
console.log(info);
}
}
let per = new Person();
per.name = "张三";
per.age = 18;
let stu = new Student<Person>(); // T在这传入的是泛型类,作为show方法的校验
stu.show(per);
let user = new User();
user.password = "123456";
user.userName = "张三";
let stu2 = new Student<User>(); // 可以写入不同的类
stu2.show(user);
案例
/*
功能: 定义一个操作数据库的类,支持Mysql,Mssql,MongoDb
要求: Mysql、Mssql、MongoDb功能一样,都有add、updata、delete、get方法
注意: 约束统一的规范、以及代码重用
解决方案: 需要约束规范所以要定义接口,需要代码重用所以用泛型
*/
interface DBI<T> {
add(info: T): boolean;
update(info: T, id: number): boolean;
delete(info: T): boolean;
get(id: number): any[];
}
// 定义一个操作mysql数据库的类
// 注意:要实现泛型接口,这个类应该是个泛型类
class MysqlDb<T> implements DBI<T> {
add(info: T): boolean {
console.log(info);
return true;
}
update(info: T, id: number): boolean {
throw new Error("Method not implemented.");
}
delete(info: T): boolean {
throw new Error("Method not implemented.");
}
get(id: number): any[] {
return [
{
title: "xxx",
desc: "xxxxx",
id: id
},
{
title: "xxx",
desc: "xxxxx",
id: id
}
];
}
}
// 定义一个操作mssql数据库的类
class MssqlDb<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(info: T): boolean {
throw new Error("Method not implemented.");
}
get(id: number): any[] {
throw new Error("Method not implemented.");
}
}
// 操作用户表,定义一个User类和数据表做映射
class User {
username: string | undefined;
password: string | undefined;
}
let u = new User();
u.username = "张三";
u.password = "123456";
let oMysql = new MysqlDb<User>(); // 类作为约束条件
oMysql.add(u);
console.log(oMysql.get(10));
3. 泛型接口
通过对接口使用泛型,对函数和类接口的使用来自己实现对于传入参数调节的限制
// 因为类和函数接口差距不大,所以这里就只写函数类泛型接口
// 第一种写法
interface encrypt {
<T>(value: T): T;
}
let md5: encrypt = function <T>(value: T): T {
// 通过泛型函数赋值
return value;
};
console.log(md5<string>("张三")); // 泛型声明刚好和接口内部的顺序相呼应
console.log(md5<boolean>(true));
// 第二种写法
interface encrypt<T> {
(value: T): T;
}
// 在将接口给变量的时候就指定类型给
let md5: encrypt<string> = function <T>(value: T): T {
// 通过泛型函数赋值
return value;
};
// 在这就可以直接使用函数,而不需要指定泛型
console.log(md5("张三"));
// 其实两种方法根据对于接口<T>写的位置的不同可以大致推断出其泛型声明指定的位置