在Typescript中扩展生成器

Question

是否有可能在这个答案中提供等效的内容，但在TypeScript中？

对 Java 生成器类进行子类化

这是迄今为止我对基类的了解：

export class ProfileBuilder {
    name: string;

    withName(value: string): ProfileBuilder {
        this.name= value;
        return this;
    }

    build(): Profile{
        return new Profile(this);
    }
}

export class Profile {
    private name: string;

    constructor(builder: ProfileBuilder) {
        this.name = builder.Name;
    }
}

和扩展类：

export class CustomerBuilder extends ProfileBuilder  {
    email: string;

    withEmail(value: string): ProfileBuilder {
        this.email = value;
        return this;
    }

    build(): Customer {
        return new Customer(this);
    }
}

export class Customer extends Profile {
    private email: string;

    constructor(builder: CustomerBuilder) {
        super(builder);
        this.email= builder.email;
    }
}

正如另一个线程提到的，由于上下文的变化，我将无法按此顺序构建客户：

let customer: Customer = new CustomerBuilder().withName('John')
                                              .withEmail('[e-mail]')
                                              .build();

我目前正在尝试使用泛型来解决此问题，但是在为我的 setter 方法返回 this 指针时遇到问题（类型 this 不能分配给类型 T）。有什么想法吗？

Answer 1

在类中，一种称为this的特殊类型动态引用当前类的类型。

--打字稿文档

因此，链式方法的返回类型将始终与您实例化的构建器类型匹配，从而允许完全访问该构建器上可用的所有方法，无论它们是继承的、覆盖的还是在子类中添加的。

js prettyprint-override">// -----------
// Parent Class

class ProfileBuilder {
  name?: string;
  
  // The `this` return type will dynamically match the instance type
  withName(value: string): this {
    this.name = value;
    return this;
  }

  build(): Profile {
    return new Profile(this);
  }
}

class Profile {
  private name: string;

  constructor(builder: ProfileBuilder) {
    this.name = builder.name ?? 'default name';
  }
}


// -----------
// Child class

class CustomerBuilder extends ProfileBuilder {
  email?: string;

  // Return `this` here too to allow further subclassing.
  withEmail(value: string): this {
    this.email = value;
    return this;
  }

  build(): Customer {
    return new Customer(this);
  }
}

class Customer extends Profile {
  private email: string;

  constructor(builder: CustomerBuilder) {
    super(builder);
    this.email = builder.email ?? '[e-mail]';
  }
}



// -----------
// Example Usage

// Notice that the order of the `with` methods no longer matters.

let customer: Customer = new CustomerBuilder()
  .withName('John')
  .withEmail('[e-mail]')
  .build();

let customer2: Customer = new CustomerBuilder()
  .withEmail('[e-mail]')
  .withName('Jane')
  .build();

export {};

Answer 2

我最近遇到了同样的需求，这是我的解决方案，如果我们创建一个配置文件生成器类，我们可以从我们的客户生成器扩展它，并使用super调用基本生成器。

class ProfileBuilder {
    private name: string;

    constructor() {
        this.name = undefined;
    }

    public withName(name: string) {
        this.name = name;
        return this;
    }

    public build() {
        return {
            name: this.name
        }
    }
}

class CustomerBuilder extends ProfileBuilder {
    private email: string;

    constructor() {
        super();

        this.email = undefined;
    }

    public withEmail(email: string) {
        this.email = email;
        return this;
    }

    public build() {
        const base = super.build();
        return {
            ...base,
            email: this.email
        }
    }
}

现在，您可以根据自己的要求创建一个客户:

const customer = new CustomerBuilder()
    .withName("John")
    .withEmail("[e-mail]") 
    .build();

Answer 3

找到了解决方案！在查看了我提到的另一个线程上的不同答案后，我最终创建了一个基本抽象类和构建器，然后为我的每个类/构建器对扩展：

abstract class BaseProfileBuilder<T extends BaseProfile, B extends BaseProfileBuilder<T, B>> {
    protected object: T;
    protected thisPointer: B;

    protected abstract createObject(): T;

    protected abstract getThisPointer(): B;

    constructor() {
        this.object = this.createObject();
        this.thisPointer = this.getThisPointer();
    }

    withName(value: string): B {
        this.object.name = value;
        return this.thisPointer;
    }

    build(): T {
        return this.object;
    }
}

abstract class BaseProfile {
    name: string;
}

class ProfileBuilder extends BaseProfileBuilder<Profile, ProfileBuilder> {
    createObject(): Profile {
        return new Profile();
    }

    getThisPointer(): ProfileBuilder {
        return this;
    }
}

class Profile extends BaseProfile {
}

class CustomerBuilder extends BaseProfileBuilder<Customer, CustomerBuilder>  {
    createObject(): Customer {
        return new Customer();
    }

    getThisPointer(): CustomerBuilder {
        return this;
    }

    withEmail(value: string): CustomerBuilder {
        this.object.email = value;
        return this;
    }
}

class Customer extends BaseProfile {
    email: string;
}


let customer: Customer = new CustomerBuilder().withName('John')
                                              .withEmail('[e-mail]')
                                              .build();

console.log(customer);