TypeScrip中泛型的案例详解

泛型的定义

// 需求一： 泛型 可以支持不特定的数据类型， 要求，传入的参数和返回参数一致

// 这种方式虽然能实现传入和返回的参数一致，但是失去类型参数检验
/*
function getdata(value: any): any {
    return "success"
}
*/

// 定义泛型解决需求一
// t表示泛型(这里的大写字母可以随便定义，但一般默认为t) 具体什么类型是调用这个方法的时候决定的
function getdata<t>(value: t):t{
    return value;
}

// 传入的字符串类型
var get = getdata<string>("hello")
console.log(get)

// 传入的类型为数字
var gettwo = getdata<number>(666)
console.log(gettwo)

// 需求二：比如有个最小堆算法，需要同时支持返回数字和字符串两种类型，通过类的泛型来实现

// 定义类的泛型
class mincla<t> {
    list: t[] = [];

    add(value: t):void {
        this.list.push(value);
    }

    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
    }
}

var minnum = new mincla<number>();
minnum.add(2);
minnum.add(1);
minnum.add(7);
console.log(minnum.min());  // 返回 1


// 字符的比较是按ascii码比较的
var minnumtwo = new mincla<string>();
minnumtwo.add("c");
minnumtwo.add("z");
minnumtwo.add("a");
console.log(minnumtwo.min())    // 返回a

泛型的接口

// 实现泛型接口的两种方式
// 方式一：
// 定义一个泛型接口
interface func {
    <t>(value: t): t
}

// 定义一个函数实现泛型接口
var f: func = function<t>(value: t) {
    return value;
}
f<string>("hello")
f<number>(666)

// 方式二：
interface funcone {
    <t>(value: t): t
}

var f1: funcone = function<t>(value: t):t {
    return value;
}

f1<string>("world")
f1<number>(666)

实现泛型类

/*
1、定义一个user类，这个类的作用是映射数据库字段
2、然后定义一个mysqldb的类这个类用于操作数据库
3、然后把user类作为参数传入到mysqldb中
*/

/*版本一：
class user {
    usernam: string | undefined;
    password: string | undefined;
}

class mysqldb {
    add(user: user): boolean {
        console.log(user);
        return true;
    }
}

var u1 = new user();
u1.usernam = "pika";
u1.password = "pika"

var msql = new mysqldb();
msql.add(u1);
*/

// 但是上述定义的表和数据库不能保证传入的数据的正确性
// 版本二
// 定义操作数据库的泛型
class mysqldb <t>{
    add(info: t): boolean {
        console.log(info);
        return true;
    }
}

// 定义一个user类和数据库进行映射
class user {
    usernam: string | undefined;
    password: string | undefined;
}

var u1 = new user();
u1.usernam = "pika";
u1.password = "pika"

// 实例化一个数据库(类当成一个参数来约束传入参数的类型)
var msql = new mysqldb<user>();
msql.add(u1);   // 保证传入数据的格式是user类型的

综合案例

需求：
功能： 定义一个操作数据库的库 支持mysql mongodb
要求1： mysql mongodb功能一样，都有add update delete get方法
注意： 约束统一的规范、以及代码重用
解决方案： 需要约束规范所以要定义接口，需要代码重用所以用到泛型
    1、接口： 在面向对象编程中，接口是一种规范的定义，它定义了行为和动作的规范
    2、泛型：通俗理解：泛型就是解决 类 接口 方法的复用性
*/

// 实现流程：
// 定义一个接口，对所有方法的约束
interface dbmethod<t> {
    add(info: t): boolean;
    update(info: t, id: number): boolean;
    delete(id: number): boolean;
    get(id: number): boolean;
}

// 定义一个mysql数据库类，注意：要实现泛型接口 这个类也应该是一个泛型类
class mysqldbs<t> implements dbmethod<t> {
    add(info: t): boolean {
        console.log(info);
        return true;
    }    
    
    update(info: t, id: number): boolean {
        var obj = {
            username: "xxxx",
            password: "666"
        }
        return true
    }

    delete(id: number): boolean {
        console.log("delete success");
        return true
    }
    
    get(id: number): boolean {
        var arr = [
            {username: "xxx",
            password: "xxxxx"
            }
        ];
        return true
    }
}
// 测试：
class users {
    username: string | undefined;
    password: string | undefined;
};

// 使用users类来约束传入的参数正确性
var mysql = new mysqldbs<users>();
var u = new users();
u.username = "xxxx"
u.password = "xxxxxx"
// 模拟数据库的增删改查
mysql.add(u);
mysql.get(1);
mysql.update(u, 1);
mysql.delete(1)



// 定义一个mongodb数据库类，注意：要实现泛型接口 这个类也应该是一个泛型类
class mongodb<t> implements dbmethod<t> {
    add(info: t): boolean {
        console.log(info);
        return true;
    }    
    
    update(info: t, id: number): boolean {
        var obj = {
            username: "xxxx",
            password: "666"
        }
        return true
    }

    delete(id: number): boolean {
        console.log("delete success");
        return true
    }
    
    get(id: number): boolean {
        var arr = [
            {username: "xxx",
            password: "xxxxx"
            }
        ];
        return true
    }
}

// 测试：
class userd {
    username: string | undefined;
    password: string | undefined;
};

// 使用users类来约束传入的参数正确性
var mysql = new mongodb<userd>();
var u = new userd();
u.username = "xxxx"
u.password = "xxxxxx"
// 模拟数据库的增删改查
mysql.add(u);
mysql.get(1);
mysql.update(u, 1);
mysql.delete(1)

到此这篇关于typescrip中泛型的案例详解的文章就介绍到这了,更多相关typescrip中泛型内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！