Why type narrowing is needed in Typescript - The Real Reasons

The Big Idea

What if your code could instantly know exactly what kind of data it's handling, avoiding bugs before they happen?

The Scenario

Imagine you have a box that can hold different kinds of toys, but you don't know which toy is inside until you open it. You want to play with the toy, but you must first check what type it is to avoid breaking it or playing the wrong way.

The Problem

If you try to play with the toy without checking its type, you might use the wrong method or action, causing errors or crashes. Manually checking every possible type with many if-else statements is slow, confusing, and easy to get wrong.

The Solution

Type narrowing helps by automatically telling you what kind of toy is inside the box at each step. It lets you safely use the right actions without guessing or writing extra checks everywhere.

Before vs After

✗ Before

function play(toy: string | number) {
  if (typeof toy === 'string') {
    console.log(toy.toUpperCase());
  } else {
    console.log(toy.toFixed(2));
  }
}

✓ After

function play(toy: string | number) {
  if (typeof toy === 'string') {
    console.log(toy.toUpperCase()); // TypeScript knows toy is string here
  } else {
    console.log(toy.toFixed(2)); // TypeScript knows toy is number here
  }
}

What It Enables

It enables writing safer and clearer code that adapts automatically to different data types without mistakes.

Real Life Example

When building a chat app, messages can be text or images. Type narrowing helps the app know when to show text or display an image, avoiding crashes or wrong displays.

Key Takeaways

Manual type checks are slow and error-prone.

Type narrowing automatically detects the exact type in each code branch.

This leads to safer, cleaner, and more reliable code.

Practice

1. Why do we need type narrowing in TypeScript when a variable can have multiple types?

easy

A. To tell TypeScript the exact type so it can check code safety

B. To make the code run faster at runtime

C. To allow variables to change types dynamically

D. To avoid writing any type annotations

Solution

1. Step 1: Understand the role of type narrowing

   Type narrowing helps TypeScript know the exact type of a variable at a certain point in code.

2. Step 2: Recognize the benefit for code safety

   Knowing the exact type allows TypeScript to check for errors and prevent bugs before running the code.

3. Final Answer:

   To tell TypeScript the exact type so it can check code safety -> Option A

4. Quick Check:

   Type narrowing = safer code [OK]

Hint: Type narrowing means telling TypeScript exact types [OK]

Common Mistakes:

• Thinking it speeds up runtime
• Believing it allows dynamic type changes
• Assuming it removes need for type annotations

2. Which of the following is a correct way to narrow a variable's type in TypeScript?

easy

A. function test(value: number | string) { return value; }

B. value = 'string' as number;

C. let value: any = 5; value = 'hello';

D. if (typeof value === 'string') { /* value is string here */ }

Solution

1. Step 1: Identify type narrowing syntax

   Using typeof checks like typeof value === 'string' narrows the type inside the block.

2. Step 2: Check other options for correctness

   value = 'string' as number; forces wrong type with as, let value: any = 5; value = 'hello'; uses any without narrowing, function test(value: number | string) { return value; } does not narrow inside function.

3. Final Answer:

   if (typeof value === 'string') { /* value is string here */ } -> Option D

4. Quick Check:

   typeof check narrows type [OK]

Hint: Use typeof or instanceof to narrow types [OK]

Common Mistakes:

• Using 'as' to force wrong types
• Not using any type checks
• Confusing type assertion with narrowing

3. What will be the output of this TypeScript code?

function printLength(x: string | number) {
  if (typeof x === 'string') {
    return x.length;
  } else {
    return x.toFixed(2);
  }
}
console.log(printLength('hello'));
console.log(printLength(3.14159));

medium

A. hello and 3.14

B. 5 and 3.14159

C. 5 and 3.14

D. Error because length is not on number

Solution

1. Step 1: Analyze the type narrowing in the function

   The if checks if x is a string, then returns its length (5 for 'hello'). Else, it treats x as number and calls toFixed(2).

2. Step 2: Evaluate the outputs for given inputs

   For 'hello', output is 5. For 3.14159, toFixed(2) returns '3.14'.

3. Final Answer:

   5 and 3.14 -> Option C

4. Quick Check:

   Type narrowing enables correct method calls [OK]

Hint: Check typeof to know which method runs [OK]

Common Mistakes:

• Expecting full decimal for number output
• Assuming length works on number
• Ignoring type narrowing effect

4. Identify the error in this TypeScript code and why type narrowing is needed:

function process(value: string | number) {
  console.log(value.length);
}

medium

A. Error: string type cannot be logged

B. Error: number type has no 'length' property, need narrowing

C. No error, code runs fine

D. Error: function missing return type

Solution

1. Step 1: Understand the union type usage

   The parameter value can be string or number, but length exists only on string.

2. Step 2: Identify why narrowing is needed

   Without checking type, accessing length on number causes error. Type narrowing is needed to safely access length.

3. Final Answer:

   Error: number type has no 'length' property, need narrowing -> Option B

4. Quick Check:

   Accessing properties needs type narrowing [OK]

Hint: Check type before accessing properties [OK]

Common Mistakes:

• Ignoring union types
• Assuming all types have same properties
• Not using if or typeof checks

5. You have a function that accepts string | number | null. You want to safely return the string length or number fixed to 1 decimal, or 0 if null. Which code correctly uses type narrowing?

hard

A. function format(x: string | number | null) {
if (x === null) return 0;
if (typeof x === 'string') return x.length;
return x.toFixed(1);
}

B. function format(x: string | number | null) {
if (x) return x.length || x.toFixed(1);
return 0;
}

C. function format(x: string | number | null) {
return x.length ?? x.toFixed(1) ?? 0;
}

D. function format(x: string | number | null) {
if (typeof x === 'number') return x.length;
else if (typeof x === 'string') return x.toFixed(1);
else return 0;
}

Solution

1. Step 1: Check handling of null

   function format(x: string | number | null) { if (x === null) return 0; if (typeof x === 'string') return x.length; return x.toFixed(1); } explicitly returns 0 if x is null, which is correct.

2. Step 2: Verify type narrowing for string and number

   function format(x: string | number | null) { if (x === null) return 0; if (typeof x === 'string') return x.length; return x.toFixed(1); } uses typeof to check string and number separately, calling correct methods safely.

3. Step 3: Identify errors in other options

   function format(x: string | number | null) { if (x) return x.length || x.toFixed(1); return 0; } incorrectly uses x.length || x.toFixed(1) without narrowing; function format(x: string | number | null) { return x.length ?? x.toFixed(1) ?? 0; } uses nullish coalescing incorrectly; function format(x: string | number | null) { if (typeof x === 'number') return x.length; else if (typeof x === 'string') return x.toFixed(1); else return 0; } swaps methods for types.

4. Final Answer:

   function format(x: string | number | null) { if (x === null) return 0; if (typeof x === 'string') return x.length; return x.toFixed(1); } -> Option A

5. Quick Check:

   Explicit checks safely narrow types [OK]

Hint: Check null first, then typeof string or number [OK]

Common Mistakes:

• Not checking null before accessing properties
• Mixing up string and number methods
• Using || or ?? without narrowing