Runtime type checking strategies in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple runtime type guard function

What is the output of this TypeScript code when calling checkType(42)?

Typescript

function isNumber(value: unknown): value is number {
  return typeof value === 'number';
}

function checkType(value: unknown) {
  if (isNumber(value)) {
    return `Number: ${value}`;
  } else {
    return 'Not a number';
  }
}

console.log(checkType(42));

A undefined

B "Not a number"

C TypeError at runtime

D "Number: 42"

💡 Hint

Think about what the type guard function returns for a number.

The function isNumber checks if the value's type is 'number'. Since 42 is a number, the condition is true, so the function returns the string 'Number: 42'.

🧠 Conceptual

intermediate

Understanding the purpose of runtime type checking

Why do developers use runtime type checking in TypeScript even though TypeScript provides static type checking?

A To catch type errors during program execution that static checking cannot detect

B To improve compile time performance

C To replace static type checking completely

D To avoid writing type annotations in code

💡 Hint

Think about what static type checking cannot verify.

Static type checking happens before running the program and cannot verify types of data coming from external sources like user input or APIs. Runtime type checking helps catch these errors during execution.

❓ Predict Output

advanced

Output of a runtime type check with union types

What is the output of this TypeScript code snippet?

Typescript

type Shape = { kind: 'circle'; radius: number } | { kind: 'square'; side: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.side ** 2;
  }
}

console.log(area({ kind: 'circle', radius: 3 }));

A 28.274333882308138

B 9

C undefined

D TypeError at runtime

💡 Hint

Recall the formula for the area of a circle.

The shape is a circle with radius 3, so the area is π * 3^2 = 28.274333882308138 approximately.

🔧 Debug

advanced

Identify the runtime error in type checking code

What error does this code produce when run, and why?

Typescript

function isStringArray(value: unknown): value is string[] {
  return Array.isArray(value) && value.every(item => typeof item === 'string');
}

const data: unknown = ['hello', 42];

if (isStringArray(data)) {
  console.log(data.join(', '));
} else {
  console.log('Not a string array');
}

A SyntaxError due to missing colon

B Throws TypeError because join is called on a non-array

C Logs 'Not a string array' because 42 is not a string

D Logs 'hello, 42' incorrectly

💡 Hint

Check what the type guard returns for the array with mixed types.

The type guard returns false because not all items are strings. So the else branch runs and logs 'Not a string array'.

🚀 Application

expert

Determine the number of valid keys after runtime filtering

Given this runtime type check filtering an object, how many keys remain in the filtered object?

Typescript

function filterStringValues(obj: Record<string, unknown>): Record<string, string> {
  const result: Record<string, string> = {};
  for (const key in obj) {
    if (typeof obj[key] === 'string') {
      result[key] = obj[key] as string;
    }
  }
  return result;
}

const input = { a: 'apple', b: 42, c: 'cat', d: true, e: 'elephant' };
const filtered = filterStringValues(input);
console.log(Object.keys(filtered).length);

A 5

B 3

C 4

D 2

💡 Hint

Count how many values in the input object are strings.

Only keys 'a', 'c', and 'e' have string values. So the filtered object has 3 keys.