泛型

用法

再不确定参数类型的时候可以用泛型来修饰函数

// 这里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)   !!!报错