ts基础常用语法(二)

类型

类型推论

//不设定类型,会按照值的类型默认推导出来,再次赋值时如果类型不同,编译报错
let val_1 = true
val_1 = false
// val_1 = '错的情况' //error

 类型断言

let typeStr_1: any = 'hello,wolrd'
//语法1
// let typeArr_1: Array<string> = (<string>typeStr_1).split(',')
//语法2
let typeArr_1: Array<string> = (typeStr_1 as string).split(',')
console.log(typeArr_1, typeStr_1, '断言的类型')

非空断言

let not_null: string | null | undefined
// console.log(not_null.toUpperCase()) //error
// console.log(not_null!.toUpperCase(), '非空断言') //编译通过

确定赋值断言

//未赋值报错
let send_val_1: number
// console.log(send_val_1) //error
let send_val_2!: number
console.log(send_val_2, '确定赋值断言')

联合类型

//联合类型
let andVal_1: number | string
andVal_1 = 1
andVal_1 = '哈哈哈'
console.log(andVal_1, '联合类型')

联合类型别名

type andType_1 = boolean[] | string[]
// andType_1 = [1,2,3] //error
let andtypeVal_1: andType_1 = [true, false]
console.log(andtypeVal_1, '联合类型别名')

交叉类型

//交叉类型
interface cross_1 {
    name: string
    age: number
}
interface cross_2 {
    name: string
    work: string
}
let cross_val_1: cross_1 & cross_2 = {
    name: "王惊涛",
    age: 28,
    work: '前端开发者'
}
console.log(cross_val_1, '交叉类型值')

类型守卫

//类型守卫
interface Inobj_1{
    val_1:number,
    val_2:string
}
interface InObj_2{
    val_1:number,
    val_3:string
}

in方法

//in方法
function isIn(arg:Inobj_1 | InObj_2){
    if('val_1' in arg){
        console.log('类型守卫val_1',arg)
    }
    if('val_2' in arg){
        console.log('类型守卫val_2',arg)
    }
}
isIn({val_1:10,val_2:'年'})
isIn({val_1:20,val_3:'年'})

typeof方法

function isTypefun(arg:string | number){
    if(typeof arg === 'number'){
        console.log(arg,'数字类型')
        return 'number'
    } 
    if(typeof arg === 'string'){
        console.log(arg,'字符类型')
        return 'string'
    } else{
        return '未定义'
    }

}
isTypefun('字符类型')
isTypefun(10)

instanceof方法

//instanceof方法
function isInstanceof(arg:boolean | number[]){
  if(arg instanceof Boolean){
    console.log(arg,'布尔类型')
  }else if(arg instanceof Array){
    console.log(arg,'数组类型')
  }
}
isInstanceof(true)
isInstanceof([1,2,3])

泛型

/*泛型*/
//基础语法
function genericity_1<A>(arg:A):A{
    return arg
}
genericity_1<string>('字符串类型')

//多个参数
function genericity_2<Name,Age>(arg:[Name,Age]):string{
    return '哈哈哈'
}
genericity_2<string,number>(['王惊涛',28])

//泛型接口
interface interGenericity_3<A,B>{
    val_1:A
    val_2:B
}
let interGenericity_3_1:interGenericity_3<string,number> = {
    val_1:'王惊涛',
    val_2:28
}
let interGenericity_3_2:interGenericity_3<number,string> ={
    val_1:29,
    val_2:'马师'
}
console.log(interGenericity_3_1,interGenericity_3_2,'泛型接口定义数据')