TS-类型断言(类型转换)

类型转换和类型断言结果一样， 语法不一样

// 类型转换
let s =  <Father>p
// 类型断言
let n =  p as Father

类型断言的第一个条件
两者具有继承关系

class Father {
    public name: string
    public age:number
    constructor(name_:string, age_: number) {
        this.name = name_
        this.age = age_
    }
    say() {

    }

}


class Son extends Father {

    public like: string
    constructor(name_:string, age_: number, like_:string) {
        super(name_, age_)
        this.like = like_
    }
    hi() {

    }

}

let  p = new Son('zs', 18, 'ss')
// 类型转换
let s =  <Father>p
// 类型断言
let n =  p as Father

如果 两个类没有继承关系，是否可以断言

两个类中的任意一个类的所有的public实例属性【不包括静态属性】加上所有的public实例方法和另一个类的所有public实例属性加上所有的public实例方法完全相同或是另外一个类的子集，这两个类就可以相互断言

总结上面一句话就是
一个类和另外一个类相同，或者一个类中的属性是另一个类中的子集

class Father {
    public name: string
    public age:number
    public like: string
    constructor(name:string, age: number, like:string) {
        this.name = name
        this.age = age
        this.like = like

    }
     public say() {}


}


class Son  {
    constructor(public name:string, public age: number, public like:string) {
        this.like = like
        this.name = name
        this.age = age
    }
}

let  p = new Son('zs', 18, 'ss')
// 类型转换
let s =  p as Father
s.say()
// 类型断言
let n =  p as Father

如果A是类，B是type定义的对象数据类型
和两个类的原理一样

type Father = {
         name: string
     age:number
     like: string
}


class Son  {
    constructor(public name:string, public age: number, public like:string) {
        this.like = like
        this.name = name
        this.age = age
    }
    kk () {

    }
}

let  p = new Son('zs', 18, 'ss')
// 类型转换
let s =  p as Father
s.name
// 类型断言
let n =  p as Father

联合类型的类型转换
最近在工作中也遇到了这个问题，类型断言真香

function Test(one: string | number) {
   one =  one as number +3
}

任何数据类型都可以转换成 any 或 unknown 类型， any 或 unknown 类型也可以转换成任何其他数据类型。
注意一点 unknown 不能作为其他类型的子类，只能是父类
下面的这段代码是会报错的

let num: number
let  s:unknown
num = s

联合类型只能取中间属性
可以使用类型断言

interface A {
   name: string
   age: number
}


interface B {
   name: string
   num: number
}

function Test(one: A | B) {
   one.name
}

function Test(one: A | B) {
   one as A
}

类型断言存在的意义和使用场景

对象中的Symbol 数据类型取值问题
加法计算， 巧用 as any

function add(one: string | number, two: string | number) {
   return one as any + two as any
}
add(1, "2")