recherche
Maisoninterface Webjs tutorielMaîtriser la correspondance de modèles de TypeScript : augmentez la puissance et la sécurité de votre code

Mastering TypeScript

Les unions discriminées de TypeScript sont une fonctionnalité puissante qui fait passer la correspondance de modèles à un niveau supérieur. Ils nous permettent de créer une logique conditionnelle complexe et sécurisée qui va au-delà des simples instructions switch. J'ai beaucoup utilisé cette technique dans mes projets récents et elle a transformé ma façon d'aborder le flux de contrôle dans TypeScript.

Commençons par les bases. Une union discriminée est un type qui utilise une propriété commune pour distinguer différentes variantes. Voici un exemple simple :

type Shape =
  | { kind: 'circle'; radius: number }
  | { kind: 'rectangle'; width: number; height: number }

La propriété « gentille » ici est notre discriminant. Il permet à TypeScript de déduire à quelle forme spécifique nous avons affaire en fonction de sa valeur.

Voyons maintenant comment nous pouvons l'utiliser pour la correspondance de motifs :

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2
    case 'rectangle':
      return shape.width * shape.height
  }
}

C'est sympa, mais ce n'est que le début. Nous pouvons aller beaucoup plus loin.

L'un des aspects les plus puissants des syndicats discriminés est le contrôle de l'exhaustivité. TypeScript peut garantir que nous avons traité tous les cas possibles dans notre correspondance de modèles. Ajoutons une nouvelle forme à notre union :

type Shape =
  | { kind: 'circle'; radius: number }
  | { kind: 'rectangle'; width: number; height: number }
  | { kind: 'triangle'; base: number; height: number }

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2
    case 'rectangle':
      return shape.width * shape.height
    // TypeScript will now warn us that we're not handling the 'triangle' case
  }
}

Pour rendre cela encore plus robuste, nous pouvons ajouter un cas par défaut qui génère une erreur, garantissant ainsi de ne jamais oublier accidentellement de gérer un nouveau cas :

function assertNever(x: never): never {
  throw new Error("Unexpected object: " + x);
}

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2
    case 'rectangle':
      return shape.width * shape.height
    case 'triangle':
      return 0.5 * shape.base * shape.height
    default:
      return assertNever(shape)
  }
}

Maintenant, si jamais nous ajoutons une nouvelle forme sans mettre à jour notre fonction getArea, TypeScript nous donnera une erreur de compilation.

Mais on peut aller encore plus loin avec la correspondance de motifs. Regardons un exemple plus complexe impliquant des modèles imbriqués.

Imaginons que nous construisions une simple machine à états pour un feu de circulation :

type TrafficLightState =
  | { state: 'green' }
  | { state: 'yellow' }
  | { state: 'red' }
  | { state: 'flashing', color: 'yellow' | 'red' }

function getNextState(current: TrafficLightState): TrafficLightState {
  switch (current.state) {
    case 'green':
      return { state: 'yellow' }
    case 'yellow':
      return { state: 'red' }
    case 'red':
      return { state: 'green' }
    case 'flashing':
      return current.color === 'yellow'
        ? { state: 'red' }
        : { state: 'flashing', color: 'yellow' }
  }
}

Ici, nous ne faisons pas seulement correspondre l'état de niveau supérieur, mais également les propriétés imbriquées lorsque nous sommes dans l'état « clignotant ».

Nous pouvons également utiliser des gardes pour ajouter des conditions encore plus complexes à notre correspondance de modèles :

type WeatherEvent =
  | { kind: 'temperature', celsius: number }
  | { kind: 'wind', speed: number }
  | { kind: 'precipitation', amount: number }

function describeWeather(event: WeatherEvent): string {
  switch (event.kind) {
    case 'temperature':
      if (event.celsius > 30) return "It's hot!"
      if (event.celsius  100) return "There's a hurricane!"
      if (event.speed > 50) return "It's very windy."
      return "There's a gentle breeze."
    case 'precipitation':
      if (event.amount > 100) return "It's pouring!"
      if (event.amount > 0) return "It's raining."
      return "It's dry."
  }
}

Cette approche de correspondance de modèles ne se limite pas aux instructions switch. Nous pouvons l'utiliser avec des chaînes if-else, ou même avec des littéraux d'objet pour des scénarios plus complexes :

type Action =
  | { type: 'INCREMENT' }
  | { type: 'DECREMENT' }
  | { type: 'RESET' }
  | { type: 'SET', payload: number }

const reducer = (state: number, action: Action): number => ({
  INCREMENT: () => state + 1,
  DECREMENT: () => state - 1,
  RESET: () => 0,
  SET: () => action.payload,
}[action.type]())

Cette approche peut être particulièrement utile lors de la mise en œuvre du modèle de visiteur. Voici un exemple de la façon dont nous pourrions utiliser des syndicats discriminés pour mettre en œuvre un évaluateur d'expression simple :

type Expr =
  | { kind: 'number'; value: number }
  | { kind: 'add'; left: Expr; right: Expr }
  | { kind: 'multiply'; left: Expr; right: Expr }

