type type_s = { width:number, height:number, radious?:number } class Square { public width:number public height:number constructor(width:number,height:number) // 重载签名 constructor(type:type_s) // 重载签名 constructor(value:any,height?:number){ this.width = value this.height = height if(typeof value === 'object'){ let { width,height } = value this.width = width this.height = height }else{ this.width = value this.height = height } } public getArea(){ return this.width * this.height } } let s = new Square(30,40) let s2 = new Square({width:20,height:30})
// 类型断言,类型转换 // a数据类型 as b数据类型 // a和b必须要有交叠 // 判断交叠的条件
// 场景1 a和b都是类并且是父子继承关系 通常是将父类类型转换为子类类型 // class Father { // public name:string // } // class Son extends Father{ // study(){
// } // } // let fat = new Father() // let res = fat as Son 将father类型转换为son类型 // 什么是类型转换 // let res = <Son>fat // res. // let son = new Son() // let res2 = son as Father // res2. // new 的底层发生了什么
// 场景2 ab都是类 但是没有继承关系 转换后的类型必须包含转换前的类型的所有属性 转换之前的属性是转换之后的子集 // class A { // public name:string // } // class B { // public name:string // public age:number // } // let a = new A() // let res = a as B // let b = new B()
// 场景3 A是类,b是接口,A类实现了B接口 implements // interface B { // username:string, // age:number // } // class A implements B { // public username: string // public age: number // }
// 场景4 A是类 B是接口 A类没有实现B接口
// 场景5 A是类 B是type定义的类型 // type B = { // username:string, // age:number // } // class A implements B { // public username: string // public age: number // }
// 场景6 A是类 B是type定义的类型 A没有实现B定义的数据类型 // type B = { // username:string, // age:number // } // class A { // public username: string // public age: number // }
// 场景7 A是一个函数上参数的联合类型变量 // function SS(name:string | number){ // let num = name as number + 3 // }
// 场景8 多个类组成的联合类型如何断言 // let a:A | B | C // a as A // a as B // a as C
无法调用子类独有方法,必须结合instanceif类型守卫解决 属性不必完全重叠,在继承的情况下 class Father { name:string eat(){ console.log('父亲吃饭') } }
class A extends Father{ age:number eat(){ console.log('A') } }
class B extends Father { address:string eat(): void { console.log('B') } }
let fat:Father = new B()
改写汽车返回价格 class Fat { total(){
} } class car extends Fat { total(){
} } class Bus extends Fat { total(){ } aaa(){
} } car 和 Bus类中各自包含一个求总价的方法 class GetTotal { returnTotal(cartype: Fat){ return cartype.total() // 只能调用total方法 无法调用B类中独有的的aaa方法 } } let gettotal = new GetTotal() let car = new car() let bus = new Bus() gettotal(car) gettotal(bus)
新特性可变元祖
1 2 3 4
let arr:[number,string,string,string] = [123,'1','2','3'] let arr2:[number,string,...any[]] = [123,'2',123,'456'] let [username,age,...rest]:[username_:string,age_:number,...rest:any[]] = ["123",123,'456'] let [username,age,...rest,desc]:[username_:string,age_:number,...rest:any[],desc_:string] = ["123",123,'456','123']
泛型类
1 2 3 4 5 6 7 8 9 10 11 12 13 14
class Person<T>{ public List:Array<T> constructor(){ this.List = [] } add(element:T){ this.List.push(element) } } let person = new Person<string>()
typeof obj能获得该对象的类型 let obj = {name:'',age:2} console.log(typeof obj) //{name:string,age:number}
keyof K keyof表示获取一个类或者一个对象类型,或者一个接口类型的所有属性名组成的联合类型 console.log(keyof 类型/也可以是类) //name | age 甚至可以获取到类上的方法名 keyof typeof obj
T extends keyof K T是K联合类型中的某一个或者全部联合类型
let obj = {name:'',age:2} type one = typeof obj //{name:string,age:number} type two = keyof one // //name | age type objKeyType = one[two] / type objKeyType = one['name'] //string || number 得到值的类型