Points clés
Considérez TypeScript comme un modèle vérifié de JavaScript, et non comme une armure à l’exécution
Les types disparaissent à l’exécution. TypeScript accepte la syntaxe JavaScript et lui ajoute un vérificateur statique. Son compilateur supprime les types et produit du JavaScript: les types ne peuvent donc ni convertir des données, ni valider une réponse réseau, ni empêcher une exception à l’exécution. Un programme peut même produire du JavaScript tout en signalant des erreurs de typage, sauf si la compilation est configurée pour refuser toute sortie en cas d’erreur.
La frontière reste poreuse. TypeScript modélise le comportement de JavaScript, mais son système de types n’est pas entièrement sûr. L’accès à un indice hors limites d’un tableau peut passer la vérification, et une déclaration concernant une réponse d’API ne prouve pas que cette réponse est conforme. Le vérificateur est un puissant détecteur d’erreurs, pas une garantie que chaque valeur à l’exécution correspond au type qui lui est déclaré.
La distinction entre décrire une valeur et la vérifier est essentielle pour bien utiliser ce langage. Une annotation de type consigne une attente ; elle ne prouve pas que cette attente est satisfaite à une frontière externe. TypeScript est donc le plus utile lorsque ses affirmations s’appuient sur du code que le projet maîtrise, et le moins fiable lorsqu’une assertion tient lieu de preuve. Considérer le vérificateur comme un réviseur plutôt que comme une barrière de sécurité permet d’en tirer parti sans lui attribuer des pouvoirs qu’il n’a pas.
Choisissez délibérément des options de compilation strictes, puis appliquez-les uniformément dans l’équipe
La configuration modifie le langage. Les options du compilateur déterminent les erreurs que TypeScript peut repérer; deux développeurs peuvent donc obtenir des résultats différents avec le même code. Consignez ces choix dans `tsconfig.json`, plutôt que de les laisser dans une commande qu’il faut penser à exécuter. Pour les nouveaux projets, activez `noImplicitAny`, qui signale les paramètres et variables qui prendraient silencieusement le type `any` autrement.
Rendez les valeurs nulles explicites. `strictNullChecks` empêche `null` et `undefined` d’être considérés comme des valeurs ordinaires de tous les types. Une recherche dans le DOM, par exemple, peut ne renvoyer aucun élément: le code doit donc vérifier cette possibilité ou l’écarter explicitement par une assertion. Le livre recommande de viser `strict: true` pour une vérification approfondie, tout en reconnaissant que les projets anciens ou en cours de migration peuvent devoir adopter les options plus strictes par étapes.
La configuration du compilateur est un accord d’équipe sur ce qui constitue un défaut. La conserver dans le dépôt rend cet accord consultable et reproductible, au lieu de le faire dépendre des éditeurs ou de la mémoire de chacun. Une vérification plus stricte exige toutefois du travail : il faut traiter les cas nuls, et le code ancien peut en révéler beaucoup d’un coup. La question pratique n’est pas de savoir s’il y aura des frictions, mais si l’équipe adopte les vérifications assez tôt pour qu’elles restent gérables.
Raisonnez en ensembles de valeurs et rappelez-vous que les types d’objets structurels sont ouverts
Les types décrivent des valeurs possibles. On peut comprendre un type comme un ensemble: `string` contient des chaînes, tandis que `'red' | 'blue'` n’autorise que ces deux valeurs. La compatibilité d’affectation signifie qu’une valeur appartient à un type, ou que l’ensemble d’un type est inclus dans celui d’un autre. Cette perspective aide à comprendre les unions, les intersections et les contraintes génériques sans traiter chaque type comme une classe dans une hiérarchie.
La forme suffit. TypeScript utilise le typage structurel: un objet correspond à une interface s’il possède les propriétés requises avec des types compatibles, même s’il en a d’autres ou n’a jamais été déclaré comme implémentant cette interface. Cette souplesse rend les objets factices simples utiles pour les tests. Elle peut aussi masquer des erreurs: un vecteur 3D peut être transmis à une fonction qui ne mesure que ses coordonnées x et y. La vérification des littéraux d’objet détecte certaines fautes de frappe, mais elle ne ferme pas les types.
La compatibilité structurelle convient bien à JavaScript, où les objets sont régulièrement assemblés sans relations formelles entre classes. En contrepartie, une interface indique généralement ce qu’une valeur doit contenir, et non tout ce qu’elle peut contenir. Cette distinction importe lorsqu’une fonction parcourt les clés ou suppose qu’une valeur 2D n’a pas de troisième coordonnée. Les interfaces de test restreintes exploitent cette même ouverture de manière constructive, en réduisant la dépendance à des objets de production complexes.
Laissez l’inférence gérer les variables locales, mais déclarez les contrats dont dépendent les appelants
Évitez les annotations superflues. TypeScript peut généralement inférer le type des variables locales à partir de leurs valeurs; répéter `number` à côté d’une initialisation numérique ne fait donc qu’ajouter du bruit. Les paramètres de fonction et les interfaces publiques demandent des indications plus explicites. Un type de retour peut détecter une erreur dans la fonction même, au lieu de laisser un type inféré incorrect surprendre ses appelants. Annoter un littéral d’objet peut également signaler un champ mal orthographié ou inattendu au moment où l’objet est créé.
Les assertions ne sont pas des déclarations. Une déclaration demande au vérificateur de s’assurer qu’une valeur correspond à un type. Une assertion lui demande de faire confiance au programmeur et peut masquer une incompatibilité. N’utilisez des assertions que si des éléments pertinents existent en dehors du système de types, par exemple si vous savez qu’un élément DOM donné est un bouton. Si le type inféré d’une valeur est trop large, demandez-vous si `const`, une annotation de type ou une assertion de constance exprime mieux la stabilité voulue.
La distinction utile ne sépare pas les lignes typées des lignes non typées, mais les informations que le compilateur peut inférer des décisions que le code doit rendre explicites. Les variables locales inférées préservent la lisibilité de l’implémentation ; les signatures déclarées rendent visibles et stables les promesses entre fonctions. Les assertions doivent satisfaire à des exigences plus élevées, car elles remplacent une vérification par la confiance. Une base de code rigoureuse utilise donc moins d’annotations au total, mais les place là où une inférence erronée fausserait une interface ou induirait un appelant en erreur.
Représentez directement les états valides au lieu de laisser chaque fonction deviner
Éliminez les combinaisons impossibles. Un modèle de page composé de champs distincts `isLoading`, `error` et de contenu peut autoriser des états contradictoires, comme un chargement en cours et un échec simultané. Une union discriminée représente plutôt des résultats distincts, par exemple en attente, erreur ou réussite, et la vérification du discriminant permet de restreindre les champs disponibles. On parle aussi d’union étiquetée.
L’ambiguïté peut coûter cher. Le livre évoque le vol Air France 447, dont les commandes distinctes des pilotes pouvaient envoyer des signaux contradictoires qu’un système moyennait. La leçon pour la conception logicielle est que certaines entrées rendent toute décision fiable impossible. Regroupez les valeurs qui vont ensemble, représentez les données facultatives sous la forme d’un seul objet facultatif lorsque c’est pertinent, et faites en sorte qu’une valeur soit soit entièrement absente, soit complète. Les types qui en résultent peuvent être plus longs, mais les fonctions ont moins de suppositions à faire et moins de branches défensives à gérer.
Ce principe de conception fait de la modélisation des données une forme de prévention des erreurs. Lorsqu’un type exclut les combinaisons contradictoires, chaque consommateur hérite d’un problème de décision plus simple. L’histoire de l’avion rend les enjeux saisissants, même si les exemples logiciels ne sont pas équivalents aux systèmes de commande de vol et qu’un type ne peut empêcher toutes les défaillances opérationnelles. L’idée transposable est plus circonscrite et solide : des entrées ambiguës imposent à chaque fonction qui les reçoit des choix de politique implicites.
Confinez `any` et utilisez `unknown` tant que la réalité n’a pas été vérifiée
`any` désactive les garde-fous. Il permet aux valeurs de franchir les frontières entre types sans vérification, prive d’une aide utile de l’éditeur et peut masquer des bogues lors d’une refactorisation. Si une seule expression a vraiment besoin d’une échappatoire, limitez l’assertion à cette expression au lieu de changer le type d’une variable pour toute sa durée de vie. Évitez de renvoyer `any` depuis une fonction: ses appelants hériteraient de cette incertitude, qui pourrait se propager dans tout le programme.
Utilisez le `unknown`, plus sûr. `unknown` accepte une valeur dont le type n’a pas été établi, mais empêche l’accès aux propriétés ou les appels de fonction tant que le code n’a pas vérifié ou affirmé un type plus précis. Un analyseur de texte externe peut, par exemple, renvoyer `unknown` plutôt que de prétendre que son résultat est un objet particulier. Si des détails d’implémentation non sûrs sont inévitables, le livre recommande de les confiner dans une petite fonction dotée d’une signature claire et vérifiée.
La différence entre any et unknown tient à la personne qui doit apporter la preuve. Avec any, l’incertitude disparaît du vérificateur de types tout en restant dans le programme. Avec unknown, elle demeure visible jusqu’à ce que quelqu’un la dissipe. unknown convient donc mieux aux données réellement non fiables ou non examinées. Cette contrainte est utile précisément parce qu’elle est gênante : elle oblige à traiter l’incertitude là où elle compte.
Utilisez des types métier précis plutôt que des chaînes qui prétendent signifier davantage
Restreignez le vocabulaire. Si un champ n’accepte qu’un petit ensemble d’étiquettes, représentez cet ensemble avec des types littéraux de chaîne plutôt qu’avec `string`. Pour un album, `recordingType` pourrait n’autoriser que `live` ou `studio`; un `Date` est également plus explicite qu’une chaîne dont le format n’existe que dans un commentaire. Pour une fonction qui lit une propriété, `keyof T` peut limiter l’argument aux clés réelles et préserver le type de la propriété sélectionnée.
Nommez honnêtement les concepts. Des types spécialisés peuvent distinguer des valeurs qui partagent une représentation primitive, par exemple un chemin absolu ou une mesure avec ses unités. Ces types marqués approchent le typage nominal, où l’identité compte au-delà de la forme, même si des assertions peuvent les contourner. La précision a ses limites: un type détaillé qui représente mal un format réel peut être pire qu’un type incomplet. Lorsqu’elles existent, dérivez les types d’une API formelle ou d’une spécification de données plutôt que de quelques exemples d’enregistrements.
Un type précis ne se contente pas de rejeter les entrées incorrectes. Il préserve le sens à mesure que les valeurs circulent entre les fonctions et aide les éditeurs à présenter les choix possibles. Mais la précision n’a de valeur que si elle est exacte. Un type élaboré qui exclut des cas légitimes pousse les utilisateurs vers les assertions et affaiblit la confiance dans toutes les vérifications. Le bon objectif n’est pas le détail maximal, mais la représentation la plus claire que les éléments disponibles permettent d’étayer.
Acceptez des entrées souples, renvoyez des sorties canoniques et veillez à la véracité des types
Rendez les API pratiques à appeler. Une fonction peut raisonnablement accepter plusieurs formats de coordonnées ou des paramètres facultatifs. Son résultat devrait généralement être plus uniforme: si une fonction de réglage de caméra accepte plusieurs formats de coordonnées, une fonction auxiliaire qui calcule une caméra devrait renvoyer un seul format complet et canonique. Sinon, chaque appelant doit gérer les mêmes différentes possibilités.
Réutilisez les types sans masquer la réalité. Les génériques et les types mappés permettent de dériver des formes apparentées au lieu de dupliquer les champs à la main. `Pick`, `Partial` et `ReturnType` en sont des exemples courants. Préférez une union d’interfaces complètes lorsque les champs doivent varier ensemble, plutôt que des unions indépendantes qui autorisent des combinaisons absurdes. Utilisez `readonly` pour les entrées qu’une fonction ne modifiera pas, et construisez les objets de manière à ce que le vérificateur puisse en voir la forme complète. Pour les opérations asynchrones, les fonctions `async` et les méthodes de tableau typées permettent souvent aux types de circuler plus clairement qu’une logique de rappels construite à la main.
Une API est plus facile à utiliser lorsque sa souplesse se concentre à la périphérie et que son vocabulaire interne reste cohérent. Les sorties canoniques réduisent le travail de conversion, tandis que les types mappés aident à synchroniser les déclarations apparentées à mesure que la base de code évolue. Le même principe favorise les entrées immuables et les opérations asynchrones composables : des contrats explicites laissent moins de place aux suppositions. La souplesse n’est toutefois pas gratuite. Chaque représentation acceptée doit répondre à un besoin réel, faute de quoi elle devient une complexité permanente pour les appelants comme pour les responsables de la maintenance.
Utilisez les outils et les idiomes de TypeScript pour faire circuler l’information de type
Faites de l’éditeur un outil d’apprentissage. Survolez les valeurs pour examiner l’inférence, suivez les définitions jusque dans les déclarations de bibliothèques et utilisez le TypeScript Playground pour voir ce qui est effacé lors de la compilation. Ces outils aident à comprendre les erreurs déroutantes et révèlent la différence entre un type et une valeur à l’exécution. Les cartes de sources permettent de déboguer le TypeScript d’origine même lorsque le JavaScript généré a été transformé.
Traitez les déclarations comme du code produit. Le livre conseille de placer TypeScript et les paquets `@types` dans les dépendances de développement, et de vérifier la compatibilité de la bibliothèque, de ses déclarations et du compilateur TypeScript. Exportez les types utilisés dans les API publiques, documentez-les avec TSDoc visible dans l’éditeur et testez soigneusement les déclarations, car les vérifications de compatibilité d’affectation peuvent laisser passer des erreurs. Privilégiez autant que possible les fonctionnalités standard de JavaScript, puisque la principale contribution de TypeScript est censée résider dans le système de types.
La valeur pratique du langage ne tient pas seulement au rejet des erreurs, mais aussi à la facilité avec laquelle il permet de parcourir, modifier et expliquer le code. Les services de l’éditeur et des déclarations fiables étendent ces avantages à toute l’équipe et aux frontières des bibliothèques. La maintenance des dépendances fait donc aussi partie de la sûreté des types : une déclaration décrit une API de bibliothèque donnée, et non une promesse abstraite qui resterait exacte pour toujours. De bons outils amplifient la fiabilité des types, mais ne peuvent pas corriger une déclaration qui décrit le mauvais comportement.
Migrez en remontant depuis les feuilles de dépendances, puis terminez en activant noImplicitAny
Procédez par étapes. Pour un grand projet JavaScript, modernisez la syntaxe et les modules, intégrez TypeScript à la compilation et aux tests, puis utilisez `allowJs` pour faire coexister JavaScript et TypeScript. Convertissez les modules en partant du bas du graphe de dépendances et en remontant, en commençant par les déclarations tierces et le code qui a peu de dépendances. Faites porter la migration sur l’ajout de types, plutôt que sur des refactorisations sans rapport.
Ne confondez pas conversion et aboutissement. `@ts-check` peut faire apparaître les premiers problèmes dans du JavaScript, tandis que la couverture explicite des types peut révéler les occurrences de `any` introduites par des annotations ou des déclarations tierces. Le livre cite une étude de 2017 qui estimait que TypeScript aurait pu prévenir 15 % des bogues corrigés dans des projets JavaScript, ainsi qu’une analyse rétrospective publiée par Airbnb, selon laquelle 38 % des incidents auraient pu être évités. L’étape finale consiste à activer `noImplicitAny`, puis à envisager des vérifications plus strictes lorsque l’équipe est prête.
Une migration progressive est une stratégie d’ingénierie, pas une concession qui rendrait l’objectif facultatif. Convertir d’abord les modules ayant peu de dépendances limite le nombre de parties du système à modifier lorsqu’un type devient explicite. Reporter le nettoyage sans rapport avec la migration évite aussi que celle-ci déborde de son objectif initial. Les pourcentages cités sont une motivation utile, mais ce sont des estimations tirées d’échantillons particuliers, et non des prévisions applicables à toutes les bases de code. Des mesures locales et une application progressive des règles constituent un plan plus solide que des statistiques empruntées seules.
Analyse
La contribution la plus profonde du livre est une présentation pratique des domaines où les types statiques méritent la confiance, et de ceux où cette confiance doit s’arrêter. TypeScript est précieux parce que son modèle peut rendre visibles les contrats implicites de JavaScript, améliorer l’assistance de l’éditeur et détecter des incohérences avant l’exécution. Ce n’est pas un vérificateur à l’exécution: ses déclarations disparaissent, ses règles de compatibilité sont volontairement pragmatiques, et les assertions peuvent inspirer confiance sans preuve. La conception des types, et non le volume d’annotations, est donc la compétence centrale.
Le geste de conception le plus récurrent et le plus efficace consiste à réduire l’ambiguïté à sa source. Une union discriminée remplace des indicateurs contradictoires par des états distincts. Un type de retour canonique évite aux appelants de gérer plusieurs représentations équivalentes. Un type métier restreint empêche de permuter deux chaînes sans rapport. Ces choix réduisent le nombre de décisions que chaque fonction en aval doit prendre. C’est une manière de localiser la complexité dans un logiciel.
On peut utilement aller plus loin en distinguant les garanties internes des faits externes. Dans un programme maîtrisé, un type bien conçu peut servir de contrat vérifiable. Mais à la frontière d’un réseau, d’un fichier ou d’une saisie utilisateur, une forme déclarée n’est qu’une hypothèse tant que la valeur n’a pas été vérifiée. La validation à l’exécution et le typage statique résolvent des problèmes différents: la première établit ce qui est arrivé, le second aide à préserver cette connaissance dans le code qui suit. Les considérer comme complémentaires évite à la fois l’excès de confiance et le faux choix entre sûreté et souplesse.
Le livre plaide également pour la retenue. Des types plus élaborés ne sont pas automatiquement meilleurs; une précision fallacieuse peut rendre les programmes valides difficiles à écrire et inciter aux assertions, qui effacent les avantages du typage. Le meilleur type n’est pas l’expression la plus astucieuse acceptée par le compilateur. C’est le modèle exact le plus simple qui clarifie l’intention, détecte les erreurs significatives et reste utilisable par les personnes chargées de sa maintenance.
Résumé des avis
Effective TypeScript est vivement salué pour sa couverture exhaustive des concepts de TypeScript, des bases aux sujets avancés. Les lecteurs apprécient ses explications claires, ses exemples pratiques et ses éclairages sur le système de types de TypeScript. Beaucoup l’ont trouvé utile aussi bien aux débutants qu’aux développeurs expérimentés, et soulignent sa contribution à l’amélioration des pratiques de programmation. La structure du livre, composée de conseils concis, en facilite la consultation. Si certains lecteurs ont estimé que certaines sections étaient moins pertinentes ou dépassées, la plupart s’accordent à dire qu’il s’agit d’une ressource essentielle pour maîtriser TypeScript et améliorer ses compétences en développement JavaScript.
Les lecteurs ont aussi lu
Glossaire
typage structurel
Compatibilité par la formeSystème de compatibilité des types dans lequel une valeur est acceptée lorsqu’elle possède les propriétés requises avec des types compatibles. La valeur n’a pas besoin d’être explicitement déclarée comme implémentant une interface, et elle peut contenir des propriétés supplémentaires. Cela reflète le modèle d’objets flexible de JavaScript, mais signifie que les types d’objets sont généralement ouverts plutôt que scellés.
vérification des propriétés excédentaires
Détection des fautes dans les littéraux d’objetVérification supplémentaire de TypeScript appliquée lorsqu’un littéral d’objet est affecté à un type déclaré ou passé directement comme argument. Elle peut signaler des noms de propriétés non reconnus que l’assignabilité structurelle ordinaire autoriserait. Il ne s’agit pas d’une règle générale qui scelle les types d’objets, et le fait de déplacer un littéral d’objet dans une variable intermédiaire peut éviter cette vérification particulière.
union discriminée
Ensemble étiqueté de possibilitésUnion de types qui comportent chacun une propriété commune ayant des valeurs littérales distinctes. La vérification de cette propriété identifie la possibilité présente et permet à TypeScript de réduire les champs disponibles. Par exemple, les états d’une requête peuvent être représentés par les variantes en attente, erreur ou succès, plutôt que par plusieurs indicateurs indépendants qui autorisent des combinaisons contradictoires.
élargissement de type
Inférence vers des types plus largesProcessus par lequel TypeScript infère un type plus large à partir d’une valeur initiale lorsqu’une variable peut changer par la suite. Une variable modifiable initialisée avec une chaîne littérale est généralement inférée comme étant de type string, et non comme étant uniquement de ce littéral. const, les annotations explicites, le contexte et les assertions const peuvent influer sur le degré de précision de l’inférence d’une valeur.
any évolutif (evolving any)
Un any implicite gagne en précisionComportement d’inférence de TypeScript selon lequel certaines variables typées implicitement commencent avec un type proche de any et deviennent plus précises à mesure que des valeurs leur sont affectées ou ajoutées. Un tableau initialement vide, par exemple, peut acquérir un type d’élément lorsque des valeurs y sont ajoutées. Ce comportement diffère d’une annotation explicite de variable en any, qui ne gagne pas cette précision.
unknown
Type d’une valeur non vérifiéeType d’une valeur qui existe, mais dont le type précis n’a pas encore été établi. Toute valeur peut être affectée à unknown, mais une valeur unknown ne peut pas être utilisée librement comme un autre type. Le programme doit en réduire le type au moyen de vérifications ou recourir à une assertion explicite, afin que l’incertitude reste visible au lieu de désactiver la vérification comme le fait any.
FAQ
De quoi parle Effective TypeScript ?
- Amélioration des compétences : Effective TypeScript de Dan Vanderkam est un guide conçu pour développer vos compétences en TypeScript au moyen de 62 stratégies précises.
- Conseils pratiques : Il propose des recommandations concrètes et applicables aux développeurs ayant déjà une certaine expérience de JavaScript et de TypeScript, afin de faire progresser leur expertise.
- Pièges courants : Le livre aborde les pièges et erreurs fréquents, aidant les lecteurs à acquérir une solide compréhension de TypeScript et de son écosystème.
Pourquoi lire Effective TypeScript ?
- Développement des compétences : Le livre aide à passer du niveau débutant ou intermédiaire à celui d’expert en TypeScript, en améliorant les pratiques de programmation et la compréhension du langage.
- Recettes pratiques : Il propose des conseils et des méthodes concrètes que l’on peut appliquer directement à son travail, ce qui le rend utile aux développeurs débutants comme chevronnés.
- Compréhension approfondie : Il offre des éclairages sur les puissantes fonctionnalités de TypeScript, afin de vous aider à écrire du code plus sûr et plus efficace.
Quels sont les principaux enseignements d’Effective TypeScript ?
- 62 méthodes précises : Le livre présente 62 façons d’améliorer son usage de TypeScript, des bases de la syntaxe à la manipulation avancée des types.
- Orientation pratique : Chaque point propose des conseils applicables au travail quotidien, faisant de l’ouvrage un guide pratique.
- Relations entre les types : Comprendre la relation entre TypeScript et JavaScript, ainsi que la manière dont TypeScript modélise le comportement de JavaScript à l’exécution, constitue un enseignement important.
Comment Effective TypeScript aborde-t-il la sûreté des types ?
- Annotations de type : Il met l’accent sur l’utilisation des annotations de type pour assurer la sûreté des types et détecter les erreurs à la compilation plutôt qu’à l’exécution.
- Vérifications strictes des valeurs nulles : Il préconise d’activer les vérifications strictes des valeurs nulles afin de repérer les valeurs potentiellement nulles ou indéfinies, pour obtenir un code plus sûr.
- Génériques : Il souligne l’intérêt des génériques pour créer des composants réutilisables et sûrs du point de vue des types, en maintenant cette sûreté avec différents types.
Quelle est l’importance de l’inférence des types dans Effective TypeScript ?
- Détection automatique : L’inférence des types permet à TypeScript de déterminer automatiquement les types des variables, réduisant ainsi le besoin d’annotations explicites.
- Compréhension du contexte : Le livre souligne que TypeScript utilise le contexte pour inférer les types, ce qui peut surprendre si l’on ne comprend pas bien ce mécanisme.
- Éviter les redondances : Comprendre l’inférence des types permet d’éviter les annotations superflues et de privilégier un code clair et concis.
Comment Effective TypeScript recommande-t-il de gérer les propriétés facultatives ?
- Utilisation des propriétés facultatives : Le livre explique comment définir des propriétés susceptibles d’être présentes ou absentes, ce qui est utile pour modéliser des situations réelles.
- Éviter l’ambiguïté : Il insiste sur l’importance de traiter clairement les cas où les propriétés facultatives ne sont pas fournies.
- Sûreté des types : Il encourage à utiliser le système de types de TypeScript pour imposer des vérifications sur les propriétés facultatives et garantir un code robuste.
Comment Effective TypeScript recommande-t-il de structurer les types pour représenter des états valides ?
- Concevoir des états valides : Le livre insiste sur la conception de types qui ne représentent que des états valides, afin de prévenir les erreurs et de faciliter la compréhension du code.
- Unions discriminées : Il suggère d’utiliser des unions discriminées pour modéliser explicitement différents états et garantir des transitions d’état bien définies.
- Éviter les combinaisons invalides : Structurer les types de façon à éviter les combinaisons invalides simplifie la logique et réduit les erreurs à l’exécution.
Que sont les unions discriminées et pourquoi sont-elles importantes dans Effective TypeScript ?
- Définition : Les unions discriminées, aussi appelées unions étiquetées, définissent un type qui peut correspondre à plusieurs types, chacun ayant une propriété « étiquette » commune.
- Sûreté des types : Elles améliorent la sûreté des types en garantissant que seules des combinaisons de propriétés valides sont autorisées, évitant ainsi les erreurs dues à des états invalides.
- Exemples pratiques : Le livre propose des exemples d’implémentation d’unions discriminées, qui aident à gérer des structures de données complexes et le flux de contrôle.
Comment Effective TypeScript aborde-t-il l’utilisation du type any ?
- Limiter l’utilisation de
any: Il déconseille d’abuser deany, car ce type réduit au silence le vérificateur de types et peut masquer de vrais problèmes. - Privilégier les types précis : Il recommande d’utiliser des types précis qui représentent fidèlement les données, afin d’améliorer la lisibilité et la maintenabilité.
- Comprendre les risques : Il met en évidence les risques de
any, comme la rupture des contrats des signatures de fonction et la perte des avantages du système de types.
Quelles méthodes et recommandations concrètes trouve-t-on dans Effective TypeScript ?
- Intégrer les valeurs nulles : Le livre conseille de structurer les types pour gérer proprement les valeurs nulles, ce qui améliore la lisibilité et réduit les erreurs.
- Éviter
any: Il déconseille fortement les typesanyet suggère des types plus précis ouunknownpour préserver la sûreté des types. - Utiliser JSDoc : Il recommande les commentaires de documentation de type JSDoc, qui améliorent l’expérience des développeurs grâce à de meilleures infobulles et à une documentation plus utile.
Comment améliorer mon code TypeScript grâce à Effective TypeScript ?
- Suivre les 62 recommandations : Les 62 points du livre proposent des conseils concrets pour améliorer progressivement ses compétences en TypeScript et la qualité de son code.
- S’exercer avec des exemples : Mettre en pratique les concepts dans des projets réels permet de consolider sa compréhension et d’assimiler les bonnes pratiques.
- Participer à la communauté : Le livre encourage à prendre part à la communauté TypeScript pour obtenir d’autres éclairages et du soutien.
Quelles sont les meilleures citations d’Effective TypeScript et que signifient-elles ?
- « TypeScript est un surensemble de JavaScript. » : Cette phrase souligne la relation fondamentale entre les deux langages et facilite l’adoption progressive de TypeScript.
- « Évitez d’utiliser
any. » : Elle met en garde contre les pièges du typeany, qui compromettent les avantages du système de types de TypeScript. - « Concevez des types qui ne représentent que des états valides. » : Elle encourage à créer des types qui empêchent les états invalides, simplifiant la logique et réduisant les erreurs.
Télécharger le PDF
Télécharger l'EPUB
.epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.