Gardes de filtrage par motif en JavaScript : Évaluation d'expressions conditionnelles

Bien que JavaScript ne soit pas traditionnellement connu pour le filtrage par motif comme certains langages fonctionnels, il a évolué pour intégrer une logique conditionnelle plus sophistiquée. Une fonctionnalité puissante qui améliore l'évaluation des expressions conditionnelles est l'utilisation des gardes de filtrage par motif. Cet article explore comment vous pouvez tirer parti des gardes de filtrage par motif pour créer un code plus lisible, maintenable et expressif.

Que sont les gardes de filtrage par motif ?

Le filtrage par motif, en général, est une technique où vous comparez une valeur à un ensemble de motifs. Les gardes étendent ce concept en vous permettant d'ajouter des expressions conditionnelles à vos motifs. Considérez-les comme des filtres supplémentaires qui doivent être satisfaits pour qu'un motif soit considéré comme une correspondance. En JavaScript, les gardes de filtrage par motif se manifestent souvent au sein d'instructions switch ou via des bibliothèques qui offrent des capacités de filtrage par motif plus avancées.

Bien que JavaScript ne dispose pas de constructions de filtrage par motif intégrées avec des gardes aussi élégantes que des langages comme Scala ou Haskell, nous pouvons simuler ce comportement en utilisant des instructions switch, des chaînes if-else et une composition de fonctions stratégique.

Simuler le filtrage par motif avec des gardes en JavaScript

Explorons comment nous pouvons simuler les gardes de filtrage par motif en JavaScript en utilisant différentes approches.

Utiliser les instructions Switch

L'instruction switch est un moyen courant de mettre en œuvre une logique conditionnelle basée sur la correspondance d'une valeur. Bien qu'elle ne dispose pas d'une syntaxe de garde directe, nous pouvons la combiner avec des instructions if supplémentaires dans chaque case pour obtenir un effet similaire.

Exemple : Catégoriser les nombres en fonction de leur valeur et de leur parité.

            
function categorizeNumber(number) {
  switch (typeof number) {
    case 'number':
      if (number > 0 && number % 2 === 0) {
        return 'Nombre pair positif';
      } else if (number > 0 && number % 2 !== 0) {
        return 'Nombre impair positif';
      } else if (number < 0 && number % 2 === 0) {
        return 'Nombre pair négatif';
      } else if (number < 0 && number % 2 !== 0) {
        return 'Nombre impair négatif';
      } else {
        return 'Zéro';
      }
    default:
      return 'Entrée invalide : Ce n\'est pas un nombre';
  }
}

console.log(categorizeNumber(4));   // Sortie : Nombre pair positif
console.log(categorizeNumber(7));   // Sortie : Nombre impair positif
console.log(categorizeNumber(-2));  // Sortie : Nombre pair négatif
console.log(categorizeNumber(-5));  // Sortie : Nombre impair négatif
console.log(categorizeNumber(0));   // Sortie : Zéro
console.log(categorizeNumber('abc')); // Sortie : Entrée invalide : Ce n'est pas un nombre

            

              
                Copy
              
            
          

Dans cet exemple, l'instruction switch vérifie le type de l'entrée. À l'intérieur du bloc case 'number', une série d'instructions if agissent comme des gardes, affinant davantage la condition en fonction de la valeur du nombre et de sa parité (pair ou impair).

Utiliser les chaînes If-Else

Une autre approche courante consiste à utiliser une chaîne d'instructions if-else if-else. Cela permet une logique conditionnelle plus complexe et peut simuler efficacement le filtrage par motif avec des gardes.

Exemple : Traiter l'entrée utilisateur en fonction de son type et de sa longueur.

            
function processInput(input) {
  if (typeof input === 'string' && input.length > 10) {
    return 'Chaîne longue : ' + input.toUpperCase();
  } else if (typeof input === 'string' && input.length > 0) {
    return 'Chaîne courte : ' + input;
  } else if (typeof input === 'number' && input > 100) {
    return 'Grand nombre : ' + input;
  } else if (typeof input === 'number' && input >= 0) {
    return 'Petit nombre : ' + input;
  } else {
    return 'Entrée invalide';
  }
}

console.log(processInput('Hello World')); // Sortie : Chaîne longue : HELLO WORLD
console.log(processInput('Hello'));       // Sortie : Chaîne courte : Hello
console.log(processInput(200));           // Sortie : Grand nombre : 200
console.log(processInput(50));            // Sortie : Petit nombre : 50
console.log(processInput(-1));            // Sortie : Entrée invalide

            

              
                Copy
              
            
          

