New

The new operator allocates memory and initializes a new instance of a class or constructor function. In TypeScript, it acts as a compile-time boundary that enforces strict type-checking against a target’s construct signature, validating both the provided arguments and the resulting instance type.

Syntax

new Constructor[<TypeParameters>](...arguments)

Construct Signatures

TypeScript represents the type of a function that can be invoked with new using a construct signature. This is defined using the new keyword preceding a function signature.

// Type alias with a construct signature
type Constructor<T> = new (...args: any[]) => T;

// Interface with a construct signature
interface StringConstructable {
    new (value: string): String;
}

When the TypeScript compiler encounters the new operator, it looks up the construct signature of the operand. If the operand lacks a construct signature, the compiler throws a TS2351 error (“This expression is not constructable”).

Type Space vs. Value Space

A critical mechanic of the new operator in TypeScript is how it interacts with class declarations. A class declaration creates exactly one type in the type space (representing the shape of the instantiated object) and one value in the value space (the constructor function itself, which contains the construct signature and static members).

To type a variable that holds the constructor itself (the target of the new operator), you must use the typeof operator on the class value to extract its type, or define a construct signature. The constructor’s type is not created as a distinct named type in the scope.

class Widget {
    constructor(public id: number) {}
}

// 'Widget' is the instance type.
const instance: Widget = new Widget(1);

// 'typeof Widget' extracts the constructor type from the value space.
// It matches the signature: new (id: number) => Widget
const WidgetConstructor: typeof Widget = Widget;

// The new operator applied to the constructor reference
const anotherInstance: Widget = new WidgetConstructor(2);

Generic Instantiation

When the new operator is applied to a generic class or constructor, TypeScript performs type inference on the constructor arguments to determine the type parameters. Alternatively, type parameters can be explicitly provided via angle brackets < > immediately following the constructor name.

class Container<T, U> {
    constructor(public primary: T, public secondary: U) {}
}

// Implicit type inference: T is inferred as string, U as number
const inferred = new Container("data", 42); 

// Explicit type instantiation: T and U are strictly bound
const explicit = new Container<string, number>("data", 42);

// Compiler error: Argument of type 'boolean' is not assignable to parameter of type 'number'.
const errorInstance = new Container<string, number>("data", true); 

Abstract Classes

TypeScript prohibits the new operator from directly instantiating abstract classes. Abstract classes possess an abstract new construct signature in their type representation. The compiler prevents instantiation by explicitly checking for the abstract modifier on the constructor type. When the new operator is applied to an abstract constructor, the compiler throws a TS2511 error (“Cannot create an instance of an abstract class”), ensuring the class can only be instantiated via a derived concrete class.

abstract class Base {
    constructor(public name: string) {}
}

class Derived extends Base {}

// TS2511: Cannot create an instance of an abstract class.
const base = new Base("test"); 

// Valid instantiation of the concrete subclass
const derived = new Derived("test"); 

Master TypeScript with Deep Grasping Methodology!

Learn More