TypeScript comes with a large number of predefined generic types that can help with some common type manipulation
Utility Types#
Utility types help to manipulate or create other new types from existing ones
Partial<Type>#
The Partial type takes in another Type and produces a type where all of its properties are optional.
Consider we have the following interface:
type Todo = {
title: string;
description: string;
};If we want to create a type where all of its properties are optional:
type PartialTodo = Partial<Todo>;This is equivalent to:
type PartialTodo = {
title?: string;
description?: string;
};Required<Type>#
The opposite of Partial; The Required type takes in another Type and produces a type where all of its properties are required.
Consider we have the following interface:
type Todo = {
title?: string;
description?: string;
};If we want to create a type where all of its properties are required:
type RequiredTodo = Required<Todo>;This is equivalent to:
type RequiredTodo = {
title: string;
description: string;
};Readonly<Type>#
Create a new type where all properties of Type are set to read-only, meaning the properties are immutable
interface Todo {
title: string;
}
const todo: Readonly<Todo> = {
title: "Delete inactive users",
}
todo.title = "Hello";
// Cannot assign to 'title' because it is a read-only property.Record<Keys, Type>#
This utility creates an object type with properties of specified Keys and values of another specified Type
interface CatInfo {
age: number;
breed: string;
}
type CatName = "miffy" | "boris" | "mordred";
const cats: Record<CatName, CatInfo> = {
miffy: { age: 10, breed: "Persian" },
boris: { age: 5, breed: "Maine Coon" },
mordred: { age: 16, breed: "British Shorthair" },
}Pick<Type, Keys>#
Creates a new type by extracting a specified Keys from Type
interface Todo {
title: string;
description: string;
completed: boolean;
}
type TodoPreview = Pick<Todo, "title" | "completed">;This is equivalent to:
type TodoPreview = {
title: string;
completed: boolean;
};Omit<Type, Keys>#
The opposite of Pick; creates a new type by excluding specified Keys from the original Type
interface Todo {
title: string;
description: string;
completed: boolean;
}
type TodoPreview = Omit<Todo, "completed">;This is equivalent to:
type TodoPreview = {
title: string;
description: boolean;
};Exclude<UnionType, ExcludedMembers>#
Creates a new type by excluding specified ExcludedMembers from a given UnionType.
type Size = 'xl' | 'lg' | 'md' | 'sm' | 'xsm';
type ExcludedSize = Exclude<Size, 'xl' | 'lg'>;This is equivalent to:
type ExcludedSize = 'md' | 'sm' | 'xsm';NonNullable<Type>#
Creates a new type by omitting null and undefined from Type
type NonNullableType = NonNullable<string | number | undefined | null>;This is equivalent to:
type NonNullableType = string | number;Parameters<Type>#
Creates a new type by extracting the parameters Type of a function
type MathOperation = (a: number, b: number) => number;
type OperationParameters = Parameters<MathOperation>;This is equivalent to:
type OperationParameters = [a: number, b: number];Conclusion#
- Utility Types reduce redundancy and ensure the type stays up to date with the original type.