When should I use generics instead of the any type in TypeScript?

Use generics when you need to preserve the relationship between function input types and return values. While any erases type safety and permits invalid operations, generics like function identity (arg: T): T guarantee that the returned value retains its exact original type.

How does TypeScript infer generic types from function arguments?

When invoking a generic function, the compiler inspects the runtime values passed into parameters and matches them against type parameter positions. For example, passing [1, 2] to function first (arr: T[]): T automatically infers T as number without requiring explicit angle brackets.

How do I instantiate a generic type parameter with new T()?

TypeScript type parameters are erased at compile time and do not exist as constructors at runtime. To instantiate a generic type inside a function, require a constructor signature parameter like ctor: new () => T and invoke new ctor() directly.

Build / Code / TypeScript

TypeScript Generics

A practical guide to TypeScript generics, type parameters, constraints, defaults, and reusable data structures.

TL;DR

Declare reusable type placeholders using angle bracket <T> parameter syntax.
Constrain type parameter shapes with the extends keyword operator.
Provide fallback defaults using = in type parameter declarations.

Jump to section

Generic Functions
Generic Interfaces and Types
Type Parameter Constraints
Default Type Parameters
Generic Classes
Tips
Warnings
In Practice
FAQ

Generic Functions

type parameter syntax

Introduces a placeholder type variable within angle brackets.

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

call-site inference

Deduces type arguments automatically from passed arguments.

const text = identity('hello'); // T inferred as string
const num = identity(42);       // T inferred as number

multiple type parameters

Accepts distinct generic variables separated by commas.

function pair<K, V>(key: K, val: V): [K, V] {
  return [key, val];
}
const entry = pair('port', 3000);

Generic Interfaces and Types

generic interface

Parameterizes object shapes for versatile data handling.

interface ApiResponse<T> {
  status: number;
  data: T;
}
const res: ApiResponse<string[]> = {
  status: 200,
  data: ['alpha', 'beta']
};

generic type alias

Builds reusable container models with flexible payloads.

type Result<T, E = Error> =
  | { success: true; value: T }
  | { success: false; error: E };

generic function signature

Defines callable generic contracts in interface methods.

interface Transformer {
  transform<T>(input: T): T;
}

Type Parameter Constraints

extends constraint

Restricts type parameters to shapes matching a contract.

interface HasId {
  id: string;
}
function logId<T extends HasId>(item: T): string {
  return item.id;
}

keyof constraint

Constrains a parameter to valid property keys of another.

function getProp<T, K extends keyof T>(
  obj: T,
  key: K
): T[K] {
  return obj[key];
}

primitive constraint

Limits generics strictly to numbers or string types.

function add<T extends number>(a: T, b: T): number {
  return a + b;
}

Default Type Parameters

default type assignment

Supplies fallback types when callers omit type arguments.

type Container<T = string> = {
  content: T;
};
const defaultBox: Container = { content: 'text' };
const numBox: Container<number> = { content: 99 };

dependent default types

Derives fallback defaults from preceding type parameters.

interface CacheEntry<T, K = string> {
  key: K;
  value: T;
}

function parameter default

Assigns default generic types in function declarations.

function createList<T = number>(): T[] {
  return [];
}
const defaultList = createList(); // number[]

Generic Classes

generic class blueprint

Shares type parameters across all instance methods.

class Queue<T> {
  private data: T[] = [];
  push(item: T) { this.data.push(item); }
  pop(): T | undefined { return this.data.shift(); }
}

instantiating generic class

Binds specific types during object creation with new.

const messages = new Queue<string>();
messages.push('hello');
const nextMsg = messages.pop();

static member limitation

Static methods cannot reference class type parameters.

class Stack<T> {
  // static items: T[]; // Error: Cannot reference T
  static createEmpty<V>(): Stack<V> {
    return new Stack<V>();
  }
}

Tips

Let TypeScript infer generic <T> type arguments from parameter values at call sites whenever possible.
Name type parameters descriptively like TItem or TResponse when complex functions handle multiple distinct generic parameters.

Warnings

Avoid declaring complex <T> generic signatures when a simpler primitive union type fulfills the exact same role.
Remember that type parameters cannot be used as runtime values inside expressions like new T() without constructor signatures.

In Practice

Demonstrates generic classes, constraints, and method return shapes in an in-memory data cache.

Declare a base entity interface requiring an immutable string identifier.
Author a generic repository class constrained to the base entity type.
Implement CRUD methods that return exact typed instances rather than any.
Instantiate the generic store for a concrete user entity and execute queries.

interface Identifiable {
  id: string;
}

class EntityStore<T extends Identifiable> {
  private items = new Map<string, T>();
  set(entity: T) {
    this.items.set(entity.id, entity);
  }
  get(id: string): T | undefined {
    return this.items.get(id);
  }
}

interface User extends Identifiable {
  email: string;
}

const store = new EntityStore<User>();
store.set({ id: 'u1', email: 'dev@example.com' });
console.log(store.get('u1')?.email);

FAQ

Yes, you can assign default types using an equals sign, such as . When consumers omit the type argument and the compiler cannot infer it from parameters, TypeScript falls back to the declared default.

type ResponseBox<T = string> = { data: T };
const box: ResponseBox = { data: 'hello' };