Core Code
Core Code Modern Dev Handbook

Type Aliases

Learn how to use type aliases in TypeScript to create reusable and readable type definitions. Type aliases simplify complex types and improve maintainability in large applications.
On this page

What is a type alias?

A type alias allows you to create a custom name for any type. This makes complex type definitions easier to reuse and improves readability across your codebase. In production systems, type aliases are frequently used to model domain entities, API responses, and reusable function signatures.

Basic type alias syntax

You define a type alias using the type keyword.

type UserId = number;

let id: UserId = 10;

This does not create a new runtime type. It simply provides a clearer name for an existing type.

Aliasing object types

Type aliases are commonly used to define object structures.

type User = {
  id: number;
  name: string;
  email?: string;
};

const u: User = {
  id: 1,
  name: "Zeynep"
};

This approach keeps object contracts reusable and centralized.

Aliasing union types

Union types can quickly become repetitive. Type aliases make them more manageable.

type Status = "draft" | "published" | "archived";

let postStatus: Status = "draft";

Using an alias avoids repeating the same union everywhere.

Aliasing function types

Type aliases are useful for reusable function signatures.

type MathOperation = (a: number, b: number) => number;

const add: MathOperation = (a, b) => a + b;

This ensures consistency across implementations.

Intersection types with aliases

Type aliases can combine multiple types using intersections.

type Timestamped = { createdAt: Date };
type UserWithTimestamp = User & Timestamped;

This enables composable and modular type design.

Type aliases vs interfaces

Both type aliases and interfaces define object shapes, but they have subtle differences. Type aliases are more flexible for unions, intersections, and primitive types. Interfaces are often preferred for extendable object contracts. Choosing between them depends on architectural needs.

Limitations

Type aliases cannot be reopened or merged like interfaces. Once defined, they are fixed. This can be beneficial for clarity but less flexible for library augmentation.

Common mistakes

  • Creating overly complex nested types that reduce readability.
  • Using long inline types instead of reusable aliases.
  • Confusing type aliases with runtime constructs.

Production guidance

  • Use type aliases to model domain concepts clearly.
  • Prefer short, meaningful names that reflect business logic.
  • Combine aliases with unions and intersections for composable models.
  • Keep types simple and avoid unnecessary abstraction.

What’s next

Now that you can create reusable type definitions, the next step is understanding interfaces and how they differ from type aliases in scalable architectures.

Interfaces →