Generics let you write reusable code parameterized by a type — a "type variable" filled in when the code is used. They give you reuse without losing type safety (the alternative, any, loses it).
(): { arr[]; }
first<T>(: T[]): T { arr[]; }
n = ([, , ]);
s = ([, ]);
T is a placeholder; TypeScript infers it from the argument, so the return type is precise — first([1,2]) gives a number, not any.
interface ApiResponse<T> { data: T; status: number; }
const res: ApiResponse<User> = await getUser(); // res.data is User
class Box<T> {
constructor(private value: T) {}
get(): T { return this.value; }
}
const box = new Box(123); // Box<number>
function pair<K, V>(k: K, v: V): [K, V] { return [k, v]; }
pair("id", 42); // [string, number]
Generics power nearly every reusable abstraction in TypeScript: Array<T>, Promise<T>, Map<K,V>, React's useState<T>, data-fetching utilities, and collections.
They let one implementation work for many types while preserving full type information end-to-end — the relationship between input and output types is kept, not erased.