1-8、基础篇：类

八、类

TypeScript提供了对ES2015中引入的 class 关键词的完全支持。

与其他JavaScript语言功能一样，TypeScript增加了类型注释和其他语法，允许你表达类和其他类型之间的关系。

8.1 类成员

这里有一个最基本的类——一个空的类：

class Point {}

这个类还不是很有用，所以我们开始添加一些成员。

8.1.1 类属性

在一个类上声明字段，创建一个公共的可写属性：A mapped type is a generic type which uses a union of PropertyKeys (frequently created via a keyof) to iterate through keys to create a type:

class Point {
  x: number;
  y: number;
}

const pt = new Point();
pt.x = 0;
pt.y = 0;

与其他位置一样，类型注解是可选的，但如果不指定，将是一个隐含的 any 类型。

字段也可以有初始化器；这些初始化器将在类被实例化时自动运行。

class Point {
  x = 0;
  y = 0;
}

const pt = new Point();
// Prints 0, 0
console.log(`${pt.x}, ${pt.y}`);

就像 const、let和var一样，一个类属性的初始化器将被用来推断其类型。

const pt = new Point();
pt.x = "0";

• --strictPropertyInitialization

strictPropertyInitialization设置控制是否需要在构造函数中初始化类字段。

class BadGreeter {
  name: string;
}

class GoodGreeter {
  name: string;

  constructor() {
    this.name = "hello";
  }
}

请注意，该字段需要在构造函数本身中初始化。TypeScript不会分析你从构造函数中调用的方法来检测初始化，因为派生类可能会覆盖这些方法而无法初始化成员。

如果你打算通过构造函数以外的方式来确定初始化一个字段（例如，也许一个外部库为你填充了你的类的一部分），你可以使用确定的赋值断言操作符 ！。

class OKGreeter {
  // 没有初始化，但没报错。
  name!: string;
}

8.1.2 readonly

字段的前缀可以是 readonly 修饰符。这可以防止在构造函数之外对该字段进行赋值。

class Greeter {
  readonly name: string = "world";

  constructor(otherName?: string) {
    if (otherName !== undefined) {
      this.name = otherName;
    }
  }

  err() {
    this.name = "not ok";
  }
}
const g = new Greeter();
g.name = "also not ok";

8.1.3 构造器

类构造函数与函数非常相似。你可以添加带有类型注释的参数、默认值和重载：

class Point {
  x: number;
  y: number;

  // 带默认值的正常签名
  constructor(x = 0, y = 0) {
    this.x = x;
    this.y = y;
  }
}

class Point {
  // 重载
  constructor(x: number, y: string);
  constructor(s: string);
  constructor(xs: any, y?: any) {
    // ...
  }
}

类的构造函数签名和函数签名之间只有一些区别：

• 构造函数不能有类型参数–这属于外层类的声明，我们将在后面学习。

• 构造函数不能有返回类型注释——类的实例类型总是被返回的。

Super 调用

就像在JavaScript中一样，如果你有一个基类，在使用任何 this.成员之前，你需要在构造器主体中调用super();。

class Base {
  k = 4;
}

class Derived extends Base {
  constructor() {
    // 在ES5中打印一个错误的值；在ES6中抛出异常。
    console.log(this.k);
    super();
  }
}

在JavaScript中，忘记调用 super 是一个很容易犯的错误，但TypeScript会在必要时告诉你。

8.1.4 方法

一个类上的函数属性被称为方法。方法可以使用与函数和构造函数相同的所有类型注释。

class Point {
  x = 10;
  y = 10;

  scale(n: number): void {
    this.x *= n;
    this.y *= n;
  }
}

除了标准的类型注解，TypeScript并没有为方法添加其他新的东西。

请注意，在一个方法体中，仍然必须通过this访问字段和其他方法。方法体中的非限定名称将总是指代包围范围内的东西。

let x: number = 0;

class C {
  x: string = "hello";

  m() {
    // 这是在试图修改第1行的'x'，而不是类属性。
    x = "world";
  }
}

8.1.5 Getters / Setters

类也可以有访问器：

class C {
  _length = 0;
  get length() {
    return this._length;
  }
  set length(value) {
    this._length = value;
  }
}

请注意，一个没有额外逻辑的字段支持的get/set对在JavaScript中很少有用。如果你不需要在get/set操作中添加额外的逻辑，暴露公共字段也是可以的。

TypeScript对访问器有一些特殊的推理规则：