Ici, la chaîne if-else if-else vérifie à la fois le type et la longueur/valeur de l'entrée, agissant efficacement comme un filtrage par motif avec des gardes. Chaque condition if combine une vérification de type avec une condition spécifique (par exemple, input.length > 10), affinant le processus de correspondance.

Utiliser des fonctions comme gardes

Pour des scénarios plus complexes, vous pouvez définir des fonctions qui agissent comme des gardes, puis les utiliser dans votre logique conditionnelle. Cela favorise la réutilisabilité et la lisibilité du code.

Exemple : Valider des objets utilisateur en fonction de plusieurs critères.

            
function isAdult(user) {
  return user.age >= 18;
}

function isValidEmail(user) {
  return user.email && user.email.includes('@');
}

function validateUser(user) {
  if (typeof user === 'object' && user !== null) {
    if (isAdult(user) && isValidEmail(user)) {
      return 'Utilisateur adulte valide';
    } else if (isAdult(user)) {
      return 'Utilisateur adulte valide (sans e-mail)';
    } else {
      return 'Utilisateur invalide : Mineur';
    }
  } else {
    return 'Entrée invalide : Ce n\'est pas un objet';
  }
}

const user1 = { age: 25, email: 'test@example.com' };
const user2 = { age: 16, email: 'test@example.com' };
const user3 = { age: 30 };

console.log(validateUser(user1)); // Sortie : Utilisateur adulte valide
console.log(validateUser(user2)); // Sortie : Utilisateur invalide : Mineur
console.log(validateUser(user3)); // Sortie : Utilisateur adulte valide (sans e-mail)
console.log(validateUser('abc')); // Sortie : Entrée invalide : Ce n'est pas un objet

            

              
                Copy
              
            
          

Dans cet exemple, isAdult et isValidEmail agissent comme des fonctions de garde. La fonction validateUser vérifie si l'entrée est un objet, puis utilise ces fonctions de garde pour affiner davantage le processus de validation.

Avantages de l'utilisation des gardes de filtrage par motif

• Amélioration de la lisibilité du code : Les gardes rendent votre logique conditionnelle plus explicite et plus facile à comprendre.
• Maintenabilité du code améliorée : En séparant les conditions en gardes distinctes, vous pouvez les modifier et les tester indépendamment.
• Expressivité du code accrue : Les gardes vous permettent d'exprimer une logique conditionnelle complexe de manière plus concise et déclarative.
• Meilleure gestion des erreurs : Les gardes peuvent vous aider à identifier et à gérer différents cas plus efficacement, ce qui conduit à un code plus robuste.

Cas d'utilisation des gardes de filtrage par motif

Les gardes de filtrage par motif sont utiles dans une variété de scénarios, notamment :

• Validation des données : Valider les entrées utilisateur, les réponses d'API ou les données provenant de sources externes.
• Gestion des routes : Déterminer quelle route exécuter en fonction des paramètres de la requête.
• Gestion de l'état : Gérer l'état d'un composant ou d'une application en fonction de divers événements et conditions.
• Développement de jeux : Gérer différents états de jeu ou actions de joueur en fonction de conditions spécifiques.
• Applications financières : Calculer les taux d'intérêt en fonction de différents types de comptes et de soldes. Par exemple, une banque en Suisse pourrait utiliser des gardes pour appliquer différents taux d'intérêt en fonction des seuils de solde de compte et du type de devise.
• Plateformes de commerce électronique : Appliquer des remises en fonction de la fidélité des clients, de l'historique des achats et des codes promotionnels. Un détaillant au Japon peut offrir des remises spéciales aux clients qui ont effectué des achats d'un certain montant au cours de la dernière année.
• Logistique et chaîne d'approvisionnement : Optimiser les itinéraires de livraison en fonction de la distance, des conditions de trafic et des fenêtres de temps de livraison. Une entreprise en Allemagne pourrait utiliser des gardes pour prioriser les livraisons dans les zones à forte congestion routière.
• Applications de santé : Trier les patients en fonction des symptômes, des antécédents médicaux et des facteurs de risque. Un hôpital au Canada pourrait utiliser des gardes pour prioriser les patients présentant des symptômes graves pour un traitement immédiat.
• Plateformes éducatives : Fournir des expériences d'apprentissage personnalisées en fonction des performances des élèves, de leurs styles d'apprentissage et de leurs préférences. Une école en Finlande pourrait utiliser des gardes pour ajuster le niveau de difficulté des devoirs en fonction des progrès d'un élève.

