typescript-interface-vs-type

Use interface until you need features from type.

This is the official TypeScript recommendation from the [TypeScript Handbook](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html).

Use interface for:

• Object type definitions
• Extending other object types
• Class implementations
• Declaration merging (augmenting existing types)

Use type only when you need:

• Union types: type Status = 'pending' | 'approved' | 'rejected'
• Mapped types: type Readonly = { readonly [K in keyof T]: T[K] }
• Conditional types: type NonNullable = T extends null | undefined ? never : T
• Tuple types: type Point = [number, number]
• Function types (though interface can also work): type Handler = (event: Event) => void

When extending object types, always prefer interface extends over type intersections.

```typescript

// Preferred

interface User {

name: string;

}

interface Admin extends User {

permissions: string[];

}

// Avoid

type User = {

name: string;

};

type Admin = User & {

permissions: string[];

};

```

Reason 1: Better Error Messages

With interface extends, TypeScript raises errors at the definition when extending with incompatible properties:

```typescript

interface Base {

id: number;

}

// Error immediately at definition

interface Extended extends Base {

id: string; // Error: Type 'string' is not assignable to type 'number'

}

```

With intersections, errors only appear when accessing the incompatible property, making bugs harder to catch:

```typescript

type Base = {

id: number;

};

// No error at definition

type Extended = Base & {

id: string;

};

// Error only when used

const item: Extended = { id: 'abc' }; // Error appears here, not at type definition

```

Reason 2: Better TypeScript Performance

interface extends provides better TypeScript performance:

• Interfaces are cached by name - TypeScript computes the type once and reuses it
• Intersections are recomputed every time they're used, which slows down type checking with complex types

See [TypeScript Performance Wiki](https://github.com/microsoft/TypeScript/wiki/Performance#preferring-interfaces-over-intersections) for details.

• [TypeScript Handbook - Everyday Types](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html)
• [TypeScript Performance Wiki](https://github.com/microsoft/TypeScript/wiki/Performance#preferring-interfaces-over-intersections)
• [Total TypeScript - Intersections vs Interface Extends](https://www.totaltypescript.com/books/total-typescript-essentials/objects#intersections-vs-interface-extends)