Declaration merging for interfaces in Typescript - Time & Space Complexity

Time Complexity: Declaration merging for interfaces

O(n)

Understanding Time Complexity

We want to understand how the time it takes to use merged interfaces changes as the interface size grows.

How does combining multiple interface declarations affect the work the program does?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

interface User {
  name: string;
}
interface User {
  age: number;
}

function printUser(user: User) {
  console.log(user.name, user.age);
}

This code merges two interface declarations into one combined interface used in a function.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Accessing properties of the merged interface object.
• How many times: Each property access happens once per call; no loops or recursion here.

How Execution Grows With Input

As the interface grows with more merged declarations, the program accesses more properties when used.

Input Size (number of properties)	Approx. Operations
2	2 property accesses
10	10 property accesses
100	100 property accesses

Pattern observation: The number of operations grows directly with the number of properties accessed.

Final Time Complexity

Time Complexity: O(n)

This means the time to access all properties grows linearly with how many properties the merged interface has.

Common Mistake

[X] Wrong: "Merging interfaces creates nested loops or extra hidden work that slows down the program a lot."

[OK] Correct: Merging just combines property lists; accessing them is straightforward and grows only with the number of properties, not loops.

Interview Connect

Understanding how interface merging affects property access helps you reason about code structure and performance in real projects.

Self-Check

What if we added nested interfaces inside the merged interface? How would the time complexity change when accessing nested properties?