泛型用於在成員之間提供有意義的約束，這些成員可以是類的例項成員、類的方法、函式引數、函式返回值。

類

class Queue<T> {
  private data: T[] = [];
  push(item: T) {
    this.data.push(item)
  }

  pop(): T | undefined {
    return this.data.shift()
  }
}


// 示例一
const queue = new Queue<number>();
queue.push(0);
queue.push('1'); // ERROR

// 示例二

const queue = new Queue<string>();
queue.push('0');
queue.push(1); // ERROR
 

number做為型別傳遞給Queue，在內部可以使用T表示該型別，並用於內部方法和屬性的約束

類成員函式

class Utility {
  reverse<T>(items: T[]): T[] {
    const toreturn = [];
    for (let i = items.length; i >= 0; i--) {
      toreturn.push(items[i]);
    }
    return toreturn;
  }
}



const a = new Utility()

const b = a.reverse<number>([1,23,'3']); // ERROR
 

配合Axios使用

import axios from 'axios'

// GET user

interface ResponseData<T = any> {
  code: number;
  result: T;
  message: string;
}


export function getUser<T>() {
  return axios.get<ResponseData<T>>('/user').then(res => res.data)
}


interface User {
  name: string;
  age: number;
}

async function test() {
  // user 被推斷出為
  // {
  //  code: number,
  //  result: { name: string, age: number },
  //  message: string
  // }
  const user = await getUser<User>();
}

 

把型別User當做一個引數，更容易理解泛型推倒的過程.