Bonnes pratiques

Suivre ces recommandations vous aidera à écrire des expressions MEL performantes, lisibles et faciles à maintenir.

Préfixer les champs

Toujours utiliser les préfixes ($form, $object,$selector, etc.) pour indiquer clairement la source des données.

❌ À éviter

JSON

{ "status": { "$eq": "active" } }

Ambigu : d'où vient "status" ?

✓ Recommandé

JSON

{ "$selector.status": { "$eq": "active" } }

Explicite : données du sélecteur

Pourquoi c'est important

Les préfixes explicites facilitent la maintenance et le débogage. Quand quelqu'un (ou vous dans 6 mois) relit l'expression, il comprend immédiatement d'où viennent les données.

Privilégier la simplicité

Optez pour l'expression la plus simple qui répond à votre besoin. Les expressions simples sont plus faciles à comprendre et à maintenir.

Utilisez $in plutôt que $or quand possible

Verbeux

JSON

{
  "$or": [
    { "type": { "$eq": "A" } },
    { "type": { "$eq": "B" } },
    { "type": { "$eq": "C" } }
  ]
}

Concis

JSON

{ "type": { "$in": ["A", "B", "C"] } }

Utilisez $ne plutôt que $not avec $eq

Verbeux

JSON

{ "status": { "$not": { "$eq": "draft" } } }

Concis

JSON

{ "status": { "$ne": "draft" } }

Utiliser la syntaxe raccourcie

MEL offre une syntaxe raccourcie pour $in. Utilisez-la pour rendre vos expressions plus lisibles.

Standard

JSON

{ "project": { "$in": ["id1", "id2"] } }

Raccourcie

JSON

{ "project": ["id1", "id2"] }

Attention

La syntaxe raccourcie ne fonctionne que pour $in. Pour les autres opérateurs, utilisez la syntaxe complète.

Valider avant d'évaluer

Si vous construisez des expressions MEL dynamiquement, validez-les avant de les utiliser. MEL dispose de fonctions de validation intégrées.

Processus de validation

Une expression MEL passe par plusieurs étapes de validation :

Normalisation JSON : Ajout des guillemets manquants
Parsing JSON : Vérification de la syntaxe JSON valide
Validation MEL : Vérification contre le schéma MEL
Validation des références : Vérification que les champs existent
Validation des opérateurs : Vérification des opérateurs utilisés

Astuce

L'éditeur MEL dans Miel effectue cette validation en temps réel. Utilisez-le pour tester vos expressions avant de les déployer.

Limiter la profondeur

Évitez les structures trop profondément imbriquées. Elles deviennent difficiles à comprendre et peuvent poser des problèmes de compatibilité.

❌ Trop profond

JSON

{
  "$and": [
    {
      "$or": [
        {
          "$and": [
            { "a": { "$eq": 1 } },
            { "b": { "$eq": 2 } }
          ]
        },
        { "c": { "$eq": 3 } }
      ]
    }
  ]
}

✓ Aplati

JSON

{
  "$or": [
    {
      "$and": [
        { "a": { "$eq": 1 } },
        { "b": { "$eq": 2 } }
      ]
    },
    { "c": { "$eq": 3 } }
  ]
}

Règle pratique

Limitez-vous à 3-4 niveaux d'imbrication maximum. Au-delà, l'interface visuelle (mode humain) ne pourra plus représenter l'expression. La limite technique est de 10 niveaux.

Choisir le bon mode

MEL propose deux modes d'édition : le mode JSON et le mode humain (visuel). Choisissez le bon selon votre cas d'usage.

Mode humain (visuel)

Utilisez-le pour :

Filtres simples (une ou quelques conditions)
Utilisateurs non-techniques
Prototypage rapide
Modifications fréquentes

Mode JSON

Utilisez-le pour :

Expressions complexes avec $or ou $not
Structures profondes
Copier/coller depuis d'autres sources
Contrôle précis de la syntaxe

Compatibilité du mode humain

Le mode humain ne supporte pas : $not, les opérations arithmétiques, les appels de fonction, et les structures de plus de 10 niveaux. Pour ces cas, utilisez le mode JSON.

Optimiser les performances

Quelques conseils pour des expressions performantes sur de grandes quantités de données.

Préférez l'égalité au regex

Les comparaisons d'égalité sont beaucoup plus rapides que les expressions régulières.

Plus lent

JSON

{ "status": { "$regex": "^active$" } }

Plus rapide

JSON

{ "status": { "$eq": "active" } }

Limitez les chemins profonds

Les chemins profonds nécessitent plusieurs résolutions. Restez autour de 3-4 niveaux.

Coûteux

JSON

{ "$form.order.provider.address.city": { "$eq": "Paris" } }

Plus efficace

JSON

{ "$form.providerCity": { "$eq": "Paris" } }

Mettez les filtres les plus sélectifs en premier

Dans un $and, les conditions les plus restrictives devraient venir en premier pour réduire rapidement le nombre d'éléments à tester.

Résumé

Préfixez toujours vos champs avec leur source ($form., $object., etc.)
Utilisez la syntaxe raccourcie pour $in avec des tableaux
Évitez les structures trop profondes (max 10 niveaux, idéalement 3-4)
Validez vos expressions avant de les utiliser en production
Préférez le mode humain pour les expressions simples
Utilisez le mode JSON pour les expressions complexes
Comparez les expressions avec la fonction dédiée (canonicalisation)

En suivant ces bonnes pratiques, vous créerez des expressions MEL performantes, lisibles et maintenables sur le long terme.

Félicitations !

Vous avez parcouru l'intégralité de la documentation MEL. Vous êtes maintenant équipé pour créer des filtres puissants et efficaces.

← Retour à l'introduction MEL Revoir les exemples