Maîtriser TypeScript : du typage de base aux patterns avancés

Adopté massivement ces dernières années, TypeScript s'est imposé comme le standard de fait pour les applications JavaScript d'envergure. Mais beaucoup d'équipes l'utilisent en surface, en se limitant à annoter quelques variables. Or sa vraie puissance réside dans son système de types, capable d'exprimer des contrats riches et de détecter des erreurs bien avant l'exécution.

Le typage comme documentation vivante

Un type bien écrit raconte l'intention du code. Quand une fonction déclare précisément ce qu'elle attend et ce qu'elle retourne, elle devient auto-documentée : l'éditeur guide le développeur, l'autocomplétion devient fiable, et le refactoring cesse d'être un saut dans le vide.

Préférer les types stricts

Activer le mode strict n'est pas une contrainte mais un investissement. Il force à gérer les cas null et undefined explicitement, éliminant une catégorie entière de bugs courants en JavaScript.

Les génériques : du code réutilisable et typé

Les génériques permettent d'écrire des fonctions et des structures qui s'adaptent au type qu'on leur passe, tout en conservant la sécurité du typage. Une fonction générique qui prend un tableau et renvoie son premier élément saura, à l'usage, que le résultat a exactement le type des éléments du tableau — pas un type vague.

Un bon générique capture une relation entre les entrées et les sorties, là où un type figé ne ferait qu'imposer une forme.

Les types utilitaires

TypeScript fournit une boîte à outils de types prêts à l'emploi qui évitent de réécrire des structures :

• Partial rend toutes les propriétés optionnelles — idéal pour des mises à jour partielles.
• Pick et Omit dérivent un nouveau type à partir d'un existant, en sélectionnant ou retirant des champs.
• Record décrit un dictionnaire dont on connaît le type des clés et des valeurs.
• Readonly verrouille un objet contre les mutations accidentelles.

Dériver les types les uns des autres plutôt que de les dupliquer garantit qu'ils restent cohérents lorsque le modèle évolue.

Types conditionnels et inférence

Avec les types conditionnels, le système de types devient capable de raisonner : « si tel type correspond à telle forme, alors le résultat est ceci, sinon cela ». Combinés à l'inférence, ils permettent d'extraire des informations — le type de retour d'une fonction, le type des éléments d'une promesse — sans jamais les répéter à la main.

Discriminated unions : modéliser des états

L'un des patterns les plus utiles consiste à représenter un ensemble d'états mutuellement exclusifs par une union discriminée. Chaque variante porte un champ commun qui l'identifie. Le compilateur peut alors vérifier qu'on a bien traité tous les cas, et affiner automatiquement le type dans chaque branche.

Le bénéfice : l'exhaustivité

Si l'on ajoute un nouvel état et qu'on oublie de le gérer quelque part, TypeScript le signale immédiatement. C'est une garantie précieuse pour les machines à états, les réducteurs ou la gestion des requêtes (chargement, succès, erreur).

Conclusion

TypeScript récompense ceux qui investissent dans ses types. Au-delà du confort de l'autocomplétion, un typage soigné transforme le compilateur en allié : il valide les contrats, documente les intentions et rend les refactorings sûrs. Le secret n'est pas d'ajouter des types partout, mais de modéliser correctement le domaine — et de laisser le système de types travailler pour vous.