Mot-clé infer TypeScript

infer est un mot-clé dans les types conditionnels TypeScript, utilisé pour inférer de nouveaux types à partir de types existants.

Il permet d'extraire et de dériver des types au sein de types conditionnels génériques, ce qui permet des opérations de type puissantes.


Diagramme SVG : Comment fonctionne infer Background Title How the infer keyword works Original Type Original Type type Promise<T> = { value: T } Arrow infer inference Inference result Extracted type type ValueOf<T> = T extends Promise<infer V> ? V : never Example Example ValueOf<Promise<string>> → string Lower half: Application scenarios Common use cases for infer Scenario 1 Extract Promise value type Scenario 2 Extract array element type Scenario 3 Extract function return type Arrow marker

Pourquoi le mot-clé infer est-il nécessaire ?

En programmation générique, nous devons souvent extraire des types partiels à partir de types complexes.

Par exemple, à partir dePromise<string>extractstring, fromArray<User>extractUser。

Le mot-clé infer rend ce type d'extraction de type élégant et sûr au niveau des types. Il permet de déclarer une variable de type dans un type conditionnel, puis de l'utiliser dans la branche vraie.

Explication du concept :infer est l'abréviation de « infer », ce qui signifie « inférer ». Il ne peut être utilisé que dans la clause extends d'un type conditionnel pour déclarer une variable de type à inférer.


Utilisation de base

Utilisez infer pour inférer des types dans les types conditionnels.

Exemple

// Extraire le type de valeur de Promise
// Si T est Promise<V>, renvoie V ; sinon renvoie never
type ValueOf<T> = T extends Promise<infer V> ? V : never;

// Test
type Str = ValueOf<Promise<string>>;  // string
type Num = ValueOf<Promise<number>>; // number
type NotPrm = ValueOf<string>;        // never

// Exemple d'utilisation
var promise: Promise<string> = Promise.resolve("hello");
var value: ValueOf<typeof promise> = "world";

console.log("Extraction de chaîne : " + (typeof value === "string" ? "Succès" : "Échec"));

Sortie :

String extraction: success

Explication :infer VUne variable de type V est déclarée, et TypeScript inférera automatiquement le type de V.


Extraction des types d'éléments de tableau

Extrayez le type d'élément d'un type tableau.

Exemple

// Extraire le type d'élément d'un tableau
// Si T est un tableau V[], renvoyer V
type ArrayElement<T> = T extends (infer V)[] ? V : never;

// Test
type User = { name: string };
type Users = User[];

type E1 = ArrayElement<string[]>;   // string
type E2 = ArrayElement<Users>;       // User
type E3 = ArrayElement<number>;       // never (non-tableau)

// Exemple d'utilisation
var users: Users = [{ name: "Alice" }];
var element: ArrayElement<Users> = users[0];

console.log("Type d'élément : " + element.name);

Cas d'utilisation :Ce modèle est souvent utilisé pour extraire des éléments d'un type spécifique à partir de types union.


Extraction des types de retour de fonction

Extraire le type de retour d'un type de fonction.

Exemple

// Extraire le type de retour d'une fonction
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

// Test
fonction getData() {
    return { id: 1, name: "Alice" };
}
function fetchUser(id: number): Promise<User> {
    return Promise.resolve({ id, name: "Bob" });
}

type R1 = ReturnType<typeof getData>;  // { id: number; name: string }
type R2 = ReturnType<typeof fetchUser>; // Promise<User>

// Exemple d'utilisation
var result: R1 = { id: 1, name: "Test" };
console.log("Type de retour : " + JSON.stringify(result));

Types intégrés :ceux intégrés de TypeScriptReturnType<T>Les types utilitaires sont implémentés à l'aide de infer.


Extraction des types de paramètres de fonction

Extraire les types de paramètres d'un type de fonction.

< h2 class="example">Exemple
// Extraire le type du premier paramètre d'une fonction
type FirstParameter<T> = T extends (first: infer P, ...rest: any[]) => any ? P : never;

// Test
function createUser(name: string, age: number): Utilisateur {
    return { id: 1, name };
}
function logMessage(msg: string): void {
    console.log(msg);
}

type P1 = FirstParameter<typeof createUser>; // string
type P2 = FirstParameter<typeof logMessage>;  // string
type P3 = FirstParameter<() => void>;          // never

// Exemple d'utilisation
var nameParam: P1 = "Alice";
console.log("Type du paramètre : " + nameParam);

Remarque :Vous pouvez utiliser...rest: any[]pour correspondre à un nombre quelconque de paramètres restants.


Plusieurs infer

Utilisation de plusieurs infer dans un type conditionnel.

Exemple

// Extraire les types des deux premiers éléments d'un tuple
type FirstTwo<T> = T extends [infer A, infer B, ...rest: any[]] ? [A, B] : never;

// Test
type Tuple = [string, number, boolean];
type FirstTwoTypes = FirstTwo<Tuple>; // [string, number]

// Extraire les propriétés de l’objet
type ObjectValue<T> = T extends { value: infer V } ? V : never;

type WithValue = { value: string; name: string };
type ExtractedValue = ObjectValue<WithValue>; // string

// Exemple d'utilisation
var tupleResult: FirstTwoTypes = ["hello", 123];
console.log("Tuple: " + JSON.stringify(tupleResult));

Tuple:Utilisez...rest: any[]pour faire correspondre les éléments restants d’un tuple.


Utilisation de infer dans les types récursifs

Utilisez infer dans les utilitaires de types récursifs pour implémenter des opérations de type complexes.

Exemple

// Type profond en lecture seule - application récursive de infer
type DeepReadonly<T> = T extends Function
    ? T
    : T extends object
        ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
        : T;

// Test
interface User {
    name: string;
    address: {
        city: string;
        zip: string;
    };
}

type ReadonlyUser = DeepReadonly<User>;

// Aplatir les types Promise
type FlattenPromise<T> = T extends Promise<infer U>
    ? U extends Promise<any>
        ? FlattenPromise<U>
        : U
    : T;

type Nested = Promise<Promise<string>>;
type Flat = FlattenPromise<Nested>; // string

// Exemple d'utilisation
var user: ReadonlyUser = {
    name: "Alice",
    address: { city: "Beijing", zip: "100000" }
};
// user.name = "Bob"; // Erreur : readonly
console.log("Lecture seule profonde : " + user.name);

Inférence récursive :L'utilisation de infer dans les types récursifs permet des transformations de type profondes, telles que deep readonly, deep partial, etc.


Notes

  • Ne peut être utilisé qu'à droite de extends :infer ne peut être utilisé que dans la clause extends d'un type conditionnel
  • Déclaration de variables de type :Utilisezinfer Vpour déclarer la variable de type à inférer.
  • Utilisations multiples autorisées :Plusieurs infer peuvent être utilisés dans un seul type conditionnel
  • Renvoie never si l'inférence échoue :Si l'inférence échoue, le type conditionnel renvoie never

Bonnes pratiques :infer est au cœur de l'implémentation de types utilitaires personnalisés ; le maîtriser permet des opérations de type puissantes.


Résumé

infer est l'une des fonctionnalités les plus puissantes du système de types de TypeScript.

  • Extraction de type :Extraire des types partiels à partir de types complexes
  • Inférence conditionnelle :Inférer des types dans les types conditionnels
  • Lié aux fonctions :Extraire les paramètres et les types de retour des fonctions
  • Utilitaires récursifs :Implémenter des transformations de type profondes

Recommandation :Une compréhension approfondie de infer vous permet d'écrire des utilitaires de type plus avancés, améliorant la sécurité des types et l'efficacité du développement.

Autres extensions