Never type and unreachable code in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function with never type in switch

What is the output of this TypeScript code when calling checkValue('a')?

Typescript

function checkValue(x: 'a' | 'b'): string {
  switch (x) {
    case 'a':
      return 'Got a';
    case 'b':
      return 'Got b';
    default:
      const _exhaustiveCheck: never = x;
      return _exhaustiveCheck;
  }
}
console.log(checkValue('a'));

A "Got a"

B TypeError at runtime

C Compilation error due to never type assignment

D "Got b"

💡 Hint

The function handles all possible cases of the union type, so the default case is never reached.

The function covers all possible values of the union type 'a' | 'b'. The default case is unreachable, so the never type assignment is valid and the function returns 'Got a' when called with 'a'.

❓ Predict Output

intermediate

Value of variable after function with never return

What is the value of result after running this code?

Typescript

function fail(): never {
  throw new Error('Fail');
}

let result = 0;
try {
  fail();
  result = 1;
} catch {
  result = 2;
}
console.log(result);

A 0

B 1

C undefined

D 2

💡 Hint

The function always throws an error, so the code after calling it inside try is unreachable.

The function fail() never returns normally because it throws an error. So the assignment result = 1 is never executed. The catch block sets result to 2.

🔧 Debug

advanced

Identify unreachable code in function with never

Which line in this function is unreachable and why?

Typescript

function process(input: string | number) {
  if (typeof input === 'string') {
    return input.toUpperCase();
  } else if (typeof input === 'number') {
    return input.toFixed(2);
  }
  console.log('Unreachable code');
}

A Line with <code>return input.toUpperCase();</code> because input might not be string

B Line with <code>return input.toFixed(2);</code> because input might not be number

C Line with <code>console.log('Unreachable code');</code> because all cases are handled

D No unreachable code, all lines can run

💡 Hint

The input type is a union of string or number, and both are handled with returns.

Since input can only be string or number, both cases return a value. The last console.log line is never reached, so it is unreachable code.

📝 Syntax

advanced

Which option causes a TypeScript error due to never type?

Which of these code snippets causes a TypeScript compilation error because of incorrect use of the never type?

A

function example(x: string | number) {
  if (typeof x === 'string') {
    return x;
  } else if (typeof x === 'number') {
    return x;
  } else {
    const y: never = x;
    return y;
  }
}

B

function example(x: string | number) {
  if (typeof x === 'string') {
    return x;
  } else {
    const y: never = x;
    return y;
  }
}

C

function example(x: string | number) {
  if (typeof x === 'string') {
    return x;
  } else if (typeof x === 'number') {
    return x;
  }
}

D

function example(x: never) {
  return x;
}

💡 Hint

Check if all possible types are handled before assigning to never.

In option B, the else block can receive a number, but it tries to assign it to a variable of type never, which causes a compilation error. Option B handles all cases and uses never correctly. Option B returns for all cases and has no unreachable code. Option B is valid because x is never type.

🚀 Application

expert

How many unreachable lines are in this function?

Consider this TypeScript function. How many lines are unreachable?

Typescript

function analyze(value: 'x' | 'y' | 'z') {
  switch (value) {
    case 'x':
      return 'X';
    case 'y':
      return 'Y';
    case 'z':
      return 'Z';
    default:
      const check: never = value;
      break;
  }
  console.log('After switch');
  return 'Done';
}

A 2

B 1

C 0

D 3

💡 Hint

Think about which lines can never be reached because all cases are handled.

The default case is unreachable because all possible values are handled. The break in default is unreachable. Also, the console.log and return after switch are unreachable because all cases return. So two lines are unreachable: the break and the console.log line.