Course contentsShow
← TypeScript
Lesson 815 of 1,79618. Conditional TypesFree lesson

Creating Safe Type Conversions

Build conditional types that convert types only when safe, returning never or the original type otherwise.

Creating Safe Type Conversions

You'll learn: How to build conditional types that only convert types when it's truly safe, preventing runtime errors by returning never or the original type when conversion would be dangerous.

The Safety Problem

When converting between types, TypeScript can't always verify that the conversion is valid. For example, converting a string to a number might succeed ("42" → 42) or fail ("hello" → NaN). Safe type conversions use conditional types to enforce compile-time checks, ensuring conversions only happen when they make sense structurally.

The Pattern

The core pattern looks like this:

type SafeConvert<T, Target> = T extends Target ? Target : never;

This reads as: "If T is already assignable to Target, convert it. Otherwise, return never (indicating impossibility)."

Real-World Example: Safe String-to-Number

type Numeric = string | number;

type SafeNumber<T> = T extends number 
  ? number 
  : T extends `${number}` 
    ? number 
    : never;

type A = SafeNumber<42>;           // number
type B = SafeNumber<"123">;        // number (string literal that's numeric)
type C = SafeNumber<"hello">;      // never (unsafe conversion blocked)

Preserving When Unsafe

Sometimes you want to keep the original type instead of returning never:

type SafeConvertOrKeep<T, Target> = T extends Target ? Target : T;

type Result1 = SafeConvertOrKeep<number, string>;  // number (kept original)
type Result2 = SafeConvertOrKeep<number, number>;  // number (converted)

This pattern is useful in mapped types where you selectively transform properties but leave incompatible ones unchanged.

Filtering Object Properties Safely

type OnlyNumbers<T> = {
  [K in keyof T]: T[K] extends number ? T[K] : never;
};

type Data = { id: number; name: string; count: number };
type Nums = OnlyNumbers<Data>;  // { id: number; name: never; count: number }

Key Takeaway: Safe type conversions use conditional types with extends checks to permit conversions only when structurally valid, returning never or the original type to prevent type-level errors from becoming runtime bugs.