TypeScript的泛型

泛型就是解决类、接口等方法的复用性问题,以及对不特定数据的支持问题的类型

如:我们想通过传入不同类型的值而返回对应类型的值,在TypeScript中可以通过any类型的返回值解决返回值的不同,但是不能解决规定同一个函数传入指定不同类型参数的问题,而且用any作为返回类型性能没有泛型高,并且不符合规范

1. 泛型函数

可以使用TypeScript中的泛型来支持函数传入不特定的数据类型,要求传入的参数和返回的参数一致

function fun(value: T): T { // 一般用T代表泛型,当然也可以是其他的非关键字和保留字,可以在函数内用
  let data: T; // T就代表着泛型函数要使用的泛型,通过后期的传入来使用
  data = value;
  return data;
}

console.log(fun(true));
console.log(fun(123)); // 如果不对泛型函数指定泛型,默认为any类型

2. 泛型类

通过泛型类可以实现对类内部不同类型变量的分别管理

// 如:有个最小堆算法,需要同时支持返回数字和字符串两种类型,可以通过类的泛型来实现
class MinNum {
  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(); // 通过泛型实现类不同变量类型的内部算法,比any类型效率更高
min1.add(1);
min1.add(2);
min1.add(996);
min1.add(7);
console.log(min1.min()); // 1

let min2 = new MinNum();
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 {
  show(info: T): void {
    console.log(info);
  }
}

let per = new Person();
per.name = "张三";
per.age = 18;
let stu = new Student(); // T在这传入的是泛型类,作为show方法的校验
stu.show(per);

let user = new User();
user.password = "123456";
user.userName = "张三";

let stu2 = new Student(); // 可以写入不同的类
stu2.show(user);

案例

/*
  功能: 定义一个操作数据库的类,支持Mysql,Mssql,MongoDb
  要求: Mysql、Mssql、MongoDb功能一样,都有add、updata、delete、get方法
  注意: 约束统一的规范、以及代码重用
  解决方案: 需要约束规范所以要定义接口,需要代码重用所以用泛型
*/
interface DBI {
  add(info: T): boolean;
  update(info: T, id: number): boolean;
  delete(info: T): boolean;
  get(id: number): any[];
}

// 定义一个操作mysql数据库的类
// 注意:要实现泛型接口,这个类应该是个泛型类
class MysqlDb implements DBI {
  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 implements DBI {
  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(); // 类作为约束条件

oMysql.add(u);
console.log(oMysql.get(10));

3. 泛型接口

通过对接口使用泛型,对函数和类接口的使用来自己实现对于传入参数调节的限制

// 因为类和函数接口差距不大,所以这里就只写函数类泛型接口
// 第一种写法
interface encrypt {
  (value: T): T;
}

let md5: encrypt = function (value: T): T {
  // 通过泛型函数赋值
  return value;
};

console.log(md5("张三")); // 泛型声明刚好和接口内部的顺序相呼应
console.log(md5(true));

// 第二种写法
interface encrypt {
  (value: T): T;
}
// 在将接口给变量的时候就指定类型给
let md5: encrypt = function (value: T): T {
  // 通过泛型函数赋值
  return value;
};
// 在这就可以直接使用函数,而不需要指定泛型
console.log(md5("张三"));

// 其实两种方法根据对于接口写的位置的不同可以大致推断出其泛型声明指定的位置

你可能感兴趣的:(TypeScript的泛型)