Suggest an edit

Improve this article

Refine the answer for “Can you overload a constructor?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## 1. The general idea of constructor overloading

In TypeScript you can declare **several constructor signatures**,
but implement **only one** (real) constructor with checks inside it:

```javascript
class User {
  name: string;
  age?: number;

// Overloads (type-level only)
  constructor(name: string);
  constructor(name: string, age: number);

// A single implementation
  constructor(name: string, age?: number) {
    this.name = name;
    this.age = age;
  }
}

const u1 = new User("Tim");       // works
const u2 = new User("Alex", 25);  // works
const u3 = new User();            // Error: no matching overload
```

> The `constructor(...)` overloads above are **only type signatures**.
> The last `constructor(...)` with a body is the **real implementation**.

---

## 2. How this works under the hood

TypeScript compiles everything into a single JavaScript constructor,
and the overloads are needed **only for type checking** at compile time.

```javascript
// TS
class User {
  constructor(name: string);
  constructor(name: string, age: number);
  constructor(name: string, age?: number) {
    console.log(name, age);
  }
}
```

Compiles to JS as:

```javascript
class User {
  constructor(name, age) {
    console.log(name, age);
  }
}
```

The type checks are removed, and a single constructor remains.

---

## 3. Checking arguments inside the constructor

Since JS does not support "real" overloading,
manual **checks** are usually done inside the constructor:

```javascript
class Point {
  x: number;
  y: number;

constructor(x: number);
  constructor(x: number, y: number);
  constructor(x: number, y?: number) {
    if (y === undefined) {
      this.x = this.y = x; // if one argument was passed
    } else {
      this.x = x;
      this.y = y;
    }
  }
}

new Point(5);     // (5, 5)
new Point(5, 10); // (5, 10)
```

---

## 4. Overloading with different parameter types

You can overload a constructor **by type**, not only by the number of arguments:

```javascript
class FileData {
  path: string;
  buffer?: Uint8Array;

constructor(path: string);
  constructor(buffer: Uint8Array);
  constructor(value: string | Uint8Array) {
    if (typeof value === "string") {
      this.path = value;
    } else {
      this.buffer = value;
      this.path = "memory.bin";
    }
  }
}

new FileData("file.txt");             // string
new FileData(new Uint8Array([1, 2])); // Uint8Array
new FileData(123);                    // A type error
```

---

## 5. Overloading via union types (an alternative)

Sometimes overloads can simply be replaced with a union of types (`|`):

```javascript
class User {
  constructor(public name: string | number) {}
}

new User("Tim");
new User(123);
```

But then TS does not distinguish the signatures,
and the types must be resolved manually inside the constructor.

---

## 6. Constructor overloading in a base and a derived class

You can overload a constructor in a parent class and call the right one via `super()`:

```javascript
class Shape {
  color: string;
  constructor();
  constructor(color: string);
  constructor(color = "black") {
    this.color = color;
  }
}

class Circle extends Shape {
  radius: number;
  constructor(radius: number);
  constructor(radius: number, color: string);
  constructor(radius: number, color?: string) {
    super(color);
    this.radius = radius;
  }
}

const c1 = new Circle(10);
const c2 = new Circle(10, "red");
```

---

## 7. An important nuance: overloads are not runtime overloading

All the signatures are checked **only by the compiler**
and do not exist in the compiled code:

- TypeScript checks the correct number and types of arguments.
- JavaScript executes a single constructor with checks inside it.
- You cannot have two implementations of a constructor.

---

## Summary

| Capability | Supported | Comment |
|---|---|---|
| Several constructor signatures | Yes | Checked by the compiler |
| Several constructor implementations | No | Only one, with a body |
| Overloading by number of arguments | Yes | Via `?` or checks |
| Overloading by type | Yes | Via unions or signatures |
| Real runtime overloading (as in C#/Java) | No | Not possible |
| Type checking at `new` | Yes | Works thanks to the signatures |

---

**In short:**

> In TypeScript you can overload constructors,
> but only **at the type level**.
> The implementation is always **a single one**, and you check the arguments yourself inside it.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts659 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.