typescript6-高级类型

交叉类型

1. 将多个类型合并成为一个新的类型,新类型具有所有类型的特性

interfaceA{
    name:string}interfaceB{
    age:number}typeC=A&Bconst c:C={
    name:'jack',
    age:19}console.log(c)

联合类型

1. 表示必须满足其中一个

// 表示可以是string或者numberconst getLengthFunc=(content:string|number):number=>{if(typeof content==='string')return content.length
    elsereturn content.toString().length
}console.log(getLengthFunc('123'))// 3console.log(getLengthFunc(123))// 3

类型保护

1. 类型保护就是一些表达式，它们会在运行时检查以确保在某个作用域里的类型

constgetRandomValue=()=>{const num=Math.random()if(num>0.5)return'123'elsereturn123}const item=getRandomValue();functionisString(value:string|number):value isstring{returntypeof value ==='string'}if(isString(item)){console.log(item.length)}else{console.log(item.toFixed())}

1. typeof类型保护，类型只能是string/number/boolean/symbol中的一种
2. instanceof类型保护

classCreatClass1{public name='jack'}classCreatClass2{public age=20}functiongetRandomClass(){const random=Math.random()return random>0.5?newCreatClass1():newCreatClass2()}const item=getRandomClass()if(item instanceofCreatClass1){console.log(item.name)}else{console.log(item.age)}

类型别名

1. 可以对类型名字重新定义
2. 类型别名可以嵌套
3. 为接口起别名时，不能使用extends | interface

typeTypeString=stringlet str:TypeString;typePositionType<T>={
    x:T,
    y:T,}const position:PositionType<number>={
    x:1,
    y:1}console.log(position)typeChilds<T>={
    current:T,
    child?:Childs<T>}const c:Childs<string>={
    current:'first',
    child:{
        current:'second',
        child:{
            current:'third'}}}console.log(c)typeDirection='first'|'second'|'third';functiongetDirction(direction:Direction){return direction.substr(0,1)}// 只能传入 'first' | 'second' | 'third'中的一个console.log(getDirction('first'))

可辨识联合

• 具有普通的单例类型属性— 可辨识的特征
• 一个类型别名包含了那些类型的联合
• 此属性上的类型保护

interfaceSquare{
    kind:'Square',
    size:number}interfaceRectangle{
    kind:'Rectangle',
    height:number,
    width:number}interfaceCircle{
    kind:'Circle',
    radius:number}/**  * kind 作为唯一特征，用来做判断  *  */typeShape=Square | Rectangle |Circle;functionassertNever(value:never):never{throwError('Unexpected object'+ value)}functiongetArea(c:Shape):number{switch(c.kind){case'Square':return c.size;break;case'Rectangle':return c.width*c.height;break;case'Circle':return Math.PI*c.radius**2;break;default:returnassertNever(c)}}const circle:Circle={
     kind:'Circle',
     radius:20}console.log(getArea(circle))

多态的this类型

1. 也就是接口或者类的子类型
2. 在父类型中方法结束时return当前实例对象出去，让子类不具备此方法但依然可以调用父类的方法

classCounter{constructor(public count:number=0){}publicadd(value:number){this.count+=value;returnthis;}publicsubtract(value:number){this.count-=value;returnthis;}}const counter=newCounter(10)
counter.add(1).subtract(2)console.log(counter)// Counter {count: 9}classPowCounterextendsCounter{constructor(count:number){super(count);}publicpow(value:number){this.count=this.count**value;}}const powCounter=newPowCounter(20)
powCounter.pow(2)
powCounter.add(100)console.log(powCounter)// PowCounter {count: 500}

索引类型

• keyof 索引类型查询操作符
• T[K] 索引访问操作符,也就是T上是否有K
• 可以检查对象上是否有对应键值对

interfaceInfoI{
    name:string,
    age:number}let infoProps:keyof InfoI
// infoProps 只能是接口定义的键值
infoProps='name'
infoProps='age'functiongetValue<T,KextendskeyofT>(obj:T,names:K[]):T[K][]{return names.map(item=>obj[item])}const infoObj={
    name:'jack',
    age:20}const infoValue:(string|number)[]=getValue(infoObj,['name','age'])console.log(infoValue)

映射类型

• 从旧类型中创建出一个新的类型
• TS内置Readonly只读和Partial可选

typeMapToPromise<T>={[KinkeyofT]:Promise<T[K]>}typeTuple=[number,string,boolean]typepromiseTuple=MapToPromise<Tuple>let tuple:promiseTuple=[newPromise((resolve)=>resolve(1)),newPromise((resolve)=>resolve('1')),newPromise((resolve)=>resolve(false)),]console.log(tuple)

unknown

• 任何类型都可以赋值给unknown类型
• 如果没有类型断言或者基于控制流的类型细化时，unknown不可赋值给其他类型
• 如果没有类型断言或者基于控制流的类型细化时，不能在上面进行任何操作
• unknown与任何其他类型组成的交叉类型，返回其他类型
• unknown与其他类型（除了any是any）组成的联合类型，都等于unknown
• never是unknown的子类型
• keyof unknown是never类型
• 只能对unknown进行等或不等操作，不能进行其他操作
• unknown类型的值不能访问它的属性，不能作为函数调用，不能作为类创建实例
• 如果映射用的unknown类型，则不会映射任何类型

条件类型

• 类似于三元运算符
• T extends U ? X : Y

typeType<T>=Textendsstring?string:numberlet type:Type<string>='a'// 分布式条件类型typeType2<T>=Textendsstring?string:Textendsnumber?number:Textends()=>void?()=>void:
    object;typetype2=Type2<((()=>void)|number)>// type2类型为()=>void | number

• 条件类型的类型推断infer

typeType1<T>=TextendsArray<inferU>?U:T;typetype=Type1<string[]>

• Exclude 交集 | Extract 并集

typeType1=Exclude<'a'|'b'|'c','a'>// Type1类型为'b'|'c'typeType2=Extract<'a'|'b'|'c','a'>// Type2类型为'a'

• NonNullable 去除null和undefined | ReturnType 返回函数的返回类型

typeType1=NonNullable<string|number|null|undefined>// Type1类型为string | numbertypeType2=ReturnType<()=>string>// Type2类型为string

• InstanceType根据类型推断出类的类型

classAClass{constructor(public name:number=10){}}typeType1=InstanceType<typeof AClass>typeType2=InstanceType<any>