TypeScript Type Aliases

Summary: in this tutorial, you will learn how to define new names for types using type aliases.

Introduction to TypeScript type aliases

In TypeScript, a type alias allows you to create a new name for an existing type.

Type aliases can be useful for:

• Simplifying complex types.
• Making code more readable.
• Creating reusable types that can be used in many places in the codebase.

To define a type alias, you use the type keyword followed by the alias name and the type it represents.

Here’s the syntax for defining a type alias

type alias = existingType;

The existing type can be any valid TypeScript type including primitive type, object type, union type, intersection type, and function type.

Type alias examples

1) Primitive types

The following example uses the type alias chars for the string type:

type Name: string;

let firstName: Name;
let lastName: Name;Code language: JavaScript (javascript)

In this example, we create the Name as a type alias for the string type and use it to declare two variables firstName and lastName.

2) Object types

The following example defines a type alias Person for an object that has two properties name and age:

type Person = {
  name: string;
  age: number;
};

let person: Person = {
  name: 'John',
  age: 25
};Code language: JavaScript (javascript)

3) Union Types

The following example shows how to define a type alias for the union type string | number:

type alphanumeric = string | number;

let input: alphanumeric;
input = 100; // valid
input = 'Hi'; // valid
input = false; // Compiler errorCode language: JavaScript (javascript)

4) Intersection Types

The following example shows how to create a type alias for the intersection type Personal & Contact:

type Personal = {
  name: string;
  age: number;
};

type Contact = {
  email: string;
  phone: string;
};

type Candidate = Personal & Contact;

let candidate: Candidate = {
  name: "Joe",
  age: 25,
  email: "[email protected]",
  phone: "(408)-123-4567"
};Code language: JavaScript (javascript)

Summary

• Use type aliases to define new names for existing types.