Opérateurs

Les opérateurs vous permettent d'effectuer des calculs, de comparer des valeurs et de combiner des conditions. C'est le cœur de toute formule.

Opérateurs arithmétiques

Ces opérateurs permettent d'effectuer des calculs mathématiques classiques.

Opérateur	Description	Exemple	Résultat
`+`	Addition	`5 + 3`	8
`-`	Soustraction	`10 - 4`	6
`*`	Multiplication	`4 * 3`	12
`/`	Division	`15 / 3`	5

Exemples pratiques

JavaScript

// Calculer un prix TTC (TVA 20%)
{{produit.prixHT}} * 1.20

// Calculer une marge
{{produit.prixVente}} - {{produit.coutAchat}}

// Calculer un prix unitaire
{{commande.totalHT}} / {{commande.quantite}}

// Calculer un montant avec remise
{{commande.total}} * (1 - {{commande.remise}} / 100)

Opérations sur les tableaux

Quand vous appliquez un opérateur entre un tableau et un nombre, l'opération s'applique à chaque élément du tableau.

JavaScript

// Ajouter 1 à chaque élément
[1, 2, 3] + 1                     // [2, 3, 4]

// Multiplier chaque élément par 2
[10, 20, 30] * 2                  // [20, 40, 60]

// Avec des données réelles
{{commande.produits.prixHT}} * 1.20   // Tableau des prix TTC

Opérations sur les dates

Vous pouvez ajouter ou soustraire des jours à une date.

JavaScript

// Date dans 7 jours
AUJOURDHUI() + 7

// Date il y a 30 jours
AUJOURDHUI() - 30

// Date d'échéance = date de facture + 30 jours
{{facture.dateEmission}} + 30

Opérateurs de comparaison

Les opérateurs de comparaison permettent de comparer deux valeurs. Ils retournent toujours un booléen (true ou false).

Opérateur	Description	Exemple	Résultat
`==`	Égal à	`5 == 5`	`true`
`!=`	Différent de	`5 != 3`	`true`
`>`	Supérieur à	`10 > 5`	`true`
`>=`	Supérieur ou égal	`5 >= 5`	`true`
`<`	Inférieur à	`3 < 10`	`true`
`<=`	Inférieur ou égal	`5 <= 5`	`true`

Exemples pratiques

JavaScript

// Vérifier si une commande dépasse un seuil
{{commande.total}} > 1000

// Vérifier l'égalité d'un statut
{{commande.statut}} == "validée"

// Vérifier si un stock est faible
{{produit.stock}} < 10

// Vérifier si une date est passée
{{facture.dateEcheance}} < AUJOURDHUI()

Attention

Pour tester l'égalité, utilisez == (deux signes égal), pas =. Le signe = simple est réservé à l'affectation de variables.

Opérateurs logiques

Les opérateurs logiques permettent de combiner plusieurs conditions. Notez qu'ils s'écrivent en français !

Opérateur	Description	Exemple	Résultat
`ET`	Les deux conditions doivent être vraies	`true ET true`	`true`
`OU`	Au moins une condition doit être vraie	`true OU false`	`true`
`!`	Inverse la valeur (NON logique)	`!true`	`false`

Tables de vérité

ET

`true ET true`	→ `true`
`true ET false`	→ `false`
`false ET true`	→ `false`
`false ET false`	→ `false`

OU

`true OU true`	→ `true`
`true OU false`	→ `true`
`false OU true`	→ `true`
`false OU false`	→ `false`

Exemples pratiques

JavaScript

// Commande importante ET urgente
{{commande.total}} > 5000 ET {{commande.priorite}} == "haute"

// Client particulier OU professionnel
{{client.type}} == "particulier" OU {{client.type}} == "professionnel"

// Produit disponible (stock > 0 ET pas en rupture)
{{produit.stock}} > 0 ET !{{produit.enRupture}}

// Condition complexe
({{commande.total}} > 1000 OU {{client.fidele}} == true)
ET {{commande.statut}} == "validée"

Bon à savoir

Utilisez des parenthèses pour grouper vos conditions et rendre votre formule plus claire. Les parenthèses sont évaluées en premier.

Précédence des opérateurs

Quand plusieurs opérateurs sont utilisés ensemble, ils sont évalués dans un ordre précis :

Parenthèses — évaluées en premier
Négation !
Multiplication et division * /
Addition et soustraction + -
Comparaison == != > < etc.
ET logique
OU logique

JavaScript

// Sans parenthèses : multiplication d'abord
2 + 3 * 4               // = 2 + 12 = 14

// Avec parenthèses : addition d'abord
(2 + 3) * 4             // = 5 * 4 = 20

// ET a priorité sur OU
true OU false ET false  // = true OU (false ET false) = true OU false = true

// Parenthèses pour clarifier
(true OU false) ET false  // = true ET false = false

Conseil

En cas de doute, ajoutez des parenthèses ! Elles rendent votre intention claire et évitent les erreurs subtiles.

Cas spéciaux

Division par zéro

En Miel, la division par zéro retourne 0 au lieu de provoquer une erreur.

JavaScript

10 / 0    // 0 (pas d'erreur)

Comparaison de décimaux

Les comparaisons de nombres décimaux sont arrondies à 2 décimales par défaut.

JavaScript

1.001 == 1.002    // true (arrondi à 1.00)

Prochaine étape

Vous maîtrisez maintenant les opérateurs. Apprenez à créer des logiques conditionnelles plus complexes avec SI...ALORS...SINON.

Conditions →← Interpolation