ConstructorParameters type in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code using ConstructorParameters?

Consider this TypeScript code using ConstructorParameters. What will be logged?

Typescript

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

type Params = ConstructorParameters<typeof Person>;

const args: Params = ['Alice', 30];
const p = new Person(...args);
console.log(p.name, p.age);

A "Person { name: 'Alice', age: 30 }"

B "Alice 30"

C "['Alice', 30]"

D "undefined undefined"

💡 Hint

ConstructorParameters extracts the types of the constructor arguments as a tuple.

The ConstructorParameters type extracts the parameter types of the constructor as a tuple. Here, Params is [string, number]. Passing args to the constructor creates a Person with name = 'Alice' and age = 30. So, logging p.name and p.age prints "Alice 30".

❓ Predict Output

intermediate

What is the type of Params in this example?

Given this class, what is the type of Params?

Typescript

class Car {
  constructor(make: string, model: string, year: number) {}
}

type Params = ConstructorParameters<typeof Car>;

A [string, string, number]

B string[]

C [string, string]

D [string, number, string]

💡 Hint

Look at the constructor parameters order and types.

The ConstructorParameters type extracts the constructor's parameter types as a tuple in the exact order. The constructor has parameters make: string, model: string, and year: number, so Params is [string, string, number].

🔧 Debug

advanced

Why does this code cause a TypeScript error?

Look at this code snippet. Why does it cause a TypeScript error?

Typescript

class Book {
  constructor(title: string, pages: number) {}
}

type Params = ConstructorParameters<typeof Book>;

const args: Params = ['My Book']; // Missing second argument
const b = new Book(...args);

A No error, code runs fine

B Error because ConstructorParameters cannot infer types from classes

C Error because spread operator cannot be used with tuples

D Error because args is missing the second parameter 'pages' required by the constructor

💡 Hint

Check if the tuple matches the constructor parameters exactly.

The ConstructorParameters type expects a tuple with exactly two elements: string and number. The args array only has one element, so TypeScript raises an error because the second parameter is missing.

🧠 Conceptual

advanced

What does ConstructorParameters return?

Choose the best description of what ConstructorParameters returns in TypeScript.

A The return type of the constructor function of <code>SomeClass</code>

B A union type of all parameter types of the constructor of <code>SomeClass</code>

C A tuple type representing the parameter types of the constructor of <code>SomeClass</code> in order

D An object type with keys as parameter names and values as their types

💡 Hint

Think about what a tuple is and how constructor parameters are represented.

ConstructorParameters returns a tuple type representing the types of the constructor parameters in the exact order they appear. It does not return an object or union type, nor the return type of the constructor.

❓ Predict Output

expert

What is the output of this complex ConstructorParameters usage?

Analyze this TypeScript code and select the correct output.

Typescript

class Gadget {
  constructor(public id: number, public name: string, public active = true) {}
}

type Params = ConstructorParameters<typeof Gadget>;

function createGadget(...args: Params) {
  return new Gadget(...args);
}

const g1 = createGadget(101, 'Phone');
const g2 = createGadget(102, 'Tablet', false);

console.log(g1.active, g2.active);

A true false

B undefined undefined

C true true

D false true

💡 Hint

Remember how default parameters work with tuples and spread arguments.

The constructor has a default value for active as true. When calling createGadget(101, 'Phone'), the third parameter is omitted, so active defaults to true. For createGadget(102, 'Tablet', false), active is explicitly false. So the output is true false.