TypeScript Conditional Types — Complete Interview Guide

Basic Conditional Type Syntax

// T extends U ? X : Y
// "If T is assignable to U, the type is X. Otherwise the type is Y."

type IsString<T> = T extends string ? true : false;

type A = IsString<string>;  // true
type B = IsString<number>;  // false
type C = IsString<"hello">; // true — "hello" extends string

// Practical: NonNullable (removes null and undefined from T)
type NonNullable<T> = T extends null | undefined ? never : T;

type D = NonNullable<string | null>;        // string
type E = NonNullable<number | undefined>;   // number
type F = NonNullable<null | undefined>;     // never

Distributive Conditional Types

When the type parameter is a naked type variable (not wrapped in anything), conditional types distribute over union members automatically — the condition is applied to each union member separately and the results are combined:

// T is naked (not wrapped) — distributes over unions
type ToArray<T> = T extends any ? T[] : never;

type StringOrNumberArrays = ToArray<string | number>;
// Distributes: ToArray<string> | ToArray<number>
// = string[] | number[]
// (NOT (string | number)[])

// Exclude is a distributive conditional type
type Exclude<T, U> = T extends U ? never : T;
type Status = "active" | "inactive" | "deleted";
type ActiveOrInactive = Exclude<Status, "deleted">;
// Distributes:
//   "active" extends "deleted" ? never : "active"   → "active"
//   "inactive" extends "deleted" ? never : "inactive" → "inactive"
//   "deleted" extends "deleted" ? never : "deleted"  → never
// Result: "active" | "inactive"

// To PREVENT distribution — wrap T in a tuple
type NoDistribute<T> = [T] extends [any] ? T[] : never;
type Wrapped = NoDistribute<string | number>;
// [string | number] extends [any] = true → (string | number)[]
// (NOT string[] | number[])

The infer Keyword

infer declares a type variable to be inferred by TypeScript during the extends check. It's the mechanism that makes ReturnType, Parameters, and Awaited possible:

// ReturnType — infer R is bound to the return type of the function
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

function getUser(): User { return { id: 1, name: "Alice" }; }
type UserType = ReturnType<typeof getUser>; // User

// Parameters — infer P is bound to the parameter tuple
type Parameters<T> = T extends (...args: infer P) => any ? P : never;
type GetUserParams = Parameters<typeof getUser>; // []

// Unwrap a Promise — infer the resolved type
type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
// Recursively unwraps: Promise<Promise<string>> → string

type Resolved = Awaited<Promise<User[]>>; // User[]

// Extract array element type
type ArrayElement<T> = T extends (infer E)[] ? E : never;
type ItemType = ArrayElement<string[]>; // string

// Extract the first element of a tuple
type Head<T extends any[]> = T extends [infer H, ...any[]] ? H : never;
type FirstArg = Head<[string, number, boolean]>; // string

Chained Conditional Types

// Multiple conditions — like if/else if/else chains
type TypeName<T> =
  T extends string  ? "string"  :
  T extends number  ? "number"  :
  T extends boolean ? "boolean" :
  T extends symbol  ? "symbol"  :
  T extends object  ? "object"  :
  "other";

type A = TypeName<string>;      // "string"
type B = TypeName<42>;          // "number"
type C = TypeName<() => void>;  // "object"

// Nested conditional for deep type extraction
type UnwrapNested<T> =
  T extends Promise<infer U> ? UnwrapNested<U> :
  T extends Array<infer U>   ? UnwrapNested<U> :
  T;

Conditional Types in Mapped Types

// Filter properties by value type using conditional type in mapped key position
type PickByValue<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K];
};

interface Config {
  host: string;
  port: number;
  debug: boolean;
  maxRetries: number;
}

type StringConfig = PickByValue<Config, string>;
// { host: string; }

type NumberConfig = PickByValue<Config, number>;
// { port: number; maxRetries: number; }

// Make only certain value-typed fields optional
type OptionalStrings<T> = {
  [K in keyof T]: T[K] extends string ? T[K] | undefined : T[K];
};