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
today() + 7

// Date il y a 30 jours
today() - 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 < today()

Attention

Pour tester l'égalité, utilisez ===, pas = : le signe simple est réservé à l'affectation de variables. La forme ==reste acceptée, mais === est la forme à écrire.

Opérateurs logiques

Les opérateurs logiques permettent de combiner plusieurs conditions. Ils s'écrivent comme en JavaScript : &&, || et !.

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

Tables de vérité

&&

`true && true`	→ `true`
`true && false`	→ `false`
`false && true`	→ `false`
`false && false`	→ `false`

||

`true \|\| true`	→ `true`
`true \|\| false`	→ `true`
`false \|\| true`	→ `true`
`false \|\| false`	→ `false`

Exemples pratiques

JavaScript

// Commande importante et urgente
commande.total > 5000 && commande.priorite === "haute"

// Client particulier ou professionnel
client.type === "particulier" || client.type === "professionnel"

// Produit disponible (stock > 0 et pas en rupture)
produit.stock > 0 && !produit.enRupture

// Condition complexe
(commande.total > 1000 || client.fidele === true)
&& 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

// && a priorité sur ||
true || false && false              // = true || (false && false) = true || false = true

// Parenthèses pour clarifier
(true || false) && false            // = true && 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 le ternaire condition ? valeur : sinon.

Conditions →← Interpolation