// 所謂的泛型，通俗一點的解釋就是泛指的類型
// 定義一個join函數(shù)，接受兩個一樣類型的參數(shù)，并將兩個參數(shù)拼接后返回。
function join<T>(first: T, second: T) {
  return `${first}${second}`
}
// 這里明確 T 為 string 類型
join<string>('第一', '第二') // 第一第二
// 這里通過類型推導的方式，編譯器會根據(jù)傳入的參數(shù)自動推斷出類型
join(1, 2) // 12

function identity<T, Y, P>(first: T, second: Y, third: P): Y {
  return second
}
// 指定類型
identity<boolean, string, number>(true, '字符串', 123) // 字符串
// 類型推斷
identity('string', 123, true) // true

class DataManager<T> {
  // 定義一個類，該類中具有一個T類型的私有數(shù)組
  constructor(private data: T[]) {}
  // 根據(jù)索引說數(shù)組中的值
  getItem(index: number): T {
    return this.data[index]
  }
}
const data = new DataManager(['一碗周'])
data.getItem(0) // 一碗周

interface Item {
  name: string
}
class DataManager<T extends Item> {
  // 定義一個類，該類中具有一個T類型的私有數(shù)組
  constructor(private data: T[]) {}
  // 根據(jù)索引說數(shù)組中的值
  getItem(index: number): string {
    return this.data[index].name
  }
}
const data = new DataManager([{ name: '一碗周' }])
data.getItem(0) // 一碗周

// 定義一個接口
interface Person {
  name: string
  age: number
  hobby: string
}
// 定義一個類
class Me {
  constructor(private info: Person) {}
  getInfo(key: string) {
    return this.info[key]
  }
}
const me = new Me({
  name: '一碗周',
  age: 18,
  hobby: 'coding',
})
// 調(diào)用 me.getInfo() 可能會得到一個 undefined 如下示例
me.getInfo('myName') // undefined

type myPerson = keyof Person // 'name' | 'age' | 'hobby'

class Me {
  constructor(private info: Person) {}
  // 該寫法與如下寫法是一樣的
  getInfo<T extends keyof Person>(key: T): Person[T] {
    return this.info[key]
  }
  // getInfo<T extends 'name' | 'age' | 'hobby'>(key: T): Person[T] {
  //     return this.info[key]
  // }
}
const me = new Me({
  name: '一碗周',
  age: 18,
  hobby: 'coding',
})
// 調(diào)用 me.getInfo() 如果傳遞一個未知的屬性則會編譯錯誤
me.getInfo('myName') // error : 類型“"myName"”的參數(shù)不能賦給類型“keyof Person”的參數(shù)。