Tables de décision dans TypeScript : un modèle sous-estimé pour un code plus propre

Lors de la création de systèmes logiciels complexes, les développeurs ont souvent recours à de longues instructions if-else ou switch pour gérer la logique de prise de décision.

Bien que ces approches puissent fonctionner, elles deviennent rapidement ingérables à mesure que le nombre de conditions augmente. C'est là qu'interviennent les tables de décision.

Un modèle puissant mais sous-utilisé qui simplifie la prise de décision complexe de manière propre et maintenable.

Dans cet article, nous explorerons ce que sont les tables de décision, pourquoi vous devriez les utiliser et comment les implémenter dans TypeScript pour gérer facilement une logique complexe.

Qu'est-ce qu'une table de décision ?

Une table de décision est un moyen structuré de mapper diverses combinaisons de conditions d'entrée aux actions ou résultats correspondants. Considérez-le comme un tableau dans lequel chaque ligne représente une combinaison unique de variables d'entrée et la colonne correspondante définit la sortie ou l'action. Cela vous permet de visualiser tous les scénarios possibles en un seul endroit, ce qui facilite la gestion et la compréhension.

Par exemple, disons que vous créez une plate-forme de commerce électronique et que vous devez envoyer différents modèles d'e-mails aux utilisateurs en fonction de leur statut de client, de leur historique d'achat, des promotions disponibles et de leur langue préférée.

Avec 3 variables booléennes (isGoldCustomer, isFirstPurchase, isPromoAvailable) et une variable enum (emailLanguage), il y a 24 combinaisons possibles à gérer.

Mais au lieu d'écrire 24 cas if-else ou switch, une table de décision fournit une solution plus propre.

Pourquoi utiliser des tables de décision ?

Les tables de décision offrent plusieurs avantages par rapport à la logique conditionnelle traditionnelle :

• Lisibilité améliorée : un seul tableau capture toutes les combinaisons possibles, ce qui facilite la compréhension en un coup d'œil.
• Maintenance plus facile : la modification de la logique devient aussi simple que la mise à jour d'une seule ligne du tableau plutôt que de parcourir les lignes de conditions imbriquées.
• Évolutivité : les tables de décision peuvent gérer des scénarios de prise de décision plus complexes sans devenir ingérables.

Voyons comment implémenter une table de décision dans TypeScript.

Comment implémenter une table de décision dans TypeScript

Le moyen le plus simple d'implémenter une table de décision dans TypeScript est d'utiliser un tableau d'objets. Chaque objet représente une ligne dans la table de décision.
Ensuite, vous pouvez utiliser la méthode find du tableau pour trouver la ligne qui correspond aux variables d'entrée et renvoyer la valeur de sortie correspondante.

type TEmailLanguage = 'en' | 'es' | 'fr';

interface IDecisionTableRow {
  //These are the input values that determine the output value
  isGoldCustomer: boolean;
  isFirstPurchase: boolean;
  isPromoAvailable: boolean;
  emailLanguage: TEmailLanguage;

  // The last property is the output value
  template: string;
};

const DECISION_TABLE: IDecisionTableRow[] = [
  {
    isGoldCustomer: true,
    isFirstPurchase: true,
    isPromoAvailable: true,
    emailLanguage: 'en',
    template: 'welcome_en.html',
  },
  {
    isGoldCustomer: true,
    isFirstPurchase: true,
    isPromoAvailable: true,
    emailLanguage: 'es',
    template: 'welcome_es.html',
  },
  {
    isGoldCustomer: true,
    isFirstPurchase: true,
    isPromoAvailable: true,
    emailLanguage: 'fr',
    template: 'welcome_fr.html',
  },
  // more rows...
];

const getTemplate = (
  isGoldCustomer: boolean,
  isFirstPurchase: boolean,
  isPromoAvailable: boolean,
  emailLanguage: EmailLanguage
): string => {
  const row = decisionTable.find(
    (row) =>
      row.emailLanguage === emailLanguage &&
      row.isGoldCustomer === isGoldCustomer &&
      row.isFirstPurchase === isFirstPurchase &&
      row.isPromoAvailable === isPromoAvailable 
  );

  if (!row) {
    throw new Error('No matching row in decision table');
  }

  return row.template;
};

Dans cet exemple, nous avons un tableau d'objets appelé DECISION_TABLE qui représente la table de décision.
Chaque objet possède 4 propriétés qui représentent les variables d'entrée et 1 propriété qui représente la valeur de sortie.

La fonction getTemplate prend les variables d'entrée comme arguments et utilise la méthode find pour trouver la ligne de la table de décision qui correspond aux variables d'entrée.

Si aucune ligne n'est trouvée, la fonction renvoie une erreur.

Et c'est tout ! Vous disposez désormais d'un moyen propre et maintenable de gérer une logique complexe qui dépend de plusieurs variables d'entrée.

Considérations supplémentaires

• Priorisation des règles : si plusieurs règles correspondent aux conditions d'entrée, vous devrez peut-être définir un mécanisme de priorité pour déterminer la sortie correcte.
• Valeurs par défaut : envisagez de fournir une sortie par défaut au cas où aucune règle de correspondance n'est trouvée.
• Validation des données : mettez en œuvre la validation pour garantir que les valeurs d'entrée sont valides et dans les plages attendues.

Conclusion

Les tables de décision offrent une approche puissante et efficace pour gérer une logique de prise de décision complexe dans TypeScript. En fournissant une représentation claire et structurée des règles, ils améliorent la lisibilité, la maintenabilité et l’évolutivité du code. En adoptant des tables de décision dans vos projets, vous pouvez améliorer la qualité et l'efficacité globales de votre base de code.

Donc, la prochaine fois que vous vous retrouverez à écrire un tas d'instructions if-else ou d'instructions switch pour gérer une logique complexe, envisagez plutôt d'utiliser une table de décision.

Bon codage !

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!