Bonnes pratiques

Suivre ces bonnes pratiques vous aidera à écrire des formules performantes, lisibles et faciles à maintenir dans le temps.

Performance

✓ Stockez les recherches dans des variables

Évitez de rechercher le même objet plusieurs fois. Chaque appel àfindObject ou findObjectsinterroge la base de données.

❌ Lent

JavaScript

findObject(client, {id: "{{id}}"}).nom.concat(" - ",
  findObject(client, {id: "{{id}}"}).email
)

✓ Rapide

JavaScript

let client = findObject(client, {id: "{{id}}"});
client.nom.concat(" - ", client.email)

✓ Filtrez avant de transformer

Réduisez d'abord le nombre d'éléments avec filteravant d'appliquer des transformations coûteuses.

❌ Inefficace

JavaScript

// Transforme TOUS les éléments d'abord
client.commandes.map(commande => commande.total * 1.20).filter(commande => commande > 1000
)

✓ Efficace

JavaScript

// Filtre d'abord, transforme moins d'éléments
client.commandes.filter(commande => commande.total > 833).map(commande => commande.total * 1.20
)

✓ Évitez les imbrications profondes

Les formules avec plus de 3-4 niveaux d'imbrication sont difficiles à lire et peuvent être plus lentes. Utilisez des variables intermédiaires.

❌ Trop imbriqué

JavaScript

findObjects(commande, {}).filter(x => x.statut === "validée"
).map(x => x.total).sum()

✓ Aéré

JavaScript

let commandes = findObjects(commande, {});
let validees = client.commandes.filter(commande => commande.statut === "validée");
validees.map(validee => validee.total).sum()

Lisibilité

✓ Utilisez des noms de variables descriptifs

Un bon nom de variable explique ce qu'elle contient sans avoir besoin de lire le code.

❌ Obscur

JavaScript

let x = findObjects(commande, {});
let y = x.filter(x2 => x2.statut === "validée");
let z = y.map(x2 => x2.total).sum();

✓ Clair

JavaScript

let toutesLesCommandes = findObjects(commande, {});
let commandesValidees = toutesLesCommandes.filter(toutesLesCommande => toutesLesCommande.statut === "validée");
let totalVentes = commandesValidees.map(commandesValidee => commandesValidee.total).sum();

✓ Décomposez les formules complexes

Une formule de 10 lignes avec des variables nommées est plus facile à comprendre qu'une formule d'une ligne très longue.

JavaScript

// Étape 1 : Récupérer les données
let commandes = findObjects(commande, {});

// Étape 2 : Filtrer par année et statut
let commandesAnnee = client.commandes.filter(commande => commande.date.year() === today().year()
);
let commandesValidees = commandesAnnee.filter(x => x.statut === "validée"
);

// Étape 3 : Calculer les totaux
let totalHT = commandesValidees.map(commandesValidee => commandesValidee.totalHT).sum();
let totalTVA = commandesValidees.map(commandesValidee => commandesValidee.totalTVA).sum();
let totalTTC = totalHT + totalTVA;

// Étape 4 : Formater le résultat
"CA annuel: ".concat(totalTTC.toFixed(2), " € TTC")

✓ Utilisez des parenthèses pour clarifier

Même quand elles ne sont pas nécessaires, les parenthèses rendent l'intention claire.

❌ Ambigu

JavaScript

a > 5 && b < 10 || c === 0

✓ Explicite

JavaScript

(a > 5 && b < 10) || (c === 0)

Fiabilité

✓ Gérez les champs optionnels

Utilisez ifEmpty pour les champs qui peuvent être vides et exists pour les vérifications.

JavaScript

// Afficher une valeur par défaut si le champ est vide
let telephone = client.telephone.ifEmpty("Non renseigné");

// Vérifier avant d'accéder
commande.client.exists()
? commande.client.nom
: "Client inconnu"

✓ Protégez les opérations risquées

Utilisez ifError pour les opérations qui peuvent échouer (recherches, accès profonds).

JavaScript

// Recherche qui peut ne rien trouver
let client = findObject(client, { email: "{{email}}" }).ifError(null
);

// Calcul qui peut échouer
let moyenne = notes.average().ifError(0
);

✓ Prévoyez les cas limites

Que se passe-t-il si le tableau est vide ? Si la valeur est zéro ? Testez ces cas.

JavaScript

let produits = commande.produits;

// Gérer le cas d'un tableau vide
commande.produits.count() === 0
? "Aucun produit"
:
  let total = commande.produits.map(produit => produit.prix).sum();
  commande.produits.count().concat(" produit(s) - Total: ", total.toFixed(2), " €")

Maintenance

✓ Formules pures

Une formule ne doit pas avoir d'effets de bord. Même entrée = même sortie. Cela rend les formules prévisibles et testables.

JavaScript

// ✓ Formule pure : dépend uniquement de ses entrées
produit.prixHT * (1 + produit.tauxTVA / 100)

// Les formules ne modifient jamais les données
// Elles calculent et retournent une valeur

✓ Évitez les valeurs codées en dur

Préférez utiliser des champs de configuration plutôt que des valeurs fixes qui pourraient changer.

❌ Valeur en dur

JavaScript

produit.prixHT * 1.20  // TVA 20% codée en dur

✓ Configurable

JavaScript

produit.prixHT * (1 + produit.tauxTVA / 100)

✓ Testez avec différentes données

Avant de déployer une formule, testez-la avec différents scénarios :

Données normales (cas standard)
Données vides (champs manquants)
Valeurs extrêmes (très grandes, très petites, négatives)
Tableaux vides
Recherches sans résultat

Erreurs courantes à éviter

❌ Oublier le point-virgule après une déclaration

JavaScript

// ❌ Erreur de syntaxe
let total = [1, 2, 3].sum()
total * 2

// ✓ Correct
let total = [1, 2, 3].sum();
total * 2

❌ Confondre = et ===

JavaScript

// ❌ = est pour l'affectation d'une variable
statut = "validée" ? "oui" : "non"

// ✓ === compare deux valeurs
statut === "validée" ? "oui" : "non"

❌ Oublier la branche « sinon »

JavaScript

// ❌ Un ternaire sans : est incomplet
total > 100
? "Gros"

// ✓ Complet
total > 100
? "Gros"
: "Petit"

❌ Mélanger index et position

JavaScript

 // Les index commencent à 0, pas à 1
"Bonjour"[1]                        // "o", pas "B"
[10, 20, 30][0]                     // 10, pas 20

❌ Oublier que month retourne 0-11

JavaScript

// ❌ Janvier n'est pas 1
commande.date.month() === 1 ? "Janvier" : null

// ✓ Janvier est 0
commande.date.month() === 0 ? "Janvier" : null

Récapitulatif

À faire

Utiliser des variables pour les recherches
Filtrer avant de transformer
Nommer clairement les variables
Gérer les valeurs vides avec ifEmpty
Protéger les opérations risquées
Décomposer les formules complexes
Tester avec différentes données

À éviter

Recherches multiples du même objet
Imbrications profondes (> 3-4 niveaux)
Variables nommées x, y, z, temp
Ignorer les cas d'erreur
Valeurs codées en dur
Formules d'une seule ligne très longues
Oublier les points-virgules

Félicitations !

Vous avez terminé le guide complet des formules Miel. Vous êtes maintenant prêt à créer des formules puissantes et maintenables.

← Retour à l'introduction