Qu’est-ce que l’inférence des types ?

L’inférence des types est une fonctionnalité de TypeScript qui détermine automatiquement le type d’une variable ou d’une expression en fonction de sa valeur.

Par exemple, lorsque vous écrivez let age = 25;, TypeScript déduit que age est de type number.

Avantages de l’inférence des types

L’inférence des types réduit la nécessité de déclarer explicitement les types, ce qui rend votre code plus clair et plus facile à écrire.

Elle aide également TypeScript à détecter les erreurs pendant le développement, garantissant la sécurité des types sans ajouter d’annotations supplémentaires.

Exemples d’inférence des types

Voici quelques exemples : 

• let message = 'Hello'; - TypeScript déduit le type string. 
• const isActive = true; - TypeScript déduit le type boolean.

L’inférence des types fonctionne également avec les valeurs de retour des fonctions :

function add(a: number, b: number) {
  return a + b;
}

Qu’est-ce que le typage contextuel ?

Le typage contextuel se produit lorsque TypeScript attribue un type à une variable en fonction de son contexte environnant.

Par exemple, lors de l’utilisation d’un écouteur d’événements, TypeScript déduit le type du paramètre event :

document.addEventListener('click', (event) => {
  console.log(event.clientX); // TypeScript knows event is a MouseEvent
});

document.addEventListener('click', (event) => {
  console.log(event.clientX);
});

Avantages du typage contextuel

Le typage contextuel améliore l’expérience de développement en réduisant la nécessité d’ajouter manuellement des annotations de type.

Il aide à détecter les erreurs et garantit que vous utilisez les types appropriés dans des contextes spécifiques.

Situations courantes d’inférence des types

TypeScript effectue une inférence dans de nombreuses situations, notamment :

• Initialisation d’une variable : let name = 'John';
• Valeurs de retour d’une fonction : function greet() { return 'Hello'; }
• Valeurs d’un tableau : let numbers = [1, 2, 3]; (déduit comme étant de type number[]).

Quand utiliser des types explicites

Bien que l’inférence des types de TypeScript soit puissante, certains cas se prêtent mieux à l’utilisation de types explicites :

• Lorsque le type est ambigu ou complexe.
• Pour les paramètres des fonctions, afin de garantir la clarté.
• Pour les API publiques, lorsque des types explicites améliorent la lisibilité et la maintenabilité.

Exercice : inférence des types et typage contextuel

Écrivez une fonction qui prend deux nombres en entrée et renvoie leur somme. TypeScript déduira les types pour vous !

Exemple :

function addNumbers(a, b) {
  return a + b;
}

function addNumbers(a, b) {
  return a + b;
}

Excellent travail !

Vous avez appris comment TypeScript utilise l’inférence des types et le typage contextuel pour rendre votre code efficace et sûr du point de vue des types. Continuez à explorer les puissantes fonctionnalités de TypeScript pour améliorer vos compétences en programmation !