• 如果存在 get，但没有set，则该属性自动是只读的

• 如果没有指定setter参数的类型，它将从getter的返回类型中推断出来

• 访问器和设置器必须有相同的成员可见性

从TypeScript 4.3开始，可以有不同类型的访问器用于获取和设置。

class Thing {
  _size = 0;

  get size(): number {
    return this._size;
  }

  set size(value: string | number | boolean) {
    let num = Number(value);

    // 不允许NaN、Infinity等

    if (!Number.isFinite(num)) {
      this._size = 0;
      return;
    }

    this._size = num;
  }
}

8.1.6 索引签名

类可以声明索引签名；这些签名的作用与其他对象类型的索引签名相同。

class MyClass {
  [s: string]: boolean | ((s: string) => boolean);

  check(s: string) {
    return this[s] as boolean;
  }
}

因为索引签名类型需要同时捕获方法的类型，所以要有用地使用这些类型并不容易。一般来说，最好将索引数据存储在另一个地方，而不是在类实例本身。

8.2 类继承

像其他具有面向对象特性的语言一样，JavaScript中的类可以继承自基类。

8.2.1 implements子句

你可以使用一个 implements 子句来检查一个类，是否满足了一个特定的接口。如果一个类不能正确地实现它，就会发出一个错误。

interface Pingable {
  ping(): void;
}

class Sonar implements Pingable {
  ping() {
    console.log("ping!");
  }
}

class Ball implements Pingable {
  pong() {
    console.log("pong!");
  }
}

