泛型 即 将类型参数化， 由调用者 决定应该是什么类型, 当你确定参数的类型的时候 就不一定要用 泛型了

  1. //定义函数时  我不决定这些参数的类型
  2. //而是让调用者以参数的形式告知  我这里的函数参数应该是什么类型
  4. function sum<Type>(num:Type):Type{
  5.     return num
  6. }
  8. //使用的时候再决定它的类型
  9. sum<number>(20)
  11. function identity<Type>(arg: Type): Type {
  12.   return arg;
  13. }
  15. let myIdentity: <Type>(arg: Type) => Type = identity;
  18. interface Gener{
  19.     <T>(arg:T):T
  20. }
  22. function id<T>(arg:T):T{
  23.     return arg
  24. }
  26. let myI:Gener = id

常见的名称/使用习惯

T : Type缩写 类型

K、V : key和value 的缩写, 键值对

E : Element的缩写, 元素

O : Object的缩写,对象

  1. function foo<T,E,O>(arg1:T,arg2:E,arg3:O){
  3. }
  5. foo<number,string,boolean>(10,"abc",true)
  1. //遍历对象索引
  2. function foo<O>(args:O){
  3.     for(let key in args){
  4.         console.log(key)
  5.     }
  6. }
  8. foo<object>({
  9.     test:'123',
  10.     abc:'123213'
  11. })
  14. //遍历数组
  15. function foo1<T>(...args:T[]){
  16.     for(let key of args){
  17.         console.log(key)
  18.     }
  19. }
  21. foo1<number>(10,20,30)
接口使用泛型
  1. //可以定义默认类型
  2. interface IPerson<T1=string,T2=number>{
  3.     name:T1
  4.     age:T2
  5. }
  7. const p:IPerson<string,number> = {
  8.     name:'why',
  9.     age:18
  10. }
类与泛型
  1. //类与泛型
  2. class Point<T>{
  3.     x:T
  4.     y:T
  5.     z:T
  7.     constructor(x:T,y:T,z:T){
  8.         this.x = x
  9.         this.y = y
  10.         this.z = z
  11.     }
  12. }
  14. //类型推导
  15. const p1 = new Point("1.33.2","2.22.3","4.22.1")
  16. //显式声明
  17. const p2 = new Point<string>("1.33.2","123","4.22.1")
  18. const p3:Point<string> = new Point("1.33.2","123","4.22.1")
泛型的类型限制
  1. //泛型的类型约束
  2. //通过extends 对类型进行限制
  3. interface ILength{
  4.     length:number
  5. }
  7. function getLength<T extends ILength>(arg:T){
  8.     return arg.length
  9. }
  11. getLength("123")
泛型继承
  1. interface Props{
  2.   length:number
  3. }
  4. const calcArray = <T extends Props,>(data:T):number=>{
  5.   return data.length