Type compatibility with classes in Typescript - Time & Space Complexity

Time Complexity: Type compatibility with classes

O(n)

Understanding Time Complexity

When working with classes in TypeScript, it's important to understand how type compatibility affects performance.

We want to see how the program's work grows when checking if one class type fits another.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Point {
  x: number;
  y: number;
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }
}

function isCompatible(a: Point, b: Point): boolean {
  return a.x === b.x && a.y === b.y;
}

const p1 = new Point(1, 2);
const p2 = new Point(1, 2);
console.log(isCompatible(p1, p2));
    

This code checks if two Point objects have the same x and y values.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Comparing each property of the class instances.
• How many times: Once per property (here 2 properties: x and y).

How Execution Grows With Input

As the number of properties in the class grows, the number of comparisons grows too.

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

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

Final Time Complexity

Time Complexity: O(n)

This means the time to check compatibility grows in a straight line with the number of properties.

Common Mistake

[X] Wrong: "Type compatibility checks happen instantly no matter how many properties there are."

[OK] Correct: Each property must be checked, so more properties mean more work and longer checks.

Interview Connect

Understanding how type compatibility scales helps you write efficient code and explain your reasoning clearly in interviews.

Self-Check

"What if the class had nested objects as properties? How would the time complexity change?"