const evaluate = (expr: Expr): number => {
  switch (expr.kind) {
    case 'number':
      return expr.value
    case 'add':
      return evaluate(expr.left) + evaluate(expr.right)
    case 'multiply':
      return evaluate(expr.left) * evaluate(expr.right)
  }
}

const expr: Expr = {
  kind: 'add',
  left: { kind: 'number', value: 5 },
  right: {
    kind: 'multiply',
    left: { kind: 'number', value: 3 },
    right: { kind: 'number', value: 7 }
  }
}

console.log(evaluate(expr))  // Outputs: 26

Ce modèle nous permet d'étendre facilement notre système d'expression avec de nouveaux types d'expressions, et TypeScript garantira que nous traitons tous les cas dans notre fonction d'évaluation.

L'un des aspects les plus puissants de cette approche est la manière dont elle nous permet de refactoriser des blocs conditionnels volumineux et complexes en structures plus gérables et extensibles. Regardons un exemple plus complexe :

Imaginez que nous construisions un système pour traiter différents types de transactions financières :

type Shape =
  | { kind: 'circle'; radius: number }
  | { kind: 'rectangle'; width: number; height: number }

Dans cet exemple, nous avons utilisé les types mappés et les types conditionnels de TypeScript pour créer un objet de type sécurisé où chaque clé correspond à un type de transaction et chaque valeur est une fonction qui traite ce type spécifique de transaction. Cette approche nous permet d'ajouter facilement de nouveaux types de transactions sans modifier la logique de base de notre fonction handleTransaction.

La beauté de ce modèle est qu'il est à la fois sécurisé et extensible. Si nous ajoutons un nouveau type de transaction, TypeScript nous obligera à ajouter une fonction de processeur correspondante. Si nous essayons de traiter un type de transaction qui n'existe pas, nous obtiendrons une erreur de compilation.

Cette approche de correspondance de modèles avec des unions discriminées peut conduire à un code TypeScript plus expressif, plus sûr et auto-documenté, en particulier dans les applications complexes. Cela nous permet de gérer une logique complexe d'une manière à la fois lisible et maintenable.

À mesure que nos applications deviennent de plus en plus complexes, ces techniques deviennent de plus en plus précieuses. Ils nous permettent d'écrire du code non seulement correct, mais également facile à comprendre et à modifier. En tirant pleinement parti du système de types de TypeScript, nous pouvons créer des systèmes robustes et flexibles avec lesquels il est agréable de travailler.

N'oubliez pas que l'objectif n'est pas seulement d'écrire du code qui fonctionne, mais d'écrire du code qui exprime clairement son intention et qui résiste aux erreurs à mesure que les exigences changent. La correspondance de modèles avec des syndicats discriminés est un outil puissant pour atteindre cet objectif.

D'après mon expérience, l'adoption de ces modèles a conduit à des améliorations significatives de la qualité du code et de la vitesse de développement. Il faut un certain temps pour s'habituer à penser en termes d'unions discriminées et de correspondance de modèles exhaustive, mais une fois que vous l'aurez fait, vous constaterez que cela ouvre de nouvelles possibilités pour structurer votre code de manière claire et sûre.

Alors que vous continuez à explorer TypeScript, je vous encourage à rechercher des opportunités d'appliquer ces modèles dans votre propre code. Commencez petit, peut-être en refactorisant une chaîne if-else complexe en une union discriminée. Au fur et à mesure que vous vous familiariserez avec la technique, vous commencerez à voir de plus en plus d'endroits où elle peut être appliquée pour simplifier et clarifier votre code.

N'oubliez pas que le véritable pouvoir de TypeScript ne réside pas seulement dans sa capacité à détecter les erreurs, mais aussi dans sa capacité à nous guider vers des structures de code meilleures et plus expressives. En adoptant des modèles tels que les unions discriminées et la correspondance de modèles exhaustive, nous pouvons créer un code qui est non seulement correct, mais aussi agréable à lire et à maintenir.


Nos créations

N'oubliez pas de consulter nos créations :

Centre des investisseurs | Vie intelligente | Époques & Échos | Mystères déroutants | Hindutva | Développeur Élite | Écoles JS


Nous sommes sur Medium

Tech Koala Insights | Epoques & Echos Monde | Support Central des Investisseurs | Mystères déroutants Medium | Sciences & Epoques Medium | Hindutva moderne

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Node.js diffuse avec dactylographieNode.js diffuse avec dactylographieApr 30, 2025 am 08:22 AM

Node.js excelle dans des E / S efficaces, en grande partie grâce aux flux. Streams traite les données progressivement, en évitant la surcharge de mémoire - idéal pour les fichiers volumineux, les tâches réseau et les applications en temps réel. Combiner les flux avec la sécurité de type dactylographié crée un powe

Python vs JavaScript: considérations de performance et d'efficacitéPython vs JavaScript: considérations de performance et d'efficacitéApr 30, 2025 am 12:08 AM

