Builder
| Fluent setters | |
| Validate at build | |
| Hide the constructor | |
| When builders win |
Fluent setters
A builder gathers options through small chained setters and produces the finished object with one build call. Each setter returns this, so configuration reads as a single line from left to right.
Start with defaults inside the class, then let each setter overwrite one field. Callers only mention what differs from the defaults, which keeps call sites short.
class ServerConfig {
private host: string = "localhost";
private port: number = 8080;
setHost(host: string): this {
this.host = host;
return this;
}
setPort(port: number): this {
this.port = port;
return this;
}
build(): string {
return this.host + ":" + this.port;
}
}
const text: string = new ServerConfig().setHost("db").setPort(5432).build();
console.log(text);
Validate at build
Constructors with many parameters fail late and with unclear messages. A builder can check the full picture in build and throw one clear error before the object escapes.
Keep each setter dumb and put every cross field rule in build. Required fields, ranges, and combinations are verified in one place, so broken states never reach the rest of the program.
function makePort(port: number): number {
if (port === 0) {
throw new Error("Port must be set");
}
return port;
}
const port: number = makePort(5432);
console.log(port);
Hide the constructor
Mark the constructor private so the builder is the only way to create the object. This single entry point keeps validation impossible to skip.
Expose a static create method or a separate builder class that calls the private constructor. Users get a clear path, and the class keeps control over every instance.
class Token {
private constructor(private value: string) {}
static create(value: string): Token {
return new Token(value);
}
}
const token: Token = Token.create("abc123");
console.log(token);
When builders win
Reach for a builder when an object has many optional settings or several valid combinations. Long parameter lists and boolean flags are a strong signal that chained setters will read better.
Skip the pattern for simple values with one or two fields. A plain object literal or a short constructor call stays clearer than a builder with a single build step.
Next: Event emitters
Article author: Arthur Isaev