6.TypeScript的接口： 用于约束类、对象、函数的契约（标准）

扩展类型： 类型别名、枚举、接口、类

TypeScript的接口： 用于约束类、对象、函数的契约（标准）

契约（标准）的形式：

• API文档，弱标准
• 代码约束，强标准
  和类型别名一样接口不出现在编译结果中

1.接口约束对象
2.约束函数

interface User{
    name: string
    age: number
    sayHello: () => void
    sayHello(): void
}

type User = {
    name: string
    name: number
}


let u:User = {
    name: 'lj',
    age: 23
}

接口和类型别名最主要的区别在于约束类。

type Condition = (n: number) => boolean;

interface Condition { // 定界符
    (n: number): boolean
}

接口可以继承

class MyComponent extends React.Component{
    
}

可以通过接口之间的继承，实现多种接口的组合

使用类型别名可以实现类似的组合效果，需要通过&, 它叫做交叉类型

interface A  {
    T1: string
}

interface B extends A  {
    T2: string
}

interface C extends A, B {
    T3: string
}

type A , typeB
typeC = {
    T3: string
} & A & B

他们的区别：
接口：子接口不能覆盖父接口的成员
交叉类型会把相同成员的类型进行交叉

readonly

只读修饰符，修饰的目标是只读

interface User = {
    readonly id: string,
    name: string,
    age: number
    readonly arr: string[]
}

let u:User = {
    id: "123",
    name: "asdf",
    age: 23
}

只读修饰符不在编译结果中。

let arr: readonly number[] = [1, 2, 3, 4];
arr = [4, 5, 6, 7]

const arr: ReadonlyArray<number> = [3, 4, 6]

readonly 修饰的是 number[],表示是一个只读的数组
使用readonly后，数组能使用的方法都不见了

readonly 修饰成员（作为属性）时，arr不可以被重新赋值，可以往数组里添加值
要想去掉数组方法：

readonly arr: readonly string[]

类型兼容性

B->A,如果能完成赋值，则B和A类型兼容

鸭子辨型法（子结构辨型法）： 目标类型需要某一些特征，赋值的类型只要能满足该特征即可

• 基本类型： 完全匹配
• 对象类型： 鸭子辨型法

interface Duck{
    sound: 'gagaga',
    swin(): void
}

let person = {
    name: "伪装成鸭子的人",
    age: 11,
    sound: 'gagaga',
    swin() {
        
    }
    
}

类型断言:

    sound: 'gagaga',
    swin(): void
}

let person = {
    name: "伪装成鸭子的人",
    age: 11,
    sound: 'gagaga' as 'gagaga',  // 前面是数据 后面是断言的类型
    swin() {
        
    }
    
}

let duck: Duck = person;

当直接使用对象字面量赋值的时候，会进行更加严格的判断

let duck: Duck = {
    sound: 'gagaga',
    swin() {
        
    }
}
type User = {
    name?: string
    age: number
}
let u:User = {
    name: '',
    age: 11
}

• 函数类型

一切无比自然

参数: 传递给目标函数的参数可以少，但不可以多
返回值: 要求返回必须返回；不要求返回，你随意。