# 用法
再不确定参数类型的时候可以用泛型来修饰函数
// 这里T可以不固定,可以是任意字母,常用T来修饰有着type类型的意思
function getArr<T>(value:T,count:number):T[]{
const arr:Array<T>=[]
for(let i=0;i<count;i++){
arr.push(value)
}
return arr
}
const arr=getArr<number>(200,2)
const arr2=getArr<string>('200',2)
# 多个泛型参数
function getMsg<K,V>(value:K,value:V):[K,V]{
return [value1,value2]
}
const arr=getMsg<string,number>('111',1)
# 泛型接口
定义接口时,不确定接口中数据是什么类中可以用泛型
// 定义一个泛型接口
interface IBaseCRUD<T>{
data:Array<T>
add:(t:T)=>T
getUserId:(id:number)=>T
}
// 定义一个用户信息类
class User{
id?:number
name:string
age:number
constructor(name:string,age:number){
this.named=name
this.age=age
}
}
// 定义一个可以针对用户信息增加以及查询的操作
class UserCRUD implements IBaseCRUD<User>{
data:Array<User>=[]
add(user:User):User{
user.id=Data.now()+Math.random()
this.data.push(user)
return user
}
getUserId(id:number):User{
return this.data.find(user=>user.id===id)
}
}
const userCRUD:UserCRUD=new UserCRUD()
userCRUD.add(new User('路飞',21))
userCRUD.add(new User('索隆',31))
let {id}=userCRUD.add(new User('罗宾',38))
console.log(userCRUD.getUserId(id))
# 泛型类
定义一个类,类中的属性类型不确定,方法的参数以及返回值也不确定
// 定义一个泛型类
class Person<T>{
name:T
add:(x:T,y:T)=>T
}
// 实例化类的时候确定泛型的类型
const person:Person<number>=new Person<number>()
person.name=2
person.add=function(x,y){
return x+y
}
person.add(1,2)
# 泛型约束
定义一个接口,用来约束将来某个类中中必须要有length这个属性
interface Ilength{
length:number
}
function getLength<T extends Ilength>(x:T):number{
return x.length
}
getLength<string>('111')
// getLength<number>(1) !!!报错