Generics

The plain-language idea

A function parameter is a placeholder for a value, filled in when the function is called. A generic is a placeholder for a type, filled in the same way — at the call site, not when the function is defined.

function identity<T>(x: T): T {
  return x;
}

T isn't a real type — it's a stand-in. identity(42) fills T with number; identity("hi") fills it with string. Each call gets its own, independently correct substitution.

See it in a real thing: what generics preserve that any throws away

function identityAny(x: any): any {
  return x;
}

const a = identityAny(42);     // a: any — TypeScript forgot it was a number
const b = identity(42);        // b: number — TypeScript remembers

Both functions "accept anything." Only one of them keeps track of what it accepted. any isn't a permissive generic — it's the total absence of type checking, and that absence propagates: a.toFixed(2) type-checks even if a turns out to be a string at runtime, because TypeScript gave up tracking it entirely the moment it became any.

function identity<T>(x: T): T — T is a placeholder for a type, filled in wherever this function is actually called.

BackNext

What people usually miss

Watch out

• A generic isn't "accepts any type" — it's "preserves whichever type was actually passed." That preserved relationship between input and output is the entire point; any gives up that relationship completely.
• Multiple type parameters are normal: function merge<T, U>(a: T, b: U): T & U combines two independently-typed inputs into one intersection type, still fully tracked.
• A generic constraint restricts, it doesn't narrow to one concrete type. <T extends { id: string }> still lets T be any shape with at least an id: string — the function just isn't allowed to assume anything more than that about it.
• Components can be generic too. A reusable <List<T> items={T[]} renderItem={(item: T) => ...} /> types itself differently depending on what data it's actually given — the same generic-function idea, applied to JSX.

Why this matters in interviews

"What's the difference between generics and any?" is a favorite because a shallow answer ("they both accept anything") misses the entire reason generics exist — to keep the compiler's understanding of your code intact across a function boundary, instead of throwing it away at the first sign of flexibility.