一 类型推论：
- 基础
- 多类型联合
- 上下文类型
二 类型兼容性：
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