Extending interfaces in Typescript - Time & Space Complexity

Time Complexity: Extending interfaces

O(n)

Understanding Time Complexity

When we extend interfaces in TypeScript, we combine properties from multiple interfaces into one. Understanding time complexity here means looking at how this combining process grows as we add more interfaces or properties.

We want to know: how does the work needed to merge interfaces change when interfaces get bigger or more numerous?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

interface A {
  x: number;
  y: number;
}

interface B {
  z: number;
}

interface C extends A, B {
  w: number;
}
    

This code defines interfaces A and B, then creates interface C that extends both A and B, adding one more property.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Combining properties from each extended interface into one.
• How many times: Once per property in each interface being extended.

How Execution Grows With Input

When we add more interfaces or more properties, the work to combine them grows with the total number of properties.

Input Size (total properties)	Approx. Operations
10	10
100	100
1000	1000

Pattern observation: The work grows directly with the number of properties combined.

Final Time Complexity

Time Complexity: O(n)

This means the time to combine interfaces grows linearly with the total number of properties involved.

Common Mistake

[X] Wrong: "Extending multiple interfaces happens instantly no matter how many properties they have."

[OK] Correct: Each property must be processed to combine interfaces, so more properties mean more work.

Interview Connect

Understanding how interface extension scales helps you reason about type system performance and design clean, maintainable code. This skill shows you think about how code grows, which is valuable in real projects.

Self-Check

"What if interface C extended three or more interfaces instead of two? How would the time complexity change?"

Practice

1. What does the extends keyword do when used with interfaces in TypeScript?

easy

A. It merges two unrelated interfaces without inheritance.

B. It deletes properties from an existing interface.

C. It creates a new interface that inherits properties from an existing interface.

D. It converts an interface into a class.

Solution

1. Step 1: Understand the role of extends in interfaces

   The extends keyword allows one interface to inherit properties from another, creating a new interface that includes all properties of the original.

2. Step 2: Compare options with this understanding

   Only It creates a new interface that inherits properties from an existing interface. correctly describes inheritance of properties. Other options describe unrelated or incorrect behaviors.

3. Final Answer:

   It creates a new interface that inherits properties from an existing interface. -> Option C

4. Quick Check:

   Extending interfaces means inheritance = D [OK]

Hint: Remember: extends means inherit properties [OK]

Common Mistakes:

• Thinking extends deletes properties
• Confusing interfaces with classes
• Believing extends merges unrelated interfaces

2. Which of the following is the correct syntax to extend an interface Person with a new interface Employee?

easy

A. interface Employee extends Person {}

B. interface Employee inherits Person {}

C. interface Employee : Person {}

D. interface Employee < Person {}

Solution

1. Step 1: Recall TypeScript syntax for extending interfaces

   The correct keyword to extend an interface is extends, used as interface NewInterface extends ExistingInterface {}.

2. Step 2: Check each option

   interface Employee extends Person {} uses the correct syntax. Options B, C, and D use invalid keywords or symbols.

3. Final Answer:

   interface Employee extends Person {} -> Option A

4. Quick Check:

   Use 'extends' keyword for interface inheritance [OK]

Hint: Use 'extends' keyword exactly for interfaces [OK]

Common Mistakes:

• Using 'inherits' instead of 'extends'
• Using ':' like in classes
• Using symbols like '<' incorrectly

3. Given the code below, what is the type of employee?

interface Person {
  name: string;
}
interface Employee extends Person {
  salary: number;
}
const employee: Employee = { name: "Alice", salary: 50000 };

medium

A. { name: string; salary: number; }

B. { salary: number; }

C. { name: string; }

D. Error: Cannot assign object to Employee

Solution

1. Step 1: Understand interface extension effect

   The Employee interface extends Person, so it includes all properties of Person plus its own.

2. Step 2: Analyze the assigned object

   The object has both name (string) and salary (number), matching the combined interface.

3. Final Answer:

   { name: string; salary: number; } -> Option A

4. Quick Check:

   Extended interface combines all properties = A [OK]

Hint: Extended interfaces combine all properties [OK]

Common Mistakes:

• Thinking only base interface properties apply
• Ignoring added properties in extension
• Expecting a type error incorrectly

4. Identify the error in the following TypeScript code:

interface Animal {
  species: string;
}
interface Dog extends Animal {
  breed: string;
}
const pet: Dog = { species: "Canine" };

medium

A. Property 'species' should be a number, not string.

B. Cannot extend interface 'Animal' with 'Dog'.

C. Syntax error in interface declaration.

D. Missing property 'breed' in object assigned to 'pet'.

Solution

1. Step 1: Check properties required by extended interface

   The Dog interface requires both species and breed properties.

2. Step 2: Verify object assigned to pet

   The object only has species, missing breed, causing a type error.

3. Final Answer:

   Missing property 'breed' in object assigned to 'pet'. -> Option D

4. Quick Check:

   All extended interface properties must be present [OK]

Hint: Check all properties from base and extended interfaces [OK]

Common Mistakes:

• Ignoring missing properties in assigned object
• Thinking extending interfaces causes syntax errors
• Confusing property types

5. You have two interfaces:

interface Vehicle {
  make: string;
  model: string;
}
interface ElectricVehicle extends Vehicle {
  batteryCapacity: number;
}

How would you create a new interface ElectricCar that extends ElectricVehicle and adds a range property (number)?

hard

A. interface ElectricCar extends Vehicle ElectricVehicle { range: number; }

B. interface ElectricCar extends ElectricVehicle { range: number; }

C. interface ElectricCar implements ElectricVehicle { range: number; }

D. interface ElectricCar extends Vehicle { batteryCapacity: number; range: number; }

Solution

1. Step 1: Understand interface extension chain

   ElectricVehicle already extends Vehicle, so extending ElectricVehicle includes all properties from both.

2. Step 2: Define ElectricCar extending ElectricVehicle and add range

   The correct syntax is interface ElectricCar extends ElectricVehicle { range: number; }.

3. Step 3: Evaluate other options

   interface ElectricCar extends Vehicle ElectricVehicle { range: number; } has invalid syntax (missing comma). interface ElectricCar implements ElectricVehicle { range: number; } uses implements which is invalid for interfaces. interface ElectricCar extends Vehicle { batteryCapacity: number; range: number; } misses extending ElectricVehicle and manually adds properties.

4. Final Answer:

   interface ElectricCar extends ElectricVehicle { range: number; } -> Option B

5. Quick Check:

   Extend the most specific interface and add new properties [OK]

Hint: Extend the most specific interface, add new properties [OK]

Common Mistakes:

• Trying to extend multiple interfaces unnecessarily
• Using 'implements' instead of 'extends' for interfaces
• Manually repeating inherited properties