Roadmap

4 - Type predicates vs equality checks vs assertions.

End of Lesson

Deciding the right type guard

We have seen 3 different methods to implement type guards:

  1. Type predicates
  2. Equality Checks
  3. Assertions

Here's a brief summary of when to prefer type predicates, equality checks, or assertions in TypeScript:

1. Type Predicates (value is Type)

  • Use When: You need to determine the type of a value within a conditional block and ensure TypeScript narrows the type based on the check.
  • Best For: Situations where type checks are common, reusable, and where you want the function to return true or false.

Example: Checking if an event is of a specific type in a function that processes different types of events.

ts
function isClickEvent(event: Event): event is ClickEvent {
  return event.type === "click";
}

2. Equality Checks (===)

  • Use When: You need a straightforward comparison of values.
  • Best For: Simple cases where you're comparing primitives or checking specific conditions. Easier to implement when the check is simple and not re-used many times, hence adding a type predicate may not be beneficial.

Example: Verifying that a string or number has a particular value.

ts
if (event.type === "click") {
  console.log("This is a ClickEvent.");
}

3. Assertion Functions (asserts value is Type)

  • Use When: You want to enforce that a value must be of a specific type and want to throw an error if it isn't.

This stops further execution if the assertion fails.

  • Best For: Scenarios where it's critical that a value conforms to a specific type, and you need to ensure that downstream code operates on the correct type without fallback logic.

Example:

ts
function assertIsClickEvent(event: Event): asserts event is ClickEvent {
  if (event.type !== "click") {
    throw new Error("Not a ClickEvent");
  }
}

Summary:

  • Use Type Predicates for reusable type checks where the result determines code flow.
  • Use Equality Checks for simple, direct comparisons or when TypeScript can infer the correct type from the comparison.
  • Use Assertion Functions when you need to guarantee a specific type and want to stop execution if the type condition isn't met.