Advanced generics and conditional types of TypeScript are the core tools for building type-safe, reusable, and intelligent type derivation capabilities. 1. Generics can ensure type safety through constraints (such as K extends keyof T), and achieve precise attribute derivation with index access types; 2. You can set default generic parameters (such as T = unknown) to improve flexibility; 3. Conditional types (T extends U ? X : Y) realize logical judgment at the type level; 4. Use infer to extract type return value and other type information from conditional types; 5. Conditional types have distributed characteristics when acting on union types, and can be disabled by tuple wrapping ([T]); 6. Mapping types and conditional types can create intelligent tool types such as MakeOptional and Promisify; 7. Built-in tool types such as Exclude, Extract, ReturnType, and InstanceType are all implemented based on conditional types and can be imitated for customization; 8. Generic combination is Type predicates can implement type guarding and improve the security of type judgment at runtime. After mastering these features, TypeScript is not only a type annotation, but also a powerful type programming language.

Advanced generics and conditional types of TypeScript are the core tools for building type-safe, reusable, and intelligent type derivation systems. They allow you to dynamically generate new types based on relationships between types, and even let the compiler "infer" the correct return type. The following is a description of the core concepts and typical application scenarios of these characteristics from the perspective of actual use.

1. Advanced usage of generics: constraints, default values and multiple parameters

Generics are not just T , you can improve type safety with more granular control.

 // Constrained generics must have a specific structure function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { name: "Alice", age: 30 };
getProperty(user, "name"); // ? Type derivation to string
getProperty(user, "email"); // ? Compilation error: email is not in the user&#39;s key

• K extends keyof T : Make sure that the incoming key does exist in the object.
• The return type T[K] is the index access type , which can accurately deduce the attribute type.

The default generic parameters are also very practical, such as:

 type ApiResponse<T = unknown> = {
  data: T;
  status: number;
};

const response: ApiResponse<string> = { data: "success", status: 200 };
const unknownRes: ApiResponse = { data: {}, status: 404 }; // Use default unknown

2. Conditional type: if...else at type level

The syntax of conditional types is: T extends U ? X : Y , which makes type judgments at compile time.

 type IsString<T> = T extends string ? true : false;

type A = IsString<"hello">; // true
type B = IsString<123>; // false

But what is really powerful is combining generics and conditional types for type filtering or mapping.

Practical application: Extract function return value type

 type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

function getUser() {
  return { name: "Bob", age: 25 };
}

type User = ReturnType<typeof getUser>; // { name: string; age: number }

• infer R means "inferred return type", which is a weapon for extracting types from conditional types.

3. Intelligent splitting of distributed condition types and union types

When a condition type acts on a union type, it is automatically "distributed" to each member.

 type ToArray<T> = T extends any ? T[] : never;

type Result = ToArray<string | number>;
// Equivalent to: ToArray<string> | ToArray<number>
// Final: string[] | number[]

This "distributed" behavior is very useful when dealing with union types. If you want to disable distribution, you can use [T] extends [any] to package one layer:

 type NonDistributed<T> = [T] extends [any] ? T[] : never;
// No more split joint types

4. Mapping type condition type: Build smart type tool

Combination uses can create powerful type manipulation tools.

Example: Change a specific property to optional or read-only

 // Change certain properties to optional type MakeOptional<T, K extends keyof T> = {
  [P in K]?: T[P];
} & {
  [P in Exclude<keyof T, K>]: T[P];
};

interface User {
  name: string;
  email: string;
  role: "admin" | "user";
}

type PartialEmailUser = MakeOptional<User, "email">;
// email becomes optional, others remain unchanged

Going further: Automatically convert according to value type

 type Promisify<T> = {
  [K in keyof T]: Promise<T[K]>;
};

const values = {
  name: "Alice",
  count: 42,
};

type AsyncValues = Promisify<typeof values>;
// { name: Promise<string>, count: Promise<number> }

5. Practical advanced modes: Extract, Exclude, ReturnType, InstanceType

TypeScript has built-in tool types based on conditional types, and understanding their implementation helps customize logic.

 // Exclude: Exclude type that can be assigned to U from T withoutString = Exclude<string | number | boolean, string>; // number | boolean

// Extract: Only retain types that can be assigned to U. OnlyString = Extract<string | number | boolean, string>; // string

// InstanceType: Get the instance type of the constructor class Person {
  constructor(public name: string) {}
}

type PersonInstance = InstanceType<typeof Person>; // Person

You can also imitate these and write one of your own:

 type GetFunctionReturnType<T> = T extends (...args: any[]) => infer R
  ? R
  : never;

6. Practical skills: Combining type guards and generics

Use generics in functions to match is type predicates to achieve safer runtime type judgment.

 function isDefined<T>(value: T | null | undefined): value is T {
  return value !== null && value !== undefined;
}

const maybeUser = getUserOrNull();
if (isDefined(maybeUser)) {
  // TypeScript knows that maybeUser is the User type console.log(maybeUser.name);
}

Summary: Key points reminder

• infer is a powerful tool for extracting types, and is often used for function return values, parameters, Promise unpacking, etc.
• Conditional type Union type = distributed judgment , be careful to use, and disable with tuples if necessary.
• Map type condition types A highly flexible type converter can be built.
• Use keyof , extends , and infer to implement type programming.
• In actual projects, you will give priority to using built-in tools such as ReturnType<t></t> and Partial<t></t> . You can customize it after understanding its principles.

Basically that's it. Advanced generics and conditional types may seem complex, but once you master it, you will find that TypeScript is not just a type annotation, but a type-level programming language . Not complicated, but it is easy to ignore details.

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