Les différences de performance et d'efficacité entre Python et JavaScript se reflètent principalement dans: 1) comme un langage interprété, Python fonctionne lentement mais a une efficacité de développement élevée et convient au développement rapide des prototypes; 2) JavaScript est limité au thread unique dans le navigateur, mais les E / S multi-threading et asynchrones peuvent être utilisées pour améliorer les performances dans Node.js, et les deux ont des avantages dans les projets réels.

Les origines de JavaScript: explorer son langage d'implémentationLes origines de JavaScript: explorer son langage d'implémentationApr 29, 2025 am 12:51 AM

JavaScript est originaire de 1995 et a été créé par Brandon Ike, et a réalisé que la langue en langue C. 1.C offre des capacités de programmation élevées et au niveau du système pour JavaScript. 2. La gestion de la mémoire de JavaScript et l'optimisation des performances reposent sur le langage C. 3. La fonctionnalité multiplateforme du langage C aide JavaScript à s'exécuter efficacement sur différents systèmes d'exploitation.

Dans les coulisses: quel langage alimente JavaScript?Dans les coulisses: quel langage alimente JavaScript?Apr 28, 2025 am 12:01 AM

JavaScript s'exécute dans les navigateurs et les environnements Node.js et s'appuie sur le moteur JavaScript pour analyser et exécuter du code. 1) Générer une arborescence de syntaxe abstraite (AST) au stade d'analyse; 2) Convertir AST en bytecode ou code machine à l'étape de compilation; 3) Exécutez le code compilé à l'étape d'exécution.

L'avenir de Python et Javascript: tendances et prédictionsL'avenir de Python et Javascript: tendances et prédictionsApr 27, 2025 am 12:21 AM

Les tendances futures de Python et JavaScript incluent: 1. Python consolidera sa position dans les domaines de l'informatique scientifique et de l'IA, 2. JavaScript favorisera le développement de la technologie Web, 3. Le développement de plate-forme multiplié deviendra un sujet brûlant, et 4. L'optimisation des performances sera le focus. Les deux continueront d'étendre les scénarios d'application dans leurs champs respectifs et de faire plus de percées dans les performances.

Python vs JavaScript: environnements et outils de développementPython vs JavaScript: environnements et outils de développementApr 26, 2025 am 12:09 AM

Les choix de Python et JavaScript dans les environnements de développement sont importants. 1) L'environnement de développement de Python comprend Pycharm, Jupyternotebook et Anaconda, qui conviennent à la science des données et au prototypage rapide. 2) L'environnement de développement de JavaScript comprend Node.js, VScode et WebPack, qui conviennent au développement frontal et back-end. Le choix des bons outils en fonction des besoins du projet peut améliorer l'efficacité du développement et le taux de réussite du projet.

JavaScript est-il écrit en C? Examiner les preuvesJavaScript est-il écrit en C? Examiner les preuvesApr 25, 2025 am 12:15 AM

Oui, le noyau du moteur de JavaScript est écrit en C. 1) Le langage C fournit des performances efficaces et un contrôle sous-jacent, qui convient au développement du moteur JavaScript. 2) Prendre le moteur V8 comme exemple, son noyau est écrit en C, combinant l'efficacité et les caractéristiques orientées objet de C. 3) Le principe de travail du moteur JavaScript comprend l'analyse, la compilation et l'exécution, et le langage C joue un rôle clé dans ces processus.

Rôle de JavaScript: rendre le Web interactif et dynamiqueRôle de JavaScript: rendre le Web interactif et dynamiqueApr 24, 2025 am 12:12 AM

JavaScript est au cœur des sites Web modernes car il améliore l'interactivité et la dynamicité des pages Web. 1) Il permet de modifier le contenu sans rafraîchir la page, 2) manipuler les pages Web via Domapi, 3) prendre en charge les effets interactifs complexes tels que l'animation et le glisser-déposer, 4) Optimiser les performances et les meilleures pratiques pour améliorer l'expérience utilisateur.

See all articles

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover

AI Clothes Remover

Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

Video Face Swap

Video Face Swap

Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Outils chauds

Navigateur d'examen sécurisé

Navigateur d'examen sécurisé

Safe Exam Browser est un environnement de navigation sécurisé permettant de passer des examens en ligne en toute sécurité. Ce logiciel transforme n'importe quel ordinateur en poste de travail sécurisé. Il contrôle l'accès à n'importe quel utilitaire et empêche les étudiants d'utiliser des ressources non autorisées.

Version crackée d'EditPlus en chinois

Version crackée d'EditPlus en chinois

Petite taille, coloration syntaxique, ne prend pas en charge la fonction d'invite de code

SublimeText3 Linux nouvelle version

SublimeText3 Linux nouvelle version

Dernière version de SublimeText3 Linux

SublimeText3 version Mac

SublimeText3 version Mac

Logiciel d'édition de code au niveau de Dieu (SublimeText3)

PhpStorm version Mac

PhpStorm version Mac

Le dernier (2018.2.1) outil de développement intégré PHP professionnel