类也可以实现多个接口，例如 class C implements A, B {

注意事项

重要的是要明白， implements 子句只是检查类是否可以被当作接口类型来对待。它根本不会改变类的类型或其方法。一个常见的错误来源是认为 implements 子句会改变类的类型–它不会！它不会。

interface Checkable {
  check(name: string): boolean;
}

class NameChecker implements Checkable {
  check(s) {
    // any：注意这里没有错误
    return s.toLowercse() === "ok";
  }
}

在这个例子中，我们也许期望 s 的类型会受到 check的name: string参数的影响。事实并非如此–实现子句并没有改变类主体的检查方式或其类型的推断。

同样地，实现一个带有可选属性的接口并不能创建该属性。

interface A {
  x: number;
  y?: number;
}
class C implements A {
  x = 0;
}
const c = new C();
c.y = 10;

8.2.2 extends子句

类可以从基类中扩展出来。派生类拥有其基类的所有属性和方法，也可以定义额外的成员。

class Animal {
  move() {
    console.log("Moving along!");
  }
}

class Dog extends Animal {
  woof(times: number) {
    for (let i = 0; i < times; i++) {
      console.log("woof!");
    }
  }
}

const d = new Dog();
// 基类的类方法
d.move();
// 派生的类方法
d.woof(3);

8.2.3 重写方法

派生类也可以覆盖基类的一个字段或属性。你可以使用super.语法来访问基类方法。注意，因为JavaScript类是一个简单的查找对象，没有 “超级字段 “的概念。

TypeScript强制要求派生类总是其基类的一个子类型。

例如，这里有一个合法的方法来覆盖一个方法。

class Base {
  greet() {
    console.log("Hello, world!");
  }
}

class Derived extends Base {
  greet(name?: string) {
    if (name === undefined) {
      super.greet();
    } else {
      console.log(`Hello, ${name.toUpperCase()}`);
    }
  }
}

const d = new Derived();
d.greet();
d.greet("reader");

派生类遵循其基类契约是很重要的。请记住，通过基类引用来引用派生类实例是非常常见的（而且总是合法的！）。

// 通过基类引用对派生实例进行取别名
const b: Base = d;
// 没问题
b.greet();

如果Derived没有遵守Base的约定怎么办？

class Base {
  greet() {
    console.log("Hello, world!");
  }
}

class Derived extends Base {
  // 使这个参数成为必需的
  greet(name: string) {
    console.log(`Hello, ${name.toUpperCase()}`);
  }
}

如果我们不顾错误编译这段代码，这个样本就会崩溃：

const b: Base = new Derived();
// 崩溃，因为 "名称 "将是 undefined。
b.greet();

8.2.4 初始化顺序

在某些情况下，JavaScript类的初始化顺序可能会令人惊讶。让我们考虑一下这段代码：

class Base {
  name = "base";
  constructor() {
    console.log("My name is " + this.name);
  }
}

class Derived extends Base {
  name = "derived";
}

// 打印 "base", 而不是 "derived"
const d = new Derived();

这里发生了什么？

按照JavaScript的定义，类初始化的顺序是：

• 基类的字段被初始化
• 基类构造函数运行
• 派生类的字段被初始化
• 派生类构造函数运行

这意味着基类构造函数在自己的构造函数中看到了自己的name值，因为派生类的字段初始化还没有运行。

8.2.5 继承内置类型

注意：如果你不打算继承Array、Error、Map等内置类型，或者你的编译目标明确设置为ES6/ES2015或以上，你可以跳过本节。

在ES2015中，返回对象的构造函数隐含地替代了super(...)的任何调用者的this的值。生成的构造函数代码有必要捕获super(...)的任何潜在返回值并将其替换为this。

因此，子类化Error、Array等可能不再像预期那样工作。这是由于Error、Array等的构造函数使用ECMAScript 6的new.target来调整原型链；然而，在ECMAScript 5中调用构造函数时，没有办法确保new.target的值。其他的下级编译器一般默认有同样的限制。

对于一个像下面这样的子类：

class MsgError extends Error {
  constructor(m: string) {
    super(m);
  }
  sayHello() {
    return "hello " + this.message;
  }
}

你可能会发现：

• 方法在构造这些子类所返回的对象上可能是未定义的，所以调用 sayHello 会导致错误。

• instanceof将在子类的实例和它们的实例之间被打破，所以（new MsgError()）instanceof MsgError将返回false。

作为建议，你可以在任何super(...)调用后立即手动调整原型。

class MsgError extends Error {
  constructor(m: string) {
    super(m);

    // 明确地设置原型。
    Object.setPrototypeOf(this, MsgError.prototype);
  }

  sayHello() {
    return "hello " + this.message;
  }
}

然而，MsgError的任何子类也必须手动设置原型。对于不支持Object.setPrototypeOf的运行时，你可以使用__proto__来代替。

不幸的是，这些变通方法在Internet Explorer 10和更早的版本上不起作用。我们可以手动将原型中的方法复制到实例本身（例如MsgError.prototype到this），但是原型链本身不能被修复。

8.2 成员的可见性

你可以使用TypeScript来控制某些方法或属性对类外的代码是否可见。

8.2.1 public

类成员的默认可见性是公共(public)的。一个公共(public)成员可以在任何地方被访问。

class Greeter {
  public greet() {
    console.log("hi!");
  }
}
const g = new Greeter();
g.greet();

因为public已经是默认的可见性修饰符，所以你永远不需要在类成员上写它，但为了风格/可读性的原因，可能会选择这样做。

8.2.2 protected

受保护的(protected)成员只对它们所声明的类的子类可见。

class Greeter {
  public greet() {
    console.log("Hello, " + this.getName());
  }
  protected getName() {
    return "hi";
  }
}

class SpecialGreeter extends Greeter {
  public howdy() {
    // 在此可以访问受保护的成员
    console.log("Howdy, " + this.getName());
  }
}
const g = new SpecialGreeter();
g.greet(); // 没有问题
g.getName(); // 无权访问

• 受保护成员的暴露

派生类需要遵循它们的基类契约，但可以选择公开具有更多能力的基类的子类型。这包括将受保护的成员变成公开。

class Base {
  protected m = 10;
}
class Derived extends Base {
  // 没有修饰符，所以默认为'公共'('public')
  m = 15;
}
const d = new Derived();
console.log(d.m); // OK

8.2.3 private

private和protected一样，但不允许从子类中访问该成员。

class Base {
  private x = 0;
}
const b = new Base();
// 不能从类外访问
console.log(b.x);

class Base {
  private x = 0;
}
const b = new Base();

class Derived extends Base {
  showX() {
    // 不能在子类中访问
    console.log(this.x);
  }
}

因为私有(private)成员对派生类是不可见的，所以派生类不能增加其可见性。

• 跨实例的私有访问

不同的OOP语言对同一个类的不同实例，是否可以访问对方的私有成员，有不同的处理方法。虽然像Java、C#、C++、Swift和PHP等语言允许这样做，但Ruby不允许。

TypeScript确实允许跨实例的私有访问：

class A {
  private x = 10;

  public sameAs(other: A) {
    // 可以访问
    return other.x === this.x;
  }
}

• 注意事项

像TypeScript类型系统的其他方面一样，private和protected只在类型检查中被强制执行。

这意味着JavaScript的运行时结构，如in或简单的属性查询，仍然可以访问一个私有或保护的成员。

class MySafe {
  private secretKey = 12345;
}

// 在JS环境中...
const s = new MySafe();
// 将打印 12345
console.log(s.secretKey);

private也允许在类型检查时使用括号符号进行访问。这使得私有声明的字段可能更容易被单元测试之类的东西所访问，缺点是这些字段是软性私有的，不能严格执行私有特性。

class MySafe {
  private secretKey = 12345;
}

const s = new MySafe();

// 在类型检查期间不允许
console.log(s.secretKey);

// 正确
console.log(s["secretKey"]);

与TypeScript的 private不同，JavaScript的private字段（#）在编译后仍然是private的，并且不提供前面提到的像括号符号访问那样的转义窗口，使其成为硬private。

class Dog {
  #barkAmount = 0;
  personality = "happy";

  constructor() {
    // 0
    console.log(this.#barkAmount);
  }
}

const dog = new Dog();
// undefined
console.log(dog.barkAmount);

当编译到ES2021或更少时，TypeScript将使用WeakMaps来代替 #。

"use strict";
var _Dog_barkAmount;
class Dog {
  constructor() {
    _Dog_barkAmount.set(this, 0);
    this.personality = "happy";
  }
}
_Dog_barkAmount = new WeakMap();

如果你需要保护你的类中的值免受恶意行为的影响，你应该使用提供硬运行时隐私的机制，如闭包、WeakMaps或私有字段。请注意，这些在运行时增加的隐私检查可能会影响性能。

8.3 静态成员

类可以有静态成员。这些成员并不与类的特定实例相关联。它们可以通过类的构造函数对象本身来访问。

class MyClass {
  static x = 0;
  static printX() {
    console.log(MyClass.x);
  }
}
console.log(MyClass.x);
MyClass.printX();

静态成员也可以使用相同的public、protected和private可见性修饰符。

class MyClass {
  private static x = 0;
}
console.log(MyClass.x);

静态成员也会被继承。

class Base {
  static getGreeting() {
    return "Hello world";
  }
}
class Derived extends Base {
  myGreeting = Derived.getGreeting();
}

8.3.1 特殊静态名称

一般来说，从函数原型覆盖属性是不安全的/不可能的。因为类本身就是可以用new调用的函数，所以某些静态名称不能使用。像name、length和call这样的函数属性，定义为静态成员是无效的。

class S {
  static name = "S!";
}

8.3.2 为什么没有静态类？

TypeScript（和JavaScript）没有像C#和Java那样有一个叫做静态类的结构。

这些结构体的存在，只是因为这些语言强制所有的数据和函数都在一个类里面；因为这个限制在TypeScript中不存在，所以不需要它们。一个只有一个实例的类，在JavaScript/TypeScript中通常只是表示为一个普通的对象。

例如，我们不需要TypeScript中的 “静态类 “语法，因为一个普通的对象（甚至是顶级函数）也可以完成这个工作。

// 不需要 "static" class
class MyStaticClass {
  static doSomething() {}
}

// 首选 (备选 1)
function doSomething() {}

// 首选 (备选 2)
const MyHelperObject = {
  dosomething() {},
};

8.4 类里的 static区块

静态块允许你写一串有自己作用域的语句，可以访问包含类中的私有字段。这意味着我们可以用写语句的所有能力来写初始化代码，不泄露变量，并能完全访问我们类的内部结构。

class Foo {
  static #count = 0;

  get count() {
    return Foo.#count;
  }

  static {
    try {
      const lastInstances = {
        length: 100,
      };
      Foo.#count += lastInstances.length;
    } catch {}
  }
}

8.5 泛型类

类，和接口一样，可以是泛型的。当一个泛型类用new实例化时，其类型参数的推断方式与函数调用的方式相同。

class Box<Type> {
  contents: Type;
  constructor(value: Type) {
    this.contents = value;
  }
}

// const b: Box<string>
const b = new Box("hello!");

类可以像接口一样使用通用约束和默认值。

• 静态成员中的类型参数

这段代码是不合法的，可能并不明显，为什么呢？

class Box<Type> {
  // 静态成员不能引用类的类型参数。
  static defaultValue: Type;
}

// Box<string>.defaultValue = 'hello'
// console.log(Box<number>.defaultValue)

请记住，类型总是被完全擦除的! 在运行时，只有一个Box.defaultValue属性。这意味着设置Box.defaultValue（如果有可能的话）也会改变Box.defaultValue，这可不是什么好事。一个泛型类的静态成员永远不能引用该类的类型参数。

8.6 类运行时中的this

重要的是要记住，TypeScript并没有改变JavaScript的运行时行为，而JavaScript的运行时行为偶尔很奇特。

比如，JavaScript对这一点的处理确实是不寻常的：

class MyClass {
  name = "MyClass";
  getName() {
    return this.name;
  }
}
const c = new MyClass();
const obj = {
  name: "obj",
  getName: c.getName,
};

// 输出 "obj", 而不是 "MyClass"
console.log(obj.getName());

长话短说，默认情况下，函数内this的值取决于函数的调用方式。在这个例子中，因为函数是通过obj引用调用的，所以它的this值是obj而不是类实例。

这很少是你希望发生的事情! TypeScript提供了一些方法来减轻或防止这种错误。

1、箭头函数

如果你有一个经常会被调用的函数，失去了它的 this 上下文，那么使用一个箭头函数而不是方法定义是有意义的。

class MyClass {
  name = "MyClass";
  getName = () => {
    return this.name;
  };
}
const c = new MyClass();
const g = c.getName;
// 输出 "MyClass"
console.log(g());

这有一些权衡：

• this 值保证在运行时是正确的，即使是没有经过TypeScript检查的代码也是如此。

• 这将使用更多的内存，因为每个类实例将有它自己的副本，每个函数都是这样定义的。

• 你不能在派生类中使用super.getName，因为在原型链中没有入口可以获取基类方法。

2、this 参数

在方法或函数定义中，一个名为this的初始参数在TypeScript中具有特殊的意义。这些参数在编译过程中会被删除。

// 带有 "this" 参数的 TypeScript 输入
function fn(this: SomeType, x: number) {
  /* ... */
}

// 编译后的JavaScript结果
function fn(x) {
  /* ... */
}

TypeScript检查调用带有this参数的函数，是否在正确的上下文中进行。我们可以不使用箭头函数，而是在方法定义中添加一个this参数，以静态地确保方法被正确调用。

class MyClass {
  name = "MyClass";
  getName(this: MyClass) {
    return this.name;
  }
}
const c = new MyClass();
// 正确
c.getName();

// 错误
const g = c.getName;
console.log(g());

这种方法做出了与箭头函数方法相反的取舍：

• JavaScript调用者仍然可能在不知不觉中错误地使用类方法
• 每个类定义只有一个函数被分配，而不是每个类实例一个函数
• 基类方法定义仍然可以通过 super调用。

8.7 this类型

在类中，一个叫做 this的特殊类型动态地指向当前类的类型。让我们来看看这有什么用：

class Box {
  contents: string = "";
  // (method) Box.set(value: string): this
  set(value: string) {
    this.contents = value;
    return this;
  }
}

在这里，TypeScript推断出 set的返回类型是this，而不是Box。现在让我们做一个Box的子类：

class ClearableBox extends Box {
  clear() {
    this.contents = "";
  }
}
const a = new ClearableBox();

// const b: ClearableBox
const b = a.set("hello");
console.log(b);

你也可以在参数类型注释中使用 this：

class Box {
  content: string = "";
  sameAs(other: this) {
    return other.content === this.content;
  }
}
const box = new Box();
console.log(box.sameAs(box));

这与其他写法不同：Box，如果你有一个派生类，它的 sameAs 方法现在只接受该同一派生类的其他实例。

class Box {
  content: string = "";
  sameAs(other: this) {
    return other.content === this.content;
  }
}

class DerivedBox extends Box {
  otherContent: string = "?";
}

const base = new Box();
const derived = new DerivedBox();
derived.sameAs(base);

8.8 基于类型守卫的this

你可以在类和接口的方法的返回位置使用 this is Type 。当与类型缩小混合时（例如if语句），目标对象的类型将被缩小到指定的Type。

class FileSystemObject {
  isFile(): this is FileRep {
    return this instanceof FileRep;
  }
  isDirectory(): this is Directory {
    return this instanceof Directory;
  }
  isNetworked(): this is Networked & this {
    return this.networked;
  }
  constructor(
    public path: string,
    private networked: boolean,
  ) {}
}
class FileRep extends FileSystemObject {
  constructor(
    path: string,
    public content: string,
  ) {
    super(path, false);
  }
}
class Directory extends FileSystemObject {
  children: FileSystemObject[];
}
interface Networked {
  host: string;
}
const fso: FileSystemObject = new FileRep("foo/bar.txt", "foo");
if (fso.isFile()) {
  // const fso: FileRep
  fso.content;
} else if (fso.isDirectory()) {
  // const fso: Directory
  fso.children;
} else if (fso.isNetworked()) {
  // const fso: Networked & FileSystemObject
  fso.host;
}

基于 this 的类型保护的一个常见用例，是允许对一个特定字段进行懒惰验证。例如，这种情况下，当 hasValue被验证为真时，就会从框内持有的值中删除一个未定义值。

class Box<T> {
  value?: T;

  hasValue(): this is { value: T } {
    return this.value !== undefined;
  }
}
const box = new Box();
box.value = "Gameboy";

// (property) Box<unknown>.value?: unknownbox.value;
if (box.hasValue()) {
  // (property) value: unknown
  box.value;
}

8.9 参数属性

TypeScript提供了特殊的语法，可以将构造函数参数变成具有相同名称和值的类属性。这些被称为参数属性，通过在构造函数参数前加上可见性修饰符 public、private、protected或readonly中的一个来创建。由此产生的字段会得到这些修饰符。

class Params {
  constructor(
    public readonly x: number,
    protected y: number,
    private z: number,
  ) {
    // No body necessary
  }
}

const a = new Params(1, 2, 3);

// (property) Params.x: number
console.log(a.x);
console.log(a.z);

8.10 类表达式

类表达式与类声明非常相似。唯一真正的区别是，类表达式不需要一个名字，尽管我们可以通过它们最终绑定的任何标识符来引用它们。

const someClass = class<Type> {
  content: Type;
  constructor(value: Type) {
    this.content = value;
  }
};

// const m: someClass<string>
const m = new someClass("Hello, world");

8.11 抽象类和成员

TypeScript中的类、方法和字段可以是抽象的。

一个抽象的方法或抽象的字段是一个没有提供实现的方法或字段。这些成员必须存在于一个抽象类中，不能直接实例化。

抽象类的作用是作为子类的基类，实现所有的抽象成员。当一个类没有任何抽象成员时，我们就说它是具体的。

让我们看一个例子：

abstract class Base {
  abstract getName(): string;
  printName() {
    console.log("Hello, " + this.getName());
  }
}
const b = new Base();

我们不能用 new来实例化Base，因为它是抽象的。相反，我们需要创建一个派生类并实现抽象成员。

class Derived extends Base {
  getName() {
    return "world";
  }
}
const d = new Derived();
d.printName();

• 抽象构造签名

有时你想接受一些类的构造函数，产生一个从某些抽象类派生出来的类的实例。

例如，你可能想写这样的代码：

function greet(ctor: typeof Base) {
  const instance = new ctor();
  instance.printName();
}

TypeScript正确地告诉你，你正试图实例化一个抽象类。毕竟，鉴于greet的定义，写这段代码是完全合法的，它最终会构造一个抽象类。

// 槽糕
greet(Base);

相反，你想写一个函数，接受具有结构化签名的东西：

function greet(ctor: new () => Base) {
  const instance = new ctor();
  instance.printName();
}
greet(Derived);
greet(Base);

现在TypeScript正确地告诉你哪些类的构造函数可以被调用：Derived可以，因为它是具体的，但Base不能。

8.12 类之间的关系

在大多数情况下，TypeScript中的类在结构上与其他类型相同，是可以比较的。

例如，这两个类可以互相替代使用，因为它们是相同的：

class Point1 {
  x = 0;
  y = 0;
}
class Point2 {
  x = 0;
  y = 0;
}

// 正确
const p: Point1 = new Point2();

同样地，即使没有明确的继承，类之间的子类型关系也是存在的：

class Person {
  name: string;
  age: number;
}
class Employee {
  name: string;
  age: number;
  salary: number;
}

// 正确
const p: Person = new Employee();

这听起来很简单，但有几种情况似乎比其他情况更奇怪。

空的类没有成员。在一个结构化类型系统中，一个没有成员的类型通常是其他任何东西的超类型。所以如果你写了一个空类（不要！），任何东西都可以用来代替它。

class Empty {}

function fn(x: Empty) {
  // 不能用'x'做任何事
}

// 以下调用均可
!fn(window);
fn({});
fn(fn);

特别声明: 本文转自 古艺散人老师 ，如有需要可前往原文预览查看。