Interfaces vs. Type Aliases: When to Use Which

Type Inference & Literal Types (const vs. let)

Discover how TypeScript infers types automatically and how let versus const declarations shape wide types versus narrow literal types.

1. Two Ways to Define Shapes

TypeScript provides two primary keywords for defining object shapes: interface and type. While they overlap significantly, they possess distinct capabilities.

2. Defining Interfaces & Inheritance (extends)

An interface defines an object contract that can be extended using the extends keyword:

interface User {
  id: number;
  name: string;
}

// Extending an interface
interface AdminUser extends User {
  permissions: string[];
}

const admin: AdminUser = {
  id: 1,
  name: "Sarah",
  permissions: ["read", "write", "delete"],
};

3. Declaration Merging (Interfaces Only)

Multiple interface declarations with the same name in the same scope automatically merge their property definitions:

interface Window {
  customTitle: string;
}

interface Window {
  customVersion: number;
}

// Window interface now contains BOTH properties!

4. Type Aliases & Intersection Types (&)

Type aliases use Intersection Types (&) to combine object shapes:

type AuditLog = { timestamp: Date };
type UserLog = User & AuditLog; // Intersection combining shapes

5. Summary Comparison Matrix

6. Common Mistakes

• Attempting Declaration Merging with Type Aliases: Declaring type User = {...} twice throws a duplicate identifier compiler error. Use interfaces when library authors need expandable shapes!

7. Next Steps

Default to interface for OOP/library object shapes, and type for unions and utility types. Next, let's explore Union Types and Type Narrowing!