Course contentsShow
← TypeScript
Lesson 998 of 1,79623. Type AssertionsFree lesson

Alternatives to Double Assertions

Explore better approaches like narrowing, type predicates, and structural refactoring.

Alternatives to Double Assertions

You'll learn: Better type-safety techniques that eliminate the need for risky double assertions in your TypeScript code.

The Core Idea

When you're tempted to use a double assertion (value as unknown as TargetType), it's usually a sign that something's wrong with your type architecture. Instead of forcing TypeScript to accept your assertion, you should either narrow the type properly, create a custom type predicate, or refactor the structure so the types align naturally.

Think of double assertions like duct-taping a square peg into a round hole. Sure, it fits, but better solutions exist: reshape the peg (narrow the type), verify it actually fits (type predicate), or redesign the hole (refactor structure).

Better Approach 1: Type Narrowing

Use runtime checks to narrow types naturally:

function processValue(input: string | number) {
  // Bad: Double assertion
  // const obj = input as unknown as { value: number };
  
  // Good: Type guard narrowing
  if (typeof input === 'number') {
    const obj = { value: input };
    return obj;
  }
  return { value: parseInt(input) };
}

Better Approach 2: Type Predicates

Create reusable validation functions:

interface User {
  id: number;
  name: string;
}

function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    'id' in value &&
    'name' in value &&
    typeof (value as User).id === 'number' &&
    typeof (value as User).name === 'string'
  );
}

function handleData(data: unknown) {
  // Bad: data as unknown as User
  
  // Good: Type predicate
  if (isUser(data)) {
    console.log(data.name); // Safely narrowed
  }
}

Better Approach 3: Structural Refactoring

Sometimes the types themselves need adjustment:

// Instead of forcing incompatible types together,
// design shared interfaces or union types

type ApiResponse = { success: true; data: string } | { success: false; error: string };

function handleResponse(response: ApiResponse) {
  // No assertions needed - the structure handles both cases
  if (response.success) {
    return response.data;
  }
  throw new Error(response.error);
}

Key takeaway: Double assertions are a code smell—replace them with type guards, type predicates, or structural changes that make the type relationships explicit and safe.