Maîtriser la correspondance de modèles de TypeScript : augmentez la puissance et la sécurité de votre code

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 < 0) return "It's freezing!"
      return "The temperature is moderate."
    case 'wind':
      if (event.speed > 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!