TypeScript 中的修饰符指南：深入了解类的成员限定符

前端

2023-11-15 03:28:33

TypeScript 修饰符简介

TypeScript 中的修饰符是一种特殊的，用于限定类成员的访问权限、类型和行为。通过使用修饰符，可以控制类成员在不同情况下的可见性和行为。

常见的 TypeScript 修饰符

TypeScript 中最常用的修饰符包括：

public ：表示该成员可以在任何地方被访问。
private ：表示该成员只能在定义它的类中被访问。
protected ：表示该成员只能在定义它的类及其子类中被访问。
readonly ：表示该成员只能被读取，不能被修改。
static ：表示该成员属于类本身，而不是类的实例。
abstract ：表示该成员是一个抽象方法，必须在子类中实现。
override ：表示该成员覆盖了父类中的同名方法。

public 修饰符

public 修饰符表示该成员可以在任何地方被访问。它是最常用的修饰符，也是默认的修饰符。例如：

class Person {
  public name: string;

  constructor(name: string) {
    this.name = name;
  }

  public greet() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}

在这个例子中，name 属性和 greet 方法都是 public 的，因此它们可以在任何地方被访问。

private 修饰符

private 修饰符表示该成员只能在定义它的类中被访问。例如：

class Person {
  private age: number;

  constructor(age: number) {
    this.age = age;
  }

  public getAge() {
    return this.age;
  }
}

在这个例子中，age 属性是 private 的，因此它只能在 Person 类中被访问。getAge 方法是 public 的，因此它可以在任何地方被调用，但是它只能访问 age 属性。

protected 修饰符

protected 修饰符表示该成员只能在定义它的类及其子类中被访问。例如：

class Person {
  protected name: string;

  constructor(name: string) {
    this.name = name;
  }

  protected greet() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}

class Employee extends Person {
  public jobTitle: string;

  constructor(name: string, jobTitle: string) {
    super(name);
    this.jobTitle = jobTitle;
  }

  public getGreeting() {
    return `Hello, my name is ${this.name} and I am a ${this.jobTitle}.`;
  }
}

在这个例子中，name 属性和 greet 方法都是 protected 的，因此它们只能在 Person 类及其子类中被访问。Employee 类继承了 Person 类，因此它可以访问 name 属性和 greet 方法。

readonly 修饰符

readonly 修饰符表示该成员只能被读取，不能被修改。例如：

class Person {
  public readonly name: string;

  constructor(name: string) {
    this.name = name;
  }
}

const person = new Person('John Doe');

person.name = 'Jane Doe'; // Error: Cannot assign to 'name' because it is a read-only property.

在这个例子中，name 属性是 readonly 的，因此它只能被读取，不能被修改。

static 修饰符

static 修饰符表示该成员属于类本身，而不是类的实例。例如：

class Person {
  public static species: string = 'Homo sapiens';

  public static greet() {
    console.log(`Hello, we are ${Person.species}.`);
  }
}

Person.greet(); // Output: Hello, we are Homo sapiens.

在这个例子中，species 属性和 greet 方法都是 static 的，因此它们属于 Person 类本身，而不是类的实例。

abstract 修饰符

abstract 修饰符表示该成员是一个抽象方法，必须在子类中实现。例如：

abstract class Animal {
  public abstract makeSound(): void;
}

class Dog extends Animal {
  public makeSound(): void {
    console.log('Woof!');
  }
}

class Cat extends Animal {
  public makeSound(): void {
    console.log('Meow!');
  }
}

const dog = new Dog();
dog.makeSound(); // Output: Woof!

const cat = new Cat();
cat.makeSound(); // Output: Meow!

在这个例子中，makeSound 方法是 abstract 的，因此它必须在 Dog 和 Cat 类中实现。

override 修饰符

override 修饰符表示该成员覆盖了父类中的同名方法。例如：

class Person {
  public greet() {
    console.log('Hello, I am a person.');
  }
}

class Employee extends Person {
  public override greet() {
    super.greet();
    console.log('I am also an employee.');
  }
}

const person = new Person();
person.greet(); // Output: Hello, I am a person.

const employee = new Employee();
employee.greet(); // Output: Hello, I am a person.
I am also an employee.