ts 泛型 泛型约束 typeof keyof

/泛型

 //两个函数只是定义类型不一样，功能一样，可优化
 function  num(a:number,b:number):Array<number>{
     return [a,b]
 }

 num(2,5)

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

 str('今天','周二')



 //泛型优化

 function Add<T>(a:T,b:T):Array<T>{
     return [a,b]
 }
Add<number>(1,2)
Add<string>('1','2')

//同时也可以使用参数类型不同

function Addy<T,Y>(a:T,b:Y):Array<T | Y>{
    return [a,b]
}
Addy<number,string>(1,'2')

type A<T> = string | number | T

let A:A<null> = null
let AB:A<string> = '1'




//定义泛型接口
interface smile<T>{
    msg:T
}

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

//泛型约束

function AddN<T extends number>(a:T,b:T) {
    return a + b
}

AddN(2,6)


interface  Student{
    name:String,
    age:Number,
    class:Number
}




type Options <T extends Object> = {
     [key in keyof T ]? : T[key]
}

type AD = Options<Student>


// keyof : 获取对象的key组成的联合类型

//typeof是 根据已有的值 来获取值的类型

const a ={name:"张三",age:18}
type keyofa =keyof typeof a