当前位置：首页 > news >正文

ts中构造器

news 来源：原创 2025/5/25 22:48:40

在 TypeScript（TS）中，构造器（constructor） 是用于创建和初始化类实例的特殊方法。它在类实例化时自动调用。

1. 基本语法

class Person {
  name: string;

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

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

const p = new Person("Alice");
p.greet(); // 输出: Hello, my name is Alice

constructor 方法 在 new Person("Alice") 时被调用。
this.name = name 赋值，将参数存入实例属性。

2. 构造器参数的访问修饰符

TypeScript 允许直接在构造器参数前加 public、private 或 protected，这样可以省略手动赋值。

class Person {
  constructor(public name: string) {} // 自动创建并赋值 name 属性

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

const p = new Person("Bob");
console.log(p.name); // Bob

修饰符说明：

public（默认）→ 外部可访问。
private → 仅类内部可访问。
protected → 仅类及其子类可访问。

示例：

class Example {
  constructor(private secret: string) {}

  showSecret() {
    console.log(this.secret); // ✅ 内部可访问
  }
}

const e = new Example("hidden");
// console.log(e.secret); ❌ 报错：属性“secret”为私有属性

3. 构造函数重载（伪重载）

TypeScript 不支持真正的构造函数重载，但可以通过 可选参数 和 联合类型 模拟：

class User {
  name: string;
  age?: number;

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

const u1 = new User("Tom");        // 只传 name
const u2 = new User("Jerry", 25);  // 传 name 和 age

4. 构造器中的 `readonly` 属性

如果某个属性只在构造器中赋值，之后不可修改，可以用 readonly：

class Car {
  constructor(public readonly brand: string) {}

  changeBrand(newBrand: string) {
    // this.brand = newBrand; ❌ 报错，brand 是 readonly
  }
}

const car = new Car("Tesla");
console.log(car.brand); // Tesla
// car.brand = "BMW"; ❌ 报错

5. 继承中的构造器

在子类中，构造器需要调用 super() 以执行父类的构造函数：

class Animal {
  constructor(public species: string) {}
}

class Dog extends Animal {
  constructor(species: string, public breed: string) {
    super(species); // 调用父类构造函数
  }
}

const d = new Dog("Canine", "Labrador");
console.log(d.species, d.breed); // Canine Labrador

6. 抽象类的构造器

抽象类不能被直接实例化，但可以在子类中使用 super() 继承其构造逻辑：

abstract class Shape {
  constructor(public color: string) {}
}

class Circle extends Shape {
  constructor(color: string, public radius: number) {
    super(color);
  }
}

const c = new Circle("red", 10);
console.log(c.color, c.radius); // red 10