构造器函数类型

构造器函数类型的基本概念

TypeScript中的构造器函数类型用于描述类的构造函数。它定义了创建类实例时所需的参数类型和返回类型。构造器函数类型通常与new关键字一起使用，表示这是一个构造函数而非普通函数。

interface ClockConstructor {
  new (hour: number, minute: number): ClockInterface;
}

interface ClockInterface {
  tick(): void;
}

function createClock(
  ctor: ClockConstructor,
  hour: number,
  minute: number
): ClockInterface {
  return new ctor(hour, minute);
}

构造器函数类型的语法

构造器函数类型的语法与普通函数类型类似，但在参数列表前需要添加new关键字。基本形式如下：

type Constructor = new (...args: any[]) => any;

更具体的构造器类型可以这样定义：

type PointConstructor = new (x: number, y: number) => Point;

构造器函数类型的应用场景

工厂函数

构造器函数类型常用于创建工厂函数，这些函数接收构造函数作为参数并返回新实例：

class Car {
  constructor(public model: string) {}
}

type CarConstructor = new (model: string) => Car;

function createCar(ctor: CarConstructor, model: string): Car {
  return new ctor(model);
}

const myCar = createCar(Car, "Tesla");

类装饰器

在实现类装饰器时，构造器函数类型是必不可少的：

function logged<T extends new (...args: any[]) => any>(ctor: T) {
  return class extends ctor {
    constructor(...args: any[]) {
      console.log(`Creating instance with args: ${args}`);
      super(...args);
    }
  };
}

@logged
class Person {
  constructor(public name: string) {}
}

构造签名与实例类型

构造器函数类型可以分解为构造签名和实例类型两部分：

interface AnimalConstructor {
  // 构造签名
  new (name: string): Animal;
  
  // 静态方法
  createDefault(): Animal;
}

interface Animal {
  name: string;
  makeSound(): void;
}

class Dog implements Animal {
  constructor(public name: string) {}
  
  makeSound() {
    console.log("Woof!");
  }
  
  static createDefault() {
    return new Dog("Default");
  }
}

泛型构造器函数类型

构造器函数类型也可以使用泛型，增加灵活性：

type GenericConstructor<T> = new (...args: any[]) => T;

function createInstance<T>(ctor: GenericConstructor<T>, ...args: any[]): T {
  return new ctor(...args);
}

class Book {
  constructor(public title: string) {}
}

const myBook = createInstance(Book, "TypeScript Deep Dive");

构造器函数类型与继承

当处理类继承时，构造器函数类型可以确保子类满足特定的构造要求：

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

type AnimalConstructor = new (name: string) => Animal;

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    super(name);
  }
}

function createAnimal(ctor: AnimalConstructor, name: string): Animal {
  return new ctor(name);
}

// 可以传入Dog，因为它满足AnimalConstructor类型
const myDog = createAnimal(Dog, "Buddy");

构造器函数类型与混合模式

在实现混合模式时，构造器函数类型特别有用：

type Constructor<T = {}> = new (...args: any[]) => T;

function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    timestamp = Date.now();
  };
}

class User {
  constructor(public name: string) {}
}

const TimestampedUser = Timestamped(User);
const user = new TimestampedUser("Alice");
console.log(user.timestamp);

构造器函数类型的高级模式

参数解构

构造器函数类型可以结合参数解构使用：

type Point3DConstructor = new (options: { x: number; y: number; z: number }) => Point3D;

class Point3D {
  constructor(public x: number, public y: number, public z: number) {}
}

function createPoint3D(ctor: Point3DConstructor, options: { x: number; y: number; z: number }) {
  return new ctor(options);
}

可选参数

构造器函数类型也可以包含可选参数：

type PersonConstructor = new (name: string, age?: number) => Person;

class Person {
  constructor(public name: string, public age?: number) {}
}

构造器函数类型与接口合并

接口可以包含构造签名，这使得它们可以描述构造函数：

interface StringArray {
  [index: number]: string;
}

interface StringArrayConstructor {
  new (size: number): StringArray;
  from(array: any[]): StringArray;
}

declare const StringArray: StringArrayConstructor;

const myArray = new StringArray(10);
const otherArray = StringArray.from([1, 2, 3]);

构造器函数类型与类型推断

TypeScript能够从构造器函数类型中推断出实例类型：

function getInstance<T>(ctor: new () => T): T {
  return new ctor();
}

class Widget {
  id = Math.random();
}

const widget = getInstance(Widget);  // widget类型被推断为Widget

构造器函数类型与抽象类

抽象类的构造器函数类型需要特殊处理：

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

type AnimalConstructor = new () => Animal;

// 错误：不能直接实例化抽象类
// const animal = new Animal();

// 但可以作为类型约束
function createAnimalSubclass(ctor: AnimalConstructor): Animal {
  class Temp extends ctor {}
  return new Temp();
}

构造器函数类型与私有构造函数

处理单例模式时，私有构造函数的类型表示：

class Singleton {
  private static instance: Singleton;
  
  private constructor() {}
  
  static getInstance(): Singleton {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton();
    }
    return Singleton.instance;
  }
}

// 构造器类型可以这样表示
type SingletonConstructor = typeof Singleton;

构造器函数类型与重载

构造器函数类型也可以表示重载的构造函数：

interface PointConstructor {
  new (x: number, y: number): Point;
  new (coord: [number, number]): Point;
}

class Point {
  constructor(...args: [number, number] | [number, number]) {
    // 实现重载逻辑
  }
}

构造器函数类型与条件类型

结合条件类型可以创建更灵活的构造器类型：

type ConstructorArg<T> = T extends new (arg: infer A) => any ? A : never;

class Foo {
  constructor(public value: string) {}
}

type FooArg = ConstructorArg<typeof Foo>;  // string

构造器函数类型与映射类型

映射类型可以用于转换构造器函数类型：

type WithName<T> = T & { name: string };

type NamedConstructor<T> = new (...args: any[]) => WithName<T>;

class Person {
  constructor(public name: string, public age: number) {}
}

type NamedPersonConstructor = NamedConstructor<Person>;