TypeScript Type Aliases

Type aliases in TypeScript provide a way to create custom names for types, making complex types more readable and reusable. You can use them to define types for primitives, objects, functions, and even union or intersection types.

 

Why Use Type Aliases?

• Simplifies complex type definitions.
• Makes code more readable and reusable.
• Helps with consistency when working with types.

 

Creating a Type Alias

To define a type alias, use the type keyword followed by the name of the alias.

type Point = {  
  x: number;  
  y: number;  
};  

const point1: Point = { x: 10, y: 20 };  
console.log(point1); // Output: { x: 10, y: 20 }

Type Aliases for Primitives

You can use type aliases to name primitive types, which can make code more descriptive.

type ID = number;  
type Username = string;  

const userId: ID = 1234;  
const userName: Username = "JohnDoe";  

console.log(userId, userName); // Output: 1234 "JohnDoe"

Type Aliases for Functions

Type aliases can define function signatures, improving code clarity.

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

const add: AddFunction = (a, b) => a + b;  
console.log(add(5, 3)); // Output: 8

Type Aliases for Union Types

You can use type aliases to create meaningful names for union types.

type Status = "Success" | "Failure" | "Pending";  

const currentStatus: Status = "Success";  
console.log(currentStatus); // Output: "Success"

Type Aliases for Intersection Types

Type aliases can combine multiple types using intersections.

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

type Employee = Person & {  
  position: string;  
  salary: number;  
};  

const employee1: Employee = {  
  name: "Alice",  
  age: 30,  
  position: "Manager",  
  salary: 50000  
};  

console.log(employee1);  
// Output: { name: 'Alice', age: 30, position: 'Manager', salary: 50000 }

Type Aliases with Optional and Readonly Properties

You can use optional (?) and readonly properties in a type alias.

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

const user1: User = { id: 101, name: "Bob" };  
console.log(user1); // Output: { id: 101, name: 'Bob' }  

// user1.id = 202; // Error: Cannot assign to 'id' because it is a read-only property

Type Aliases for Arrays and Tuples

Type aliases can simplify array or tuple types.

type NumberArray = number[];  
type StringTuple = [string, string];  

const numbers: NumberArray = [1, 2, 3, 4];  
const names: StringTuple = ["Alice", "Bob"];  

console.log(numbers); // Output: [1, 2, 3, 4]  
console.log(names);   // Output: ["Alice", "Bob"]

Type Aliases vs Interfaces

While both type aliases and interface can define object types, type aliases are more versatile as they can define primitives, union types, and intersections.

 

Summary

Type aliases in TypeScript allow you to create custom, reusable type names for primitives, objects, functions, and complex types like unions or intersections. They make your code more readable, consistent, and easier to maintain. Use type aliases when you need flexibility beyond what interfaces provide.