In TypeScript, what does marking a class constructor `private` do, and how does a `protected constructor` differ?

## What the modifier does A constructor is a class member, so it takes the same visibility modifiers as any other member. Marking it `private` restricts *calls* to the body of the declaring class: ```ts class Config { private constructor(private readonly n: number) {} } ``` (That parameter shorthand aside, the point is the modifier.) From outside, `new Config(1)` is a compile error. From inside — including from a `static` method, which is inside the class body — it is perfectly legal. ## Why it also blocks `extends` This is the part candidates miss. A derived class constructor must call `super()`, and `super()` is a call to the base constructor. If that constructor is private, the subclass cannot make the call, so TypeScript rejects the inheritance outright rather than waiting for the `super()` line: it reports that the class cannot be extended because its constructor is marked private. `protected` is the modifier that keeps `new` closed to outsiders while leaving `super()` open to subclasses. | Modifier | `new C()` outside | `class D extends C` | | --- | --- | --- | | (public, default) | allowed | allowed | | `protected` | error | allowed | | `private` | error | error | ## What the pattern buys you Closing the constructor moves construction behind a named, static entry point you control. That enables: - **Singletons / caches.** A `static getInstance()` returns a stored instance instead of a fresh one. - **Validating factories.** A `static parse(raw: string): Result | null` can fail without throwing, which a constructor cannot do — a constructor must either return an instance or throw. - **Named constructors.** `Duration.fromSeconds` and `Duration.fromMinutes` read better than one overloaded constructor with a mode flag. - **Async construction.** A `static async connect()` can await work before handing back a fully initialised object; constructors cannot be async. ```ts class Duration { private ms: number; private constructor(ms: number) { this.ms = ms; } static fromSeconds(s: number) { return new Duration(s * 1000); } static fromMinutes(m: number) { return new Duration(m * 60_000); } } ``` ## The `protected constructor` shape Use `protected` when the class is a base that should never be constructed on its own but must be subclassed: ```ts class Handler { protected constructor(readonly name: string) {} } class JsonHandler extends Handler { constructor() { super("json"); } // ok } // new Handler("x"); // error ``` This is close to what an abstract class gives you, and the choice between the two is a real design question: a protected constructor still allows a fully concrete class with no members left unimplemented, whereas abstractness is about members the subclass must supply. ## The erasure caveat As with every visibility modifier, this is checked and then erased. The emitted JavaScript has a plain constructor; `new (Config as any)(1)` runs happily, and a JavaScript consumer of your compiled package can call it directly. So a private constructor is a design constraint expressed to TypeScript callers, not an invariant the runtime protects. If instances must be impossible to forge, the enforcement has to live in the constructor body or in a brand the factory alone can produce. ## Interaction with type positions One more consequence worth knowing: a class whose constructor is not public does not satisfy a construct signature such as `new () => T`, so it cannot be passed where a constructable value is expected — a generic factory helper that takes `ctor: new () => T` will reject it. That is usually a feature rather than a problem: you closed construction on purpose, so the class should not slip through a generic that reopens it.