TypeScript 高级类型

1. class 类

2. 类型兼容性

3. 交叉类型

4. 泛型 和 keyof

5. 索引签名类型 和 索引查询类型

6. 映射类型

class 类

class Person {
    age: number //不加类型 默认为 any 类型
    gender = '男'
}
const p = new Person()

属性初始化

p.age
p.gender
// new Person(18, '男')

class 构造函数

class Person1 {
    age: number
    gender: string
    constructor(age: number, gender: string) {
        this.age = age
        this.gender = gender
    } //构造函数 -- 构造函数不能写返回值类型
}
const p1 = new Person1(18, '男')
console.log(p.age, p.gender);

class 实例方法

class Point {
    x = 1
    y = 2
​
    scale(n: number) {
        this.x *= n
        this.y *= n
    }
}
const p2 = new Point()

class 继承 - extends | implements

class Animal {
    move() {
        console.log('move');
    }
}
class Dog extends Animal {
    name = 'name'
    break() {
        console.log('break');
​
    }
}
const dog = new Dog()
​
​
interface Single {
    sing(): void
}
class Person2 implements Single {
    // 接口中定义了什么，调用接口时就要实现这些定义
    sing(): void {
        console.log('sing');
    }
}

class 类常见的修饰符 - 可见性修饰符：public | protected | private ;只读修饰符：readonly

// 成员可见性 -- public | protected | private
class Animal1 {
    // public | protected | private move1() {}
}
​
// readyonly 只读修饰符，只能修饰属性不能修饰方法 -- 接口 or 对象也可用
class Person3 {
    // 只要是 readonly 修饰的属性，必须手动添加类型
    readonly age: number = 18
    constructor(age: number) {//只有 constructor 才能改变只读属性的值
        this.age = age
    }
}
​
// 接口中 使用 readonly
interface IPerson {
    readonly name: string
}
let obj: IPerson = {
    name: 'jack'
}
// obj.name = 'rose' 因为是只读属性，不能修改 name 属性的值
​
// 对象的方式
let obj1: { readonly name: string } = {
    name: 'jack'
}

类型兼容性

有两种类型系统：

• 结构化类型系统 Structural Type System

  • TypeScript 采用结构化类型系统，也叫做ducktyping（鸭子类型），类型检查关注的是所具有的形状

class Point2 { x: number; y: number }
class Point2D { x: number; y: number }
const p4: Point2 = new Point2D()

• 标明性类型系统 Nominal Type System

  • 例如 java \ c#,不同的类，类型无法兼容

对象之间的类型兼容性

// 对于对象类型来说，y成员至少与x相同，则x兼容y
class Point3D { x: number; y: number; z: number }
const p5: Point2 = new Point3D()

接口之间的类型兼容性

接口之间的兼容性，类似于 class，并且 class 和 interface 之间也可以兼容。

interface Point { x: number, y: number }
interface Point2D { x: number, y: number }
interface Point3D { x: number, y: number, z: number }
let p1: Point
let p2: Point2D
let p3: Point3D
​
p1 = p2    p2 = p1    p1 = p3 // 正确演示
p3 = p1 // 错误演示
​
// class类和接口之间也是可以兼容的
class Point 4D { x: number; y: number; z: number }
p2 = new Point4D()    

函数之间的类型兼容性

函数之间兼容性比较复杂，需要考虑