TS的对象类型

TypeScript 对象类型

这里所说的对象类型，就是我们常说的函数、数组、类、{}、object、Object 类型

object

object 类型用于表示所有的非原始类型，即我们不能把 number、string、boolean、symbol等 原始类型赋值给 object。在严格模式下，null 和 undefined 类型也不能赋给 object。

    let object: object;
    object = 1; // 报错
    object = "a"; // 报错
    object = true; // 报错
    object = null; // 报错
    object = undefined; // 报错
    object = {}; // 编译正确

Object

大 Object 代表所有拥有 toString、hasOwnProperty 方法的类型 所以所有原始类型、非原始类型都可以赋给 Object(严格模式下 null 和 undefined 不可以)

    let bigObject: Object;
    object = 1; // 编译正确
    object = "a"; // 编译正确
    object = true; // 编译正确
    object = null; // 报错
    ObjectCase = undefined; // 报错
    ObjectCase = {}; // ok

{}

{} 空对象类型和大 Object 一样 也是表示原始类型和非原始类型的集合

类

在 TypeScript 中，我们通过 Class 关键字来定义一个类

    class Person {
        name: string;
        age: number;
        constructor(name: string, age: number) {
            this.name = name;
            this.age = age;
        }
        sayHi(): void {
            console.log(`Hi, ${this.name}`);
        }
    }

类的修饰符

定义的属性需要提前声明属性的类型 前面还需要添加修饰符

public :公有 在当前类里面、子类、类外都可以访问

protected :保护 在当前类里面、子类里面都可以访问，在类外部无法访问

private :私有 在当前类里面可以访问，子类、类外部都无法访问

属性如果不加修饰符，默认就是公有 (public)

类的静态属性方法

与es6中相同 添加关键字static即为静态属性方法

抽象类

提供其他类继承的基类，不能直接被实例化

用abstract关键字定义抽象类和抽象方法

抽象类中的抽象方法不包含具有实现并且必须在派生类中实现

abstract抽象方法只能放在抽象类里面

抽象类和抽象方法用来定义标准 要求子类必须包含抽象方法

abstract class Animal{
  public name:string
  constructor(name:string){
    this.name=name;
  }
  abstract eat():any; // 抽象类的子类必须实现抽象类里面的抽象方法
  run(){
    console.log('其他方法可以不实现');
  }
}
// 继承的子类必须具有eat()方法

数组

    const flag1: number[] = [1, 2, 3];
    const flag2: Array<number> = [1, 2, 3];

函数

函数声明

    function add(x: number, y: number): number {
        return x + y;
    }

函数表达式

    const add = function(x: number, y: number): number {
        return x + y;
    }

接口定义函数

    interface Add {
        (x: number, y: number): number;
    }
    
    type fun = (x: number) => number

可选参数

    function add(x: number, y?: number): number {
        return y ? x + y : x;
    }

默认参数

    function add(x: number, y: number = 0): number {
        return x + y;
    }

剩余参数

    function add(...numbers: number[]): number {
        let sum = 0;
        for (let i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
        return sum;
    }

函数重载

函数重载或方法重载是使用相同名称和不同参数数量或类型创建多个方法的一种能力。

    function add(x: number, y: number): number;
    function add(x: string, y: string): string;
    function add(x: any, y: any): any {
        return x + y;
    }

上面示例中，我们给同一个函数提供多个函数类型定义，从而实现函数的重载

需要注意的是：函数重载真正执行的是同名函数最后定义的函数体 ，在最后一个函数体定义之前全都属于函数类型定义 ，不能写具体的函数实现方法 只能定义类型。

定义：定义函数重载需要定义重载签名和一个实现签名。其中重载签名定义函数的形参和返回类型，没有函数体。
一个函数可以有多个重载签名:主要是可以精确显示函数的输入输出，对应于调用该函数的不同方式。
此外， 实现签名还具有参数类型和返回类型，而且还有实现函数的主体，且只能有一个实现签名。
实现签名主要是将所有的输入输出类型做一个全量定义，防止TS编译报错，实现签名就是整个整个函数实现的全部逻辑 。