TS语法五 类型推论和兼容性

一 类型推论：

• 基础
• 多类型联合
• 上下文类型

二 类型兼容性：
1.基础
2.函数兼容性

• 参数个数
• 参数类型
• 返回值类型
• 可选参数和剩余参数
• 参数双向协变
• 函数重载

3.类
4.泛型

类型推论

//1.基础
let name5 = 'lyy'
// name5 = 222    报错

//2.多类型联合
let arr = [1, 'a']   //ts会自动将其推断为 let arr: Array<number | string> = [1, 'a']
arr = [2, 3, 'aaa']
// arr = [1, false]  报错，不支持boolean类型

//根据上下文判断
window.onmousedown = (mouseEvent) => {
    console.log(mouseEvent)
}
//mouseEvent的属性和方法根据左边判断出来

类型兼容性

interface User {
    name: string
}
let user1: User
const user2 = {name:'lyy'}
const user3 = {age:18}
const user4 = {name:'lyy', age:18}
user1 = user2 
// user1 = user3   报错，不可以缺少name属性
user1 = user4   //可以多出属性，但是不能缺少name属性

//函数兼容性
//参数个数
let x = (a: number) => 0
let y = (b: number, c: string) => 0
// x = y   报错，右边的参数个数必须小于等于左边的参数个数
y = x

//参数类型
let x1 = (a: number) => 0
let y1 = (c: string) => 0
// x1 = y1   类型必须相同，且同一位置的参数类型必须相同

//可选参数和剩余参数
const getSum = (arr: number[], callback: (...args: number[]) => number ) => {
    return callback(...arr)
}

let num1 = getSum([1,2,3], (...args:number[]):number => {
   return args.reduce((a,b)=>a+b,0)
})
console.log(num1)
let num2 = getSum([1,2,3], (arg1:number, arg2:number, arg3:number):number => {
    return arg1 + arg2 + arg3
})
console.log(num2)

//函数参数双向协变
let funcA = (arg: number|string):void => {}
let funcB = (arg: number):void => {}
funcB = funcA
// funcA = funcB  报错

//返回值类型
let x2 = (): string|number => 0
let x3 = (): string => 'a'
x2 = x3
// x3 = x2   报错

//函数重载
function merge(arg1: number, arg2: number):number
function merge(arg1: string, arg2: string):string
function merge(arg1: any, arg2: any){
    return arg1 + arg2
}

function sum(arg1: number, arg2: number):number
function sum(arg1: any, arg2: any){
    return arg1 + arg2
}

let func1 = merge
// func1 = sum  报错

let func2 = sum 
func2 = merge    // merge中包含了sum的几种情况


//类
class c1 {
    public static age: number
    constructor(public name:string){}
}

class c2 {
    public static age: string
    constructor(public name:string){}
}

class c3 {
    constructor(public name:number){}
}

let test1: c1
let test2: c2
let test3: c3
test1 = test2
// test2 = test3   报错，类作为类型时，只会比较类的实例成员，不会比较静态属性

//泛型
interface Data<T>{}
let data1: Data<number>
let data2: Data<string>
data1=data2

interface DataI<T>{
    data: T
}
let data3: DataI<number>
let data4: DataI<string>
// data3=data4   报错，DataI里有类型为T的data