TypeScript学习(五)泛型

  • 时间:
  • 来源:互联网
  • 文章标签:

1.基础泛型

泛型,可以支持不固定的类型,具体类型调用方法时决定

//传入什么类型,返回什么类型
//对参数校验
function get<T>(value:T):T{
    return value
}
console.log(get<number>(123))//123

2.类泛型

通过规定类泛型,增加类的可接收类型,避免声明多余的功能类似的类,提升代码复用

class Minclass<T>{
    public list:T[]=[];
    //增加元素
    add(...num:T[]):void{
        this.list.push(...num)
    }
    //获取最小值
    min():T{
        var min = this.list[0]
        for(let i=1;i<this.list.length;i++){
            if(min>this.list[i]){
                min=this.list[i]
            }
        }
        return min
    }
}

let m = new Minclass<number>()//规定T为number
m.add(2,3,4,9)
console.log(m.min())//2
let m2 = new Minclass<string>()//规定T为string
m2.add('a','b','c','d')
console.log(m2.min())//a

3.泛型接口

//1.
interface Config{
    <T>(value1:T):T;
}

var setData:Config=function<T>(value1:T):T{
    return value1
};

console.log(setData<string>("小李"))//小李
//2.
interface Config<T>{
    (value1:T):T;
}

var setData:Config<number>=function(value1){
    return value1
};

console.log(setData(1))//只能传入number类型

4.泛型类

将类作为参数传入,进行方法的数据校验

class User{
    username:string|undefined;
    password:string|undefined
    constructor(username:string,password:string){
        this.username=username
        this.password=password
    }
}

class MySql<T>{
    add(user:T):boolean{
        console.log(user)
        return true
    }
}
//两种传入数据定义
//1.实例化
let u = new User("张三","133")
//2.手动构造,可知属性是可多不可少
let u1={
    username:"李四",
    password:"123",
    age:20
}
let m = new MySql<User>()//指定传入类型
m.add(u1)
m.add(u)

5.泛型、接口示例

//使用接口规定固有方法
interface DB<T>{
    add(info:T):boolean;
    update(info:T,id:number):void;
    delete(id:number):boolean;
    select(id:number):T[];
}
//定义操作类
class MySql<T> implements DB<T>{
    add(info: T): boolean {
        console.log(`增加了数据${info}`)
        return true
    }
    update(info: T, id: number): void {
        console.log(`id为${id}更新数据为${info}`)
    }
    delete(id: number): boolean {
        console.log(`删除了id为${id}的数据`)
        return true
    }
    select(id: number): T[] {
        console.log(`查询了id为${id}的数据`)
        return []
    }
}

class User{
    username:string|undefined;
    password:string|undefined
    constructor(username:string,password:string){
        this.username=username
        this.password=password
    }
}

let u={
    username:"西西",
    password:"123"
}

let m =new MySql<User>()//传入User类做数据类型校验
m.add(u)//增加了数据[object Object]
m.delete(20)//删除了id为20的数据
m.select(10)//查询了id为10的数据
m.update(u,2)//id为2更新数据为[object Object]

总结

泛型的存在,可以减少类、接口的重复声明,提高代码复用性

本文链接http://www.taodudu.cc/news/show-83204.html