Pick Select the specified attribute K from type T Build a new type, suitable for extracting subsets of fields required for API responses, etc.; 2. Omit Exclude the specified attribute K from type T, suitable for creating a public interface that does not contain sensitive or internal fields; 3. Exclude Removes the type members that can be assigned to U from union type T, which are often used to filter unwanted types such as null or number; 4. Extract Keeps the type members that can be assigned to U in union type T, suitable for extracting specific types from mixed union types; 5. Record Creates an object structure with a key K and a value T, suitable for routing mapping or configuration management, where K must be string, number, and symbol or literal union type; 6. Parameters Extract the parameter type of function type T as tuple, suitable for higher-order function encapsulation; 7. ReturnType Extract the return value type of function type T to avoid repeated definition of return structure; 8. NonNullable Remove null and undefined from type T, suitable for processing values that have been checked non-null; 9. Required Turn all optional attributes into Required, suitable for data verification before form submission; 10. Partial Turn all attributes into optional, often used for update operations; 11. ThisType is used to specify the type of this in the object method, and requires --noImplicitThis, which is mostly used for framework design; in addition, you can combine built-in tool types to create custom types such as Prettify Optimize display and Merge to implement type merging coverage. These advanced tool types upgrade TypeScript from type annotation to type programming, improving code security and maintainability.

TypeScript's utility types are powerful tools that let you manipulate and transform existing types in clean, reusable ways. While basic ones like Partial<t></t> or Readonly<t></t> are widely known, TypeScript also offers more advanced utility types that unlock sophisticated type programming. Let's dive into the most useful advanced utility types—what they do, how they work, and when to use them.

1. Pick<t k></t> and Omit<t k></t> – Selective Type Transformation

These two are essential for creating new types by selecting or excluding specific properties.

• Pick<t k></t> : Constructions a type with only the properties listed in K from type T .

  

   interface User {
    id: number;
    name: string;
    email: string;
    age: number;
  }
  
  type UserPreview = Pick<User, &#39;id&#39; | &#39;name&#39;>;
  // { id: number; name: string; }

  Useful when you want to extract a subset of fields—eg, for API responses or form inputs.

• Omit<T, K> : The opposite of Pick . Removes the keys in K from T .

  

   type PublicUser = Omit<User, &#39;email&#39; | &#39;age&#39;>;
  // { id: number; name: string; }

  Great for hiding sensitive or internal fields in public interfaces.

? Tip: Omit<T, K> is especially handy when you're extending a component or props interface but want to exclude certain inherited props.

2. Extract<T, U> and Exclude<T, U> – Conditional Type Filtering

These utilities work on union types , letting you filter out members based on assignment.

• Exclude<T, U> : Removes from T any types that are assigned to U .

   type Status = 'loading' | 'success' | 'error' | 404;
  type StringStatus = Exclude<Status, number>;
  // &#39;loading&#39; | &#39;success&#39; | &#39;error&#39;

  Commonly used to strip unwanted types from unions—eg, removing null or undefined .

• Extract<T, U> : Keeps only the parts of T that are assigned to U .

   type NumbersOnly = Extract<Status, number>;
  // 402

  Useful when you want to isolate a specific kind of value from a mixed union.

These are built using conditional types under the hood:

 type Exclude<T, U> = T extends U ? never : T;
type Extract<T, U> = T extends U ? T : never;

3. Record<K, T> – Flexible Key-Value Mapping

Creates an object type with keys of type K and values of type T .

 type Routes = 'home' | 'about' | 'contact';
const pages: Record<Routes, string> = {
  home: &#39;/&#39;,
  about: &#39;/about&#39;,
  contact: &#39;/contact&#39;,
};

Also useful for mapping configurations or state:

 type ConfigMap = Record<string, { enabled: boolean; timeout: number }>;

?? K must be a string | number | symbol , or a union of literal types. You can't use complex objects as keys.

4. Parameters<T> and ReturnType<T> – Function Signature Introduction

These let you extract types directly from function signatures.

• Parameters<T> : Produces a tuple of the parameter types of a function.

   function createUser(name: string, age: number): void {}
  type CreateArgs = Parameters<typeof createUser>;
  // [name: string, age: number]

  Super useful for higher-order functions or wrappers:

   function withLogging<F extends (...args: any[]) => any>(
    fn: F,
    logger: (...args: any[]) => void
  ): (...args: Parameters<F>) => ReturnType<F> {
    return (...args) => {
      logger(&#39;Calling function with:&#39;, args);
      return fn(...args);
    };
  }

• ReturnType<T> : Extracts the return type of a function.

   type ApiResponse = ReturnType<() => { data: any; status: number }>;
  // { data: any; status: number }

  Often used when you want to type a variable based on a function's output without duplicating the structure.

5. NonNullable<T> – Remove null and undefined

Strips null and undefined from a type.

 type MaybeString = string | null | undefined;
type DefinitelyString = NonNullable<MaybeString>; // string

This is particularly helpful when working with APIs or DOM methods that return nullable types, and you've already checked for existence.

Under the hood:

 type NonNullable<T> = T extends null | undefined ? never : T;

6. Required<T> and Partial<T> – Handling Optional Properties

While Partial<T> is well-known, Required<T> is equally useful in specific cases.

• Partial<T> : Makes all properties optional.
• Required<T> : Makes all properties required.

 interface FormField {
  label?: string;
  value?: string;
  touched?: boolean;
}

type CompleteField = Required<FormField>;
// All fields now required

Use Required when you want to enforce that an object has all properties filled in (eg, before submission or validation).

7. ThisType<T> – Advanced Context Typing (Rare but Powerful)

ThisType doesn't transform types—it tells TypeScript what this should be in an object.

 type MyObj = {
  sayHello(): string;
  getName(): string;
} & ThisType<{ getName(): string; age: number }>;

const obj: MyObj = {
  sayHello() {
    return `Hello, ${this.getName()}! You&#39;re ${this.age}`; // ? `this` knows about `age` and `getName`
  },
  getName() {
    return &#39;Anonymous&#39;;
  },
};

obj.sayHello();

This requires --noImplicitThis and is typically used in framework design or fluent APIs.

Bonus: Custom Utility Type Patterns

You can combine these to create your own advanced utilities.

• Prettify<T> – Clean up nested interaction types in error messages:

   type Prettify<T> = {
  } & {};

• Merge<T, U> – Combine two types, with U overriding T :

   type Merge<T, U> = Omit<T, keyof U> & U;

  Useful for config overrides or theme extensions.

These advanced utility types become indispensable as your TypeScript projects grow in complexity. They help you write safer, more maintained code by reusing and transforming types instead of duplicating them.

Basically, once you start combining Pick , Omit , Parameters , and ReturnType , you're no longer just annotating types—you're programming with them.

The above is the detailed content of Advanced TypeScript Utility Types Explained. For more information, please follow other related articles on the PHP Chinese website!