Optional properties in interfaces in Typescript - Time & Space Complexity

Time Complexity: Optional properties in interfaces

O(n)

Understanding Time Complexity

We want to see how the time it takes to check optional properties in interfaces changes as the input grows.

How does the program's work increase when more objects with optional properties are checked?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

interface User {
  id: number;
  name?: string; // optional property
}

function greetUsers(users: User[]) {
  for (const user of users) {
    if (user.name !== undefined) {
      console.log(`Hello, ${user.name}!`);
    } else {
      console.log('Hello, guest!');
    }
  }
}
    

This code loops through a list of users and greets them by name if available, or as guest if not.

Identify Repeating Operations

• Primary operation: Looping through each user in the array.
• How many times: Once for every user in the list.

How Execution Grows With Input

Each user causes one check and one greeting. More users mean more checks and greetings.

Input Size (n)	Approx. Operations
10	10 greetings and checks
100	100 greetings and checks
1000	1000 greetings and checks

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

Final Time Complexity

Time Complexity: O(n)

This means the time to greet users grows in a straight line as the number of users increases.

Common Mistake

[X] Wrong: "Checking optional properties makes the code slower in a way that depends on how many optional properties there are."

[OK] Correct: The check for an optional property is simple and happens once per user, so it only adds a small constant step per user, not extra loops or nested work.

Interview Connect

Understanding how optional properties affect loops helps you explain how your code scales when handling flexible data shapes, a useful skill in many coding tasks.

Self-Check

What if we added a nested loop inside the greeting to check multiple optional properties? How would the time complexity change?