Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/typescript/typescript-utility-types/ below:

TypeScript Utility Types - GeeksforGeeks

Last Updated : 23 Jul, 2025

TypeScript utility types are predefined constructs that facilitate common type transformations, enhancing code flexibility and maintainability.

• They allow developers to modify existing types easily, such as by making properties optional or read-only.
• Utility types help in creating more expressive and concise type definitions, reducing redundancy in code.

Here is the list of utility types in TypeScript:

Partial utility type constructs a type with all properties of the provided type T set to optional. It's useful when we want to create a new type where all properties can be present but aren't required.

Partial<T>

• T- represents the original type whose properties are being made optional.

interface User {
    Id: string;
    email: string;
}

type PartialUser = Partial<User>;

const partialUser: PartialUser = { Id: '123' };

console.log(partialUser);

• The PartialUser type has all properties of User set to optional.
• The partialUser object is valid with only the id property.

Output:

{ Id: '123' }

In contrast to Partial, Required utility type constructs a type where all properties of the provided type T are set to required. This is useful when we want to ensure that all properties must be present.

Required<T>

• T: represents any type whose properties we want to make required.

interface User {
    name?: string;
    age?: number;
}

type RequiredUser = Required<User>;

const requiredUser: RequiredUser = { name: 'John', age: 20 };

console.log(requiredUser);

• The RequiredUser type has all properties of User set to required.
• The requiredUser object must include both name and age properties.

Output:

{ name: 'John', age: 20 }

Readonly utility type constructs a type where all properties of the provided type T are marked as readonly. It's beneficial for ensuring immutability.

Readonly<T>

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

type ReadonlyUser = Readonly<User>;

const readonlyUser: ReadonlyUser = { name: 'John', age: 30 };
readonlyUser.name = 'Jane'; 
// This line will giv error: 'name' is read-only

• The ReadonlyUser type has all properties of User set to readonly.
• Attempting to modify readonlyUser.name results in a compile-time error.

Output:

error: Cannot assign to 'name' because it is a read-only property.

Pick utility type constructs a type by picking the set of properties specified by the keys K from the type T. It's useful when we want to create a new type by selecting only a few properties from an existing type.

Pick<T, K>

• T: Represents the type from which properties will be picked.
• K: Represents the keys of T that will be picked.

interface User {
    name: string;
    age: number;
    email: string;
}

type UserSummary = Pick<User, 'name' | 'email'>;

const userSummary: UserSummary = { name: 'ram', email: 'ram@example.com' };
console.log(userSummary)

• The UserSummary type includes only the name and email properties from User.
• The userSummary object must include both name and email properties.

Output:

{ name: 'ram', email: 'ram@example.com' }

Parameters utility type obtains the parameter types of a function type T as a tuple type. It's beneficial when we need to extract the parameter types of a function for further type manipulation.

Parameters<T>

• T: Represents a function type whose parameters we want to extract.

function sum(a: number, b: number): number {
    return a + b;
}

type SumParams = Parameters<typeof sum>;
// SumParams is [number, number]

const params: SumParams = [1, 2];

console.log(params);

• The SumParams type is a tuple representing the parameter types of the sum function.
• The params array is valid with two numbers, matching the sum function's parameters.

Output:

[1, 2]

Record utility type constructs an object type whose property keys are of type K and values are of type T. It's useful when you want to define a fixed set of keys with specific value types.

Record<K, T>

• K: Represents the keys of the resulting record type.
• T: Represents the type of values associated with the keys.

type Fruit = 'apple' | 'banana' | 'orange';
type Inventory = Record<Fruit, number>;

const inventory: Inventory = {
    apple: 10,
    banana: 15,
    orange: 20
};
console.log(inventory)

• The Inventory type defines an object with keys of type Fruit and values of type number.
• The inventory object correctly maps each fruit to its quantity.

Output:

{ apple: 10, banana: 15, orange: 20 }

The Exclude utility type constructs a new type by excluding from T all properties that are assignable to U.

Exclude<T, U>

• T: Represents the original type you want to manipulate.
• U: Represents the subset of T that you want to exclude.

type Status = 'pending' | 'approved' | 'rejected';
type NonRejectedStatus = Exclude<Status, 'rejected'>;

const status: NonRejectedStatus = 'approved';

console.log(status);

• NonRejectedStatus includes only 'pending' and 'approved', excluding 'rejected'.
• Assigning 'rejected' to status would result in an error.
  

Output:

approved

• Understand Each Utility: Familiarize yourself with utility types like Partial, Readonly, Pick, and Omit to use them effectively.
• Maintain Consistency: Apply utility types consistently across your codebase to enhance readability and maintainability.
• Combine Utilities Wisely: Combine utility types to create complex types, but avoid overcomplicating type definitions.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4