ts学习第七篇 泛型

export {}
// 泛型

function creatArray0(length: number, value: any): Array<any> {
  let result: any[] = []
  for(let i = 0; i < length; i++) {
    result[i] = i
  }
  return result
}
// 以上函数满足返回一个数组的要求,但是传参value没有用上, 而我们的期望是返回的数组内容是传参value, 那么就需要用到泛型, 如下:
function creatArray<T>(length: number, value: T): Array<T> {
  let result: T[] = []
  for(let i = 0; i < length; i++) {
    result[i] = value
  }
  return result
}

let result = creatArray<string>(3, 'x')
console.log(result); // ['x', 'x', 'x']



// 泛型类
class MyArray<T> {
  private list: T[] = []
  add(value: T) {
    this.list.push(value)
  }
  getVal(): T {
    return this.list[0]
  }
}
let array0 = new MyArray<number>()
array0.add(1)
array0.add(2)
array0.add(3)
console.log(array0.getVal()); //1



// 泛型与new
function factory<T>(type: {new(): T}):T {
  return new type()
}
class Person{}
let p = factory<Person>(Person)  //表示传入的参数type(Person) new之后返回的类型为Person, 函数factory的最终返回结果类型也是Person
console.log(p); //Person {} 类型为Person

// {new(): T} 表示传入的参数type new之后返回的类型为T



// 泛型接口
// 第一种情况
interface Calculate {
  <T>(a:T, b:T):T
}

let sum: Calculate = function<T>(a:T, b:T):T {
  return a
  // return a + b  会报错, 因为T为任意类型,而只有number和string类型可以相加
}
sum<number>(1, 2)  //T在里面时调用函数时确定类型


// 第二种情况
interface Calculate0<T> {  //如果T放在外面则在定义类型时就应该传入类型, 如下:
  (a:T, b:T):T
}

let sum0: Calculate0<number> = function(a:number, b:number):number