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 àCHERCHER.OBJET ou CHERCHER.OBJETSinterroge la base de données.

❌ Lent

JavaScript

CONCAT(
  CHERCHER.OBJET(client, {id: {{id}}}).nom,
  " - ",
  CHERCHER.OBJET(client, {id: {{id}}}).email
)

✓ Rapide

JavaScript

var client = CHERCHER.OBJET(client, {id: {{id}}});
CONCAT({{client.nom}}, " - ", {{client.email}})

✓ Filtrez avant de transformer

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

❌ Inefficace

JavaScript

// Transforme TOUS les éléments d'abord
FILTRER(
  TRANSFORMER({{commandes}}, {{$.total}} * 1.20),
  {{$}} > 1000
)

✓ Efficace

JavaScript

// Filtre d'abord, transforme moins d'éléments
TRANSFORMER(
  FILTRER({{commandes}}, {{$.total}} > 833),
  {{$.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

SOMME(TRANSFORMER(FILTRER(
  CHERCHER.OBJETS(commande, {}),
  {{$.statut}} == "validée"
), {{$.total}}))

✓ Aéré

JavaScript

var commandes = CHERCHER.OBJETS(commande, {});
var validees = FILTRER(commandes, {{$.statut}} == "validée");
SOMME(TRANSFORMER(validees, {{$.total}}))

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

var x = CHERCHER.OBJETS(commande, {});
var y = FILTRER(x, {{$.statut}} == "validée");
var z = SOMME(TRANSFORMER(y, {{$.total}}));

✓ Clair

JavaScript

var toutesLesCommandes = CHERCHER.OBJETS(commande, {});
var commandesValidees = FILTRER(toutesLesCommandes, {{$.statut}} == "validée");
var totalVentes = SOMME(TRANSFORMER(commandesValidees, {{$.total}}));

✓ 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
var commandes = CHERCHER.OBJETS(commande, {});

// Étape 2 : Filtrer par année et statut
var commandesAnnee = FILTRER(commandes,
  ANNEE({{$.date}}) == ANNEE(AUJOURDHUI())
);
var commandesValidees = FILTRER(commandesAnnee,
  {{$.statut}} == "validée"
);

// Étape 3 : Calculer les totaux
var totalHT = SOMME(TRANSFORMER(commandesValidees, {{$.totalHT}}));
var totalTVA = SOMME(TRANSFORMER(commandesValidees, {{$.totalTVA}}));
var totalTTC = totalHT + totalTVA;

// Étape 4 : Formater le résultat
CONCAT("CA annuel: ", FIXER.DECIMALES(totalTTC, 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 ET b < 10 OU c == 0

✓ Explicite

JavaScript

(a > 5 ET b < 10) OU (c == 0)

Fiabilité

✓ Gérez les champs optionnels

Utilisez SI.VIDE.RENVOYER pour les champs qui peuvent être vides et EXISTE pour les vérifications.

JavaScript

// Afficher une valeur par défaut si le champ est vide
var telephone = SI.VIDE.RENVOYER({{client.telephone}}, "Non renseigné");

// Vérifier avant d'accéder
SI EXISTE({{commande.client}})
ALORS {{commande.client.nom}}
SINON "Client inconnu"
FINSI

✓ Protégez les opérations risquées

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

JavaScript

// Recherche qui peut ne rien trouver
var client = SI.ECHOUE.RENVOYER(
  CHERCHER.OBJET(client, { email: {{email}} }),
  null
);

// Calcul qui peut échouer
var moyenne = SI.ECHOUE.RENVOYER(
  MOYENNE({{notes}}),
  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

var produits = {{commande.produits}};

// Gérer le cas d'un tableau vide
SI COMPTER(produits) == 0
ALORS "Aucun produit"
SINON
  var total = SOMME(TRANSFORMER(produits, {{$.prix}}));
  CONCAT(COMPTER(produits), " produit(s) - Total: ", FIXER.DECIMALES(total, 2), " €")
FINSI

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 var

JavaScript

// ❌ Erreur de syntaxe
var total = SOMME([1, 2, 3])
total * 2

// ✓ Correct
var total = SOMME([1, 2, 3]);
total * 2

❌ Confondre = et ==

JavaScript

// ❌ = est pour l'affectation
SI {{statut}} = "validée" ALORS ...

// ✓ == est pour la comparaison
SI {{statut}} == "validée" ALORS ...

❌ Oublier FINSI

JavaScript

// ❌ Manque FINSI
SI {{total}} > 100
ALORS "Gros"
SINON "Petit"

// ✓ Complet
SI {{total}} > 100
ALORS "Gros"
SINON "Petit"
FINSI

❌ 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 MOIS retourne 0-11

JavaScript

// ❌ Janvier n'est pas 1
SI MOIS({{date}}) == 1 ALORS "Janvier" FINSI

// ✓ Janvier est 0
SI MOIS({{date}}) == 0 ALORS "Janvier" FINSI

Récapitulatif

À faire

Utiliser des variables pour les recherches
Filtrer avant de transformer
Nommer clairement les variables
Gérer les valeurs vides avec SI.VIDE.RENVOYER
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