book

TypeScript efficace

by Dan Vanderkam

November 2024

Intermediate to advanced

264 pages

7h 6m

French

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

À qui s'adresse ce livrePourquoi j'ai écrit ce livreComment ce livre est organiséConventions dans les échantillons de code TypeScriptConventions typographiques utilisées dans ce livreUtiliser des exemples de codeApprentissage en ligne O'ReillyComment nous contacterRemerciements
Point 1 : comprendre les relations entre TypeScript et JavaScriptPoint 2 : connais les options Typescript que tu utilises.Point 3 : Comprendre que la génération de code est indépendante des typesPoint 4 : se familiariser avec le typage structurelPoint 5 : Limite l'utilisation de n'importe quel type de produit
Point 6 : Utilise ton éditeur pour interroger et explorer le système de typographiePoint 7 : Considère les types comme des ensembles de valeursItem 8 : Savoir dire si un symbole se trouve dans l'espace de type ou l'espace de valeurPoint 9 : Préférer les déclarations de type aux assertions de typePoint 10 : Éviter les types de wrappers d'objets (chaîne, nombre, booléen, symbole, BigInt)Point 11 : Reconnaître les limites du contrôle des biens excédentairesPoint 12 : Appliquer les types à des expressions de fonctions entières lorsque c'est possiblePoint 13 : Connaître les différences entre type et interfacePoint 14 : Utiliser les opérations de type et les génériques pour éviter de se répéterPoint 15 : Utiliser les signatures d'index pour les données dynamiquesPoint 16 : Préférer les tableaux, les n-uplets et les tableaux similaires aux signatures d'index numériquesPoint 17 : Utilise readonly pour éviter les erreurs associées à la mutationPoint 18 : Utiliser les types mappés pour garder les valeurs synchronisées
Point 19 : Évite d'encombrer ton code avec des types inférablesPoint 20 : Utilise des variables différentes pour des types différentsPoint 21 : Élargissement du type de compréhensionPoint 22 : Comprendre le rétrécissement des typesPoint 23 : Créer des objets en une seule foisPoint 24 : Sois cohérent dans ton utilisation des pseudonymesPoint 25 : Utilise des fonctions asynchrones plutôt que des rappels pour le code asynchroneItem 26 : Comprendre comment le contexte est utilisé dans l'inférence de typePoint 27 : Utiliser des constructions fonctionnelles et des bibliothèques pour faciliter le flux des types
Item 28 : Préférer les types qui représentent toujours des états validesPoint 29 : Sois libéral dans ce que tu acceptes et strict dans ce que tu produisPoint 30 : Ne pas répéter les informations de type dans la documentationPoint 31 : Repousse les valeurs nulles à la périphérie de tes typesItem 32 : Préférer les Unions d'Interfaces aux Interfaces d'UnionsPoint 33 : Préférer des alternatives plus précises aux types de chaînes de caractèresItem 34 : Préférer les types incomplets aux types inexactsPoint 35 : Générer des types à partir des API et des spécifications, pas des donnéesItem 36 : Nommer les types en utilisant le langage de ton domaine de problèmesPoint 37 : Envisager des "marques" pour les caractères nominaux
Point 38 : Utiliser le champ d'application le plus étroit possible pour tous les types de produitsItem 39 : Préférer des variantes plus précises de n'importe quel à un simple n'importe quelPoint 40 : Cacher les assertions de type non sûres dans les fonctions bien typéesItem 41 : Comprendre les évolutionsPoint 42 : Utilise inconnu au lieu de quelconque pour les valeurs dont le type est inconnuPoint 43 : Préférer les approches de sécurité de type pour le rapiéçage des singes.Point 44 : Suivre la couverture des types pour éviter les régressions dans la sécurité des types
Point 45 : mettre TypeScript et @types dans les devDependencies.Item 46 : Comprendre les trois versions impliquées dans les déclarations de typePoint 47 : Exporter tous les types qui apparaissent dans les API publiquesPoint 48 : Utiliser TSDoc pour les commentaires sur l'APIPoint 49 : Fournir un type pour cela dans les rappelsPoint 50 : Préférer les types conditionnels aux déclarations surchargéesPoint 51 : Types de miroirs pour supprimer les dépendancesPoint 52 : Sois conscient des pièges des types de tests
Point 53 : Préférer les fonctionnalités d'ECMAScript à celles de TypeScript.Item 54 : Savoir itérer sur les objetsPoint 55 : Comprendre la hiérarchie DOMPoint 56 : Ne compte pas sur le privé pour cacher des informationsPoint 57 : utiliser les cartes de source pour déboguer TypeScript.
Point 58 : Écrire du JavaScript modernePoint 59 : Utilise @ts-check et JSDoc pour expérimenter avec TypeScriptPoint 60 : utilise allowJs pour mélanger TypeScript et JavaScript.Point 61 : Convertir module par module ton graphique de dépendancePoint 62 : Ne considère pas la migration comme terminée tant que tu n'as pas activé noImplicitAny

Content preview from TypeScript efficace

Chapitre 7. Écrire et exécuter ton code

Cet ouvrage a été traduit à l'aide de l'IA. Tes réactions et tes commentaires sont les bienvenus : translation-feedback@oreilly.com

Ce chapitre est un peu un fourre-tout : il couvre certains problèmes qui se posent lors de l'écriture du code (et non des types) ainsi que des problèmes que tu peux rencontrer lors de l'exécution de ton code.

Point 53 : Préférer les fonctionnalités d'ECMAScript à celles de TypeScript.

La relation entre TypeScript et JavaScript a évolué au fil du temps. Lorsque Microsoft a commencé à travailler sur TypeScript en 2010, l'attitude dominante autour de JavaScript était qu'il s'agissait d'un langage problématique qui devait être corrigé. Il était courant que les frameworks et les compilateurs source à source ajoutent à JavaScript des fonctionnalités manquantes telles que des classes, des décorateurs et un système de modules. TypeScript n'était pas différent. Les premières versions comprenaient des versions maison de classes, d'enums et de modules.

Au fil du temps, le TC39, l'organisme de normalisation qui régit JavaScript, a ajouté un grand nombre de ces mêmes fonctionnalités au langage JavaScript de base. Et les fonctionnalités qu'ils ont ajoutées n'étaient pas compatibles avec les versions qui existaient dans TypeScript. L'équipe TypeScript s'est donc retrouvée dans une situation délicate : adopter les nouvelles fonctionnalités de la norme ou casser le code existant ?

TypeScript a largement choisi de faire ce dernier ...