Type-safe API response handling in Typescript - Time & Space Complexity

Time Complexity: Type-safe API response handling

O(n)

Understanding Time Complexity

When handling API responses in TypeScript, we often check and process data safely using types. Understanding how the time needed grows as the response size grows helps us write better code.

We want to know: how does the time to handle the response change when the response has more items?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

interface ApiResponse {
  data: { id: number; value: string }[];
}

function processResponse(response: ApiResponse) {
  return response.data.map(item => {
    if (typeof item.id === 'number' && typeof item.value === 'string') {
      return item.value.toUpperCase();
    }
    return null;
  });
}
    

This code takes an API response with a list of items, checks each item's type, and converts the value to uppercase if valid.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The map method loops over each item in the data array.
• How many times: Once for every item in the response array.

How Execution Grows With Input

Explain the growth pattern intuitively.

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

Pattern observation: The work grows directly with the number of items. Double the items, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to process the response grows in a straight line with the number of items.

Common Mistake

[X] Wrong: "Type checks inside the loop don't affect time complexity much."

[OK] Correct: Even simple checks happen for every item, so they add up and affect total time as the list grows.

Interview Connect

Understanding how your code scales with input size shows you can write efficient and reliable programs, a skill valued in many coding challenges and real projects.

Self-Check

"What if we replaced map with a nested loop over two arrays? How would the time complexity change?"