Suggest an edit

Improve this article

Refine the answer for “What does ConstructorParameters<T> do?”. 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)

## What `ConstructorParameters<T>` does

`ConstructorParameters<T>` is a built-in TypeScript utility type that **extracts the constructor's parameter types** from a given class or constructor.

It works just like `Parameters<T>`, but **for classes** (or constructor functions).

---

### Definition

In the TypeScript source:

```javascript
type ConstructorParameters<T extends abstract new (...args: any) => any> =
  T extends abstract new (...args: infer P) => any ? P : never;
```

Breakdown:

- `T` is the **constructor type**, that is, something like `new (...args) => Instance`.
- `infer P` extracts the constructor's argument types.
- The result is a **tuple** of the constructor's parameter types.

---

## Code examples

### 1. A regular class

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

type UserParams = ConstructorParameters<typeof User>;
// [string, number]

const args: UserParams = ["Alex", 30];
const user = new User(...args); // correct
```

---

### 2. A class without a constructor

```javascript
class Empty {}

type P = ConstructorParameters<typeof Empty>;
// []
```

---

### 3. An abstract class

```javascript
abstract class Base {
  constructor(protected id: number, public name: string) {}
}

type BaseParams = ConstructorParameters<typeof Base>;
// [number, string]
```

---

### 4. A constructor as a type

```javascript
type Ctor = new (flag: boolean, count: number) => object;

type Args = ConstructorParameters<Ctor>;
// [boolean, number]
```

---

## What happens if you pass a **non-constructor**

If you pass something that is not a constructor (for example, a regular function or a type without `new`),
TypeScript raises an error:

> Type 'T' does not satisfy the constraint 'abstract new (...args: any) => any'

Example:

```javascript
type Bad = ConstructorParameters<() => void>;
// Error: the function is not a constructor
```

---

## Practical applications

### 1. Dynamically creating instances

```javascript
function createInstance<T extends new (...args: any[]) => any>(
  ctor: T,
  ...args: ConstructorParameters<T>
): InstanceType<T> {
  return new ctor(...args);
}

class Person {
  constructor(public name: string, public age: number) {}
}

const p = createInstance(Person, "Tom", 25); // correctly typed
```

---

### 2. Using it in DI / factories

```javascript
function makeSingleton<T extends new (...args: any[]) => any>(Ctor: T) {
  let instance: InstanceType<T> | null = null;
  return (...args: ConstructorParameters<T>): InstanceType<T> => {
    if (!instance) instance = new Ctor(...args);
    return instance;
  };
}

class Config {
  constructor(public host: string, public port: number) {}
}

const getConfig = makeSingleton(Config);
const c1 = getConfig("localhost", 8080);
const c2 = getConfig("localhost", 8080); // the same instance
```

---

### 3. Used together with `InstanceType<T>`

- `ConstructorParameters<T>` gives the constructor's arguments
- `InstanceType<T>` gives the type of the created instance

```javascript
class Point {
  constructor(public x: number, public y: number) {}
}

type Args = ConstructorParameters<typeof Point>; // [number, number]
type Instance = InstanceType<typeof Point>;      // Point
```

---

## Summary

| Question | Answer |
|---|---|
| What does `ConstructorParameters<T>` do? | Extracts the parameter types of class `T`'s constructor as a tuple. |
| What can be passed? | Only constructors (classes or types of the form `new (...args) => any`). |
| What happens with a non-constructor? | A type error. |
| What does it return? | A tuple of the constructor's argument types. |

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

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.