TypeScript基本知识（4）

泛型(动态类型)

interface Pair<T> {

first: T

second: T

}

let pair: Pair<string> = { first: "Hello", second: "World" }

function xiaoman(a: string, b: string): Array<string> { 
    return [a,b]
}

function xiaoman1<T>(a: T, b: T): Array<T> { 
    return [a,b]
}

xiaoman1(1, 2)
xiaoman1('1', '2')

type AA<T> = string | number | T

// let a:A<boolean> = 1
let aa:AA<Boolean> = true

interface Data<T> {
    msg: T
}

let data: Data<number> = {
    msg:1
}

function add<T, D>(a: T, b: D): Array<T | D> { 
    return [a,b]
}
add(1, '2')

interface Data1 { 
    message: string
    code: number
}

const axios = {
    get<T>(url: string): Promise<T> { 
        return new Promise((resolve, reject) => { 
            let xhr: XMLHttpRequest = new XMLHttpRequest()
            xhr.open('GET', url)
            xhr.onreadystatechange = () => { 
                if (xhr.readyState === 4 && xhr.status === 200) { 
                    resolve(JSON.parse(xhr.responseText))
                } 
            }
            xhr.send(null)
        })
    }
}

axios.get<Data1>('./data.json').then((res) => { 
    console.log(res)
})

泛型约束

// 泛型约束 在类型后面跟一个extends，再跟一个约束类型
function add<T extends number>(a:T, b:T) {
  return a + b
}

add(1,2)

let obj = {
  name:'小满',
  sex: '女'
}

type Key = keyof typeof obj // name | age

function ob<T extends object, K extends keyof T>(obj: T, key: K) {
  return obj[key]
}

ob(obj,'name')

interface Data {
  name: string
  age: number
  sex: string
}

//for in
type Options<T extends object> = {
  [Key in keyof T]? : T[Key]
}

type B = Options<Data>

// 结果
type B = {  
    name?: string | undefined;  
    age?: number | undefined;  
    sex?: string | undefined;  
}