Bibliothèques pour un filtrage par motif amélioré

Bien que les fonctionnalités intégrées de JavaScript soient limitées, plusieurs bibliothèques améliorent les capacités de filtrage par motif et fournissent des mécanismes de garde plus sophistiqués. Parmi les bibliothèques notables, on trouve :

• ts-pattern : Une bibliothèque de filtrage par motif complète pour TypeScript et JavaScript, offrant un support de garde puissant et une sécurité de type.
• jswitch : Une bibliothèque légère qui fournit une instruction switch plus expressive avec une fonctionnalité de garde.

Exemple avec ts-pattern (nécessite TypeScript) :

            
import { match, P } from 'ts-pattern';

interface User {
  age: number;
  email?: string;
  country: string;
}

const user: User = { age: 25, email: 'test@example.com', country: 'USA' };

const result = match(user)
  .with({ age: P.gt(18), email: P.string }, (u) => `Utilisateur adulte avec e-mail de ${u.country}`)
  .with({ age: P.gt(18) }, (u) => `Utilisateur adulte de ${u.country}`)
  .with({ age: P.lt(18) }, (u) => `Utilisateur mineur de ${u.country}`)
  .otherwise(() => 'Utilisateur invalide');

console.log(result); // Sortie : Utilisateur adulte avec e-mail de USA

            

              
                Copy
              
            
          

Cet exemple montre comment ts-pattern vous permet de définir des motifs avec des gardes en utilisant l'objet P, qui fournit divers prédicats de correspondance comme P.gt (supérieur à) et P.string (est une chaîne de caractères). La bibliothèque offre également une sécurité de type, garantissant que vos motifs sont correctement typés.

Meilleures pratiques pour l'utilisation des gardes de filtrage par motif

• Gardez les gardes simples : Des expressions de garde complexes peuvent rendre votre code plus difficile à comprendre. Décomposez les conditions complexes en gardes plus petites et plus faciles à gérer.
• Utilisez des noms de garde descriptifs : Donnez à vos fonctions ou variables de garde des noms descriptifs qui indiquent clairement leur objectif.
• Documentez vos gardes : Ajoutez des commentaires pour expliquer le but et le comportement de vos gardes, surtout s'ils sont complexes.
• Testez vos gardes minutieusement : Assurez-vous que vos gardes fonctionnent correctement en écrivant des tests unitaires complets qui couvrent tous les scénarios possibles.
• Envisagez d'utiliser des bibliothèques : Si vous avez besoin de capacités de filtrage par motif plus avancées, envisagez d'utiliser une bibliothèque comme ts-pattern ou jswitch.
• Équilibrez la complexité : Ne compliquez pas votre code à l'excès avec des gardes inutiles. Utilisez-les judicieusement pour améliorer la lisibilité et la maintenabilité.
• Tenez compte des performances : Bien que les gardes n'introduisent généralement pas de surcharge de performance significative, soyez attentif aux expressions de garde complexes qui pourraient avoir un impact sur les performances dans les sections critiques de votre code.

Conclusion

Les gardes de filtrage par motif sont une technique puissante pour améliorer l'évaluation des expressions conditionnelles en JavaScript. Bien que les fonctionnalités intégrées de JavaScript soient limitées, vous pouvez simuler ce comportement en utilisant des instructions switch, des chaînes if-else et des fonctions comme gardes. En suivant les meilleures pratiques et en envisageant l'utilisation de bibliothèques comme ts-pattern, vous pouvez tirer parti des gardes de filtrage par motif pour créer un code plus lisible, maintenable et expressif. Adoptez ces techniques pour écrire des applications JavaScript plus robustes et élégantes, capables de gérer un large éventail de scénarios avec clarté et précision.

Alors que JavaScript continue d'évoluer, nous pouvons nous attendre à voir un support natif plus important pour le filtrage par motif et les gardes, rendant cette technique encore plus accessible et puissante pour les développeurs du monde entier. Explorez les possibilités et commencez à intégrer les gardes de filtrage par motif dans vos projets JavaScript dès aujourd'hui !