Inférence de type TypeScript
L'inférence de type est l'une des fonctionnalités les plus puissantes et les plus pratiques de TypeScript.
Elle permet au compilateur d'analyser automatiquement le contexte du code et d'inférer les types des variables à partir des valeurs des variables, des valeurs de retour des fonctions, etc.
Cela signifie que les développeurs n'ont pas besoin de déclarer explicitement les types pour chaque variable, ce qui leur permet d'écrire un code plus propre et plus facile à maintenir.
Diagramme SVG : processus d'inférence de type
Pourquoi l'inférence de type est nécessaire
Dans le développement JavaScript, vous devez déclarer manuellement les types pour chaque variable.
Cela augmente non seulement la redondance du code, mais réduit aussi l'efficacité du développement.
L'inférence de type de TypeScript peut inférer automatiquement les types des variables dans la plupart des cas.
Les développeurs n'ont besoin de déclarer explicitement les types que lorsque ceux-ci sont complexes ou ambigus.
Explication du concept :L'inférence de type est le processus par lequel le compilateur TypeScript analyse le contexte du code et détermine automatiquement les types des variables. Il infère à partir de plusieurs dimensions telles que les valeurs initiales, les valeurs de retour de fonction et les types de paramètres.
Inférence de type de base
Lorsqu'une variable est déclarée et initialisée, TypeScript infère automatiquement son type à partir de la valeur initiale.
Il s'agit du scénario d'inférence de type le plus courant.
Exemple
// La valeur initiale est le nombre 10, donc le type inféré est number
var num = 10;
// La valeur initiale est une chaîne de caractères, donc le type inféré est string
var str = "hello";
// La valeur initiale est un booléen, donc le type inféré est boolean
var isActive = true;
// Utilisez typeof pour vérifier le résultat inféré
console.log("type de num : " + typeof num);
console.log("type de str : " + typeof str);
console.log("type de isActive : " + typeof isActive);
Sortie :
num 类型: number str 类型: string isActive 类型: boolean
Explication :Lorsque TypeScript utilise `var` pour déclarer une variable, il infère le type en fonction de la valeur initiale. Si la valeur initiale est un nombre, le type est number ; s'il s'agit d'une chaîne de caractères, le type est string.
Inférence du type de retour de fonction
TypeScript infère automatiquement le type de retour en fonction de l'instruction return de la fonction.
Cela garantit des indications de type correctes lors de l'appel de la fonction.
Exemple
// Parce que la valeur retournée est le résultat de a + b
function add(a: number, b: number) {
return a + b;
}
// TypeScript infère le type de retour comme string
// Car la valeur retournée est le résultat d'une concaténation de chaînes
function greet(name: string) {
return "Bonjour, " + name;
}
// Appeler la fonction ; le type de retour a été correctement inféré
var result = add(1, 2);
var result = greet("TypeScript");
console.log("Résultat de l'addition : " + result);
console.log("Salutation : " + message);
Sortie :
加法结果: 3 问候语: Hello, TypeScript
Astuce :Bien que TypeScript puisse inférer les types de retour, dans des projets réels, il est recommandé de déclarer explicitement les types de retour des fonctions pour améliorer la lisibilité du code.
Inférence de type contextuelle
L'inférence de type ne repose pas uniquement sur la variable elle-même, mais aussi sur le contexte dans lequel la variable est utilisée.
Par exemple, le type de paramètre de la fonction de rappel dans une méthode de tableau est automatiquement inféré à partir du type des éléments du tableau.
Exemple
var numbers = [1, 2, 3, 4, 5];
// Utiliser la méthode map
// Le type du paramètre de rappel n est automatiquement inféré comme étant de type number en fonction du type des éléments du tableau numbers
var doubled = numbers.map(function(n) {
// n est automatiquement inféré comme étant de type number
return n * 2;
});
console.log("Doubled array: " + doubled);
Sortie :
翻倍数组: 2,4,6,8,10
Inférence contextuelle :Lorsqu'une variable est utilisée dans un contexte spécifique (comme les callbacks, les gestionnaires d'événements, etc.), TypeScript infère automatiquement le type en fonction de ce contexte. C'est ce qu'on appelle « l'inférence de type contextuelle ».
Inférence du meilleur type commun
Lorsqu'il y a plusieurs types candidats, TypeScript sélectionne le « meilleur type commun » qui peut tous les accueillir.
Cela garantit la compatibilité des types.
Exemple
// TypeScript l'infère comme (number | string)[] (type union)
var mixed = [1, "two", 3, "four"];
// Accès aux éléments de différents types
console.log("Tableau mixte : " + mixed);
console.log("Type : " + typeof mixed[0] + ", " + typeof mixed[1]);
Type union :Lorsqu'un tableau contient plusieurs types, TypeScript infère un type union. Par exemple
(number | string)[]signifie que les éléments du tableau peuvent être de type number ou string.
Limites de l'inférence de type
Bien que l'inférence de type de TypeScript soit puissante, elle peut échouer à inférer correctement les types dans certains cas.
Dans de tels cas, des déclarations de type explicites sont nécessaires.
Exemple
// TypeScript ne peut pas inférer le type, donc il infère any
var unknown;
// Tout type de valeur peut être affecté
unknown = "hello";
unknown = 123;
// Ce comportement peut facilement entraîner des erreurs de type
console.log("Type non spécifié : " + unknown);
// Suggestion : spécifiez explicitement le type pour une meilleure sécurité des types
var fixedNumber: number = 42;
console.log("Type spécifié : " + fixedNumber);
Sortie :
未指定类型: 123 指定类型: 42
Avertissement :Évitez de déclarer des variables sans affectation. Il est préférable de fournir une valeur initiale lors de la déclaration ou de déclarer explicitement un type pour tirer pleinement parti des capacités de vérification de type de TypeScript.
Inférence de fonction générique
Les paramètres de type d’une fonction générique sont automatiquement inférés à partir des arguments transmis.
Cela rend les fonctions génériques flexibles tout en préservant la sécurité des types.
Exemple
// T est automatiquement inféré en fonction de l'argument transmis
function identity<T>(arg: T): T {
return arg;
}
// Passage d'une chaîne, T est inféré comme string
var str = identity("hello");
// Passage d'un nombre, T est inféré comme number
var num = identity(42);
// Passage d'un objet, T est inféré comme le type object
var obj = identity({ name: "TypeScript" });
console.log("Chaîne : " + str);
console.log("Nombre : " + num);
console.log("Objet : " + JSON.stringify(obj));
Inférence générique :TypeScript infère automatiquement le type des paramètres génériques en fonction des types d'arguments passés au site d'appel. Cela permet à la même fonction de gérer différents types d'entrée tout en conservant la sécurité de type.
Notes
- Importance des valeurs initiales :Fournissez toujours une valeur initiale lors de la déclaration d'une variable afin que TypeScript puisse correctement inférer son type
- Déclaration explicite :Lorsque les types sont complexes ou ambigus, il est recommandé de déclarer explicitement les types
- Risques du type any :Les variables sans valeur initiale sont inférées comme any, perdant la protection de la vérification des types
- Mode strict :Il est recommandé d'activer le mode strict pour éviter l'abus des types any
Bonnes pratiques :Tirer pleinement parti de l'inférence de types peut réduire la redondance du code, mais déclarer explicitement les types aux emplacements clés (comme les paramètres de fonction et les types complexes) peut améliorer la lisibilité et la maintenabilité du code.
Résumé
L'inférence de types est une fonctionnalité essentielle de TypeScript qui améliore l'efficacité du développement.
- Inférence de type de base :Déduire le type d'une variable en fonction de sa valeur initiale
- Inférence du type de retour :Déduire le type de retour d'une fonction à partir des instructions return
- Inférence contextuelle :Déduire le type en fonction de l'emplacement d'utilisation
- Meilleur type commun :Choisir le type le plus approprié parmi plusieurs types candidats
- Inférence générique :Inférer automatiquement les types génériques en fonction des arguments passés
- Déclaration explicite :Spécifier explicitement le type lorsque c'est nécessaire
Autres extensionsRecommandation :Bien utiliser l'inférence de types permet d'écrire un code à la fois concis et sûr au niveau des types.