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
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
// 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
// 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
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 TypeScript
ReturnType<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.
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
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 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 :Utilisez
infer 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
Autres extensionsRecommandation :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.