泛型

泛型是一種參數(shù)化數(shù)據(jù)類型，具有以下特點(diǎn)
1：定義時(shí)不明確，使用時(shí)必須明確成 某種具體數(shù)據(jù)類型 的數(shù)據(jù)類型【泛型的寬泛】
2：編譯期間進(jìn)行 數(shù)據(jù)類型安全檢查 的數(shù)據(jù)類型【泛型的嚴(yán)謹(jǐn)】

泛型類的格式： class 類名<泛型形參類型>{ }

  class ArrayList<T>{  
    array: Array<T>
    add(data:T){
        ....
    }
    ....
  }

泛型形參類型一般有兩種表示:
1、 A-Z 任何一個(gè)字母（絕大多數(shù)情況是這種）
2、 語義化的單詞來表示

class ArrayList<T> {
  public element: Array<T>;
  constructor() {
    this.element = [];
  }
  public index: number = 0;
  public add(ele: T) {
    this.element[this.index++] = ele;
  }
  get(index: number): T {
    return this.element[index];
  }
}

type stuType = { stuname: string; age: number; address: string };
let stuOne: stuType = { stuname: "wnagwu", age: 23, address: "beijing" };
let stuTwo: stuType = { stuname: "lisi", age: 39, address: "shanghai" };
let stuThree: stuType = { stuname: "liuqi", age: 31, address: "nanjing" };

let arrayList3 = new ArrayList<stuType>();
arrayList3.add(stuOne);
arrayList3.add(stuTwo);
arrayList3.add(stuThree);

let stuobj = arrayList3.get(1);
console.log(stuobj.stuname); //能點(diǎn)出來

//泛型如果在使用時(shí)沒有具體化的類型,那么就會默認(rèn)為unknown數(shù)據(jù)類型
//class ArrayList<T=any> {} //這樣默認(rèn)值就是any
//class ArrayList<T=number> {}
//這樣默認(rèn)值就是number,但下面的arrayList5.add("abc")就會報(bào)錯(cuò)
let arrayList5 = new ArrayList();
arrayList5.add(3);
arrayList5.add("abc");
arrayList5.add(stuOne);
arrayList5.get(2); //點(diǎn)不出來，類型“unknown”

泛型約束

泛型約束簡單點(diǎn)說就是把泛型的具體化數(shù)據(jù)類型范圍縮小
T extends object 表示具體化的泛型類型只能是 object 類型

泛型接口+ 泛型類 + 泛型約束 + 多態(tài)

//泛型接口 + 泛型類
interface List<T> {
  add(ele: T): void;
  get(index: number): T;
  size(): number;
}

class ArrayList<T> implements List<T> {
  public array: Array<T>;
  public index: number = 0;
  constructor() {
    this.array = [];
  }
  public add(ele: T) {
    this.array[this.index++] = ele;
  }
  size() {
    return this.index ? this.index : 0;
  }
  get(index: number): T {
    return this.array[index];
  }
}

// 定義繼承類（多態(tài)）
abstract class People {
  public name!: string;
  public abstract info(): void;
  public eat() {
    console.log("人類-吃飯");
  }
}

class Man extends People {
  public info() {
    console.log("男人");
  }
}
class Woman extends People {
  public info() {
    console.log("女人");
  }
}

// 結(jié)合使用
class Tcs {
  //泛型約束
  public rent<T extends object>(list: List<T>) {
    for (let i = 0; i < list.size(); i++) {
      let res = list.get(i);
      console.log("get拿到的類型是：", res);
      //雖然傳入前和get拿到的類型是一樣的，外部可以點(diǎn)操作，這里不行。
      //是因?yàn)檎l知道你傳入的泛型類是否一定有info()函數(shù)，所以需as斷言后才能使用點(diǎn)
      //或者泛型約束為People類型
      (res as any).info(); //用了any自然不能點(diǎn)操作
    }
  }
}

//let aList: List<String> = new ArrayList<String>();
//泛型約束是為了防止，如上句，泛型為String則會影響Tcs類的內(nèi)部代碼使用
let aList: List<People> = new ArrayList<People>();
//上句：左邊是List接口，右邊是ArratList接口。同樣是多態(tài)，接口的多態(tài)
let bus: People = new Woman(); //類的多態(tài)
console.log("傳入前的類型是：", bus);
aList.add(bus);
aList.add(new Man()); //類的多態(tài)

let tc = new Tcs();
tc.rent(aList);
export {};

泛型函數(shù)：

格式： 函數(shù)名<泛型1,泛型2> (參數(shù)中可以使用泛型類型)：返回值也可以是泛型類型

泛型函數(shù)好處：可在調(diào)用返回后 得到返回值的具體數(shù)據(jù)類型，從而有點(diǎn)操作和類型錯(cuò)誤的提示

let numArr: number[] = [1, 3, 5, 7];
let strArr: Array<string> = ["a", "c", "e", "g"];

// Array<T> 等于 T[]
function funa<T>(arr: Array<T>): T[] {
  let newNumArr: Array<T> = [];
  newNumArr.push(arr[0]);
  return newNumArr;
}
console.log("funa1:", funa(numArr)); // [ 1 ]
console.log("funa2:", funa(strArr)); // [ 'a' ]

泛型函數(shù)+重載

function funb(data: string): string;
function funb<T>(data: T): T;
function funb(data: any): any {
  if (typeof data === "string") {
    return "字符串類型";
  }
  if (data instanceof Array) {
    return funa(data);
  }
}
console.log("funb1:", funb("abcde")); // 字符串類型
console.log("funb2:", funb(numArr)); // [ 1 ]