Nombres et calculs

En JavaScript, 0.1 + 0.2 donne 0.30000000000000004, et 17 % 5 donne 2. Les deux s'expliquent quand on sait comment les nombres sont stockés et ce que signifie %.

Les opérateurs arithmétiques

La plupart des tâches d'un ordinateur se ramènent à des calculs, et JavaScript les écrit presque comme sur papier. Les symboles qui font le travail s'appellent des opérateurs. Tu en connais déjà cinq, et deux sont nouveaux :

Opérateur	Sens	Exemple	Résultat
+	addition	7 + 2	9
-	soustraction	7 - 2	5
*	multiplication	7 * 2	14
/	division	7 / 2	3.5
%	reste	7 % 2	1
**	puissance	7 ** 2	49

La multiplication utilise un astérisque, car la lettre x se confondrait avec une variable appelée x. La division donne toujours le résultat exact, décimales comprises : 7 / 2 vaut 3.5, pas 3. L'opérateur de reste % divise et ne garde que ce qui reste. 17 % 5 vaut 2, car 5 va trois fois dans 17 (15) et il reste 2. Cela ressemble à une curiosité, mais c'est l'un des opérateurs les plus utilisés en programmation. Un nombre est pair exactement quand n % 2 vaut 0, et minutes % 60 donne les minutes qui restent une fois les heures entières retirées.

L'ordre des opérations

JavaScript suit les mêmes priorités qu'en mathématiques à l'école. Les puissances d'abord, puis la multiplication, la division et le reste, puis l'addition et la soustraction. Les opérateurs de même rang se calculent de gauche à droite, sauf ** qui se calcule de droite à gauche. Les parenthèses passent avant tout : dans le doute, ajoute-en ; elles ne coûtent rien et rendent l'intention claire pour le prochain lecteur.

console.log(2 + 3 * 4);      // 14 (multiplication d'abord)
console.log((2 + 3) * 4);    // 20
console.log(20 - 6 / 2);     // 17
console.log(2 ** 3 * 5);     // 40 (puissance d'abord)

Des raccourcis pour mettre à jour une variable

Mettre à jour une variable à partir de sa propre valeur est si courant qu'il existe des formes courtes. x += 5 signifie x = x + 5, et il existe les formes correspondantes -=, *= et /=. Ajouter ou retirer exactement un a une forme encore plus courte : x++ ajoute 1 et x-- retire 1. Tu verras ++ en permanence dans les boucles.

let coins = 10;
coins += 5;      // 15
coins *= 2;      // 30
coins--;         // 29
console.log(coins);   // affiche 29

Les outils de Math

JavaScript est livré avec un objet intégré appelé Math qui contient des outils tout prêts pour les nombres. Math.round(2.5) arrondit à l'entier le plus proche (3), Math.floor(2.9) arrondit toujours vers le bas (2) et Math.ceil(2.1) toujours vers le haut (3). Math.max(4, 9, 2) donne la plus grande de ses valeurs et Math.min la plus petite. Math.sqrt(81) est la racine carrée, 9, et Math.PI est le nombre π, environ 3.14159. Math.floor et % font bon ménage : pour 135 minutes, Math.floor(135 / 60) donne 2 heures et 135 % 60 donne 15 minutes.

Pourquoi 0.1 + 0.2 ne vaut pas exactement 0.3

JavaScript stocke chaque nombre en binaire sur une quantité fixe de mémoire, selon le format double précision IEEE 754 que fixe la norme ECMAScript. Certains décimaux ordinaires, comme 0.1, ne peuvent pas s'écrire exactement en binaire, de même que 1/3 ne peut pas s'écrire exactement en décimal. Les minuscules erreurs d'arrondi restent en général cachées, mais parfois elles se voient : 0.1 + 0.2 affiche 0.30000000000000004. Ce n'est pas un bug de ton code. Quand tu montres des sommes d'argent ou des mesures à des gens, arrondis le résultat, par exemple avec (0.1 + 0.2).toFixed(2), qui donne la chaîne "0.30". Les entiers jusqu'à environ neuf millions de milliards sont stockés exactement : compter n'est donc jamais affecté.

Exemples corrigés

Exemple 1. La moyenne de 80, 90 et 85 est (80 + 90 + 85) / 3. Sans parenthèses, 80 + 90 + 85 / 3 ne divise que 85 et donne environ 198.3. Exemple 2. 2024 est-il un multiple de 4 ? 2024 % 4 vaut 0, donc oui. Exemple 3. Partager 50 bonbons entre 6 enfants : Math.floor(50 / 6) donne 8 chacun et 50 % 6 donne 2 restants.

opérateur	Un symbole qui agit sur des valeurs : + - * / % **
%	Reste de la division : 17 % 5 vaut 2
**	Puissance : 2 ** 3 vaut 8
+=	x += 5 signifie x = x + 5
++	Ajouter exactement 1 à une variable
Math.floor	Arrondir à l'entier inférieur
Math.round	Arrondir à l'entier le plus proche
toFixed(2)	Écrire un nombre avec 2 décimales, sous forme de chaîne

Qu'affiche ce code ?
```
console.log(2 + 3 * 4);
```
Qu'affiche ce code ?
```
console.log((2 + 3) * 4);
```
Qu'affiche ce code ?
```
console.log(17 % 5);
```
Qu'affiche ce code ?
```
console.log(9 / 2);
```
Qu'affiche ce code ?
```
console.log(2 ** 5);
```

Qu'affiche ce code ?

let x = 10;
x += 4;
x *= 2;
console.log(x);

Qu'affiche ce code ?

let n = 5;
n++;
n++;
n--;
console.log(n);

Qu'affiche ce code ?

console.log(Math.floor(7.9), Math.ceil(7.1));

Qu'affiche ce code ?

console.log(Math.max(3, 11, 6) - Math.min(3, 11, 6));

Qu'affiche ce code ?
```
console.log(10 - 4 - 3);
```
Quelle expression est vraie pour tout nombre pair n ?
- n % 2 === 0
- n / 2 === 0
- n % 2 === 1
Qu'affiche ce code ?
```
console.log((0.1 + 0.2).toFixed(2));
```

L'essentiel

+ - * / fonctionnent comme en mathématiques ; / garde les décimales.
% donne le reste ; n % 2 === 0 signifie que n est pair.
** est la puissance. Les parenthèses d'abord, puis **, puis * / %, puis + -.
x += 5 et x++ sont des formes courtes pour mettre à jour x.
Math.floor, Math.round, Math.ceil, Math.max, Math.min et Math.PI.
Les décimaux peuvent porter de minuscules erreurs d'arrondi ; utilise toFixed pour les afficher.

Sources de ce cours (2)

MDN Web Docs, JavaScript Guide (developer.mozilla.org/en-US/docs/Web/JavaScript/Guide, chapters Introduction, Grammar and types, Control flow, Loops and iteration, Functions, Expressions and operators, Numbers and strings, Indexed collections, Working with objects; checked 2026-10-17)
Ecma International, ECMA-262 ECMAScript 2026 Language Specification, 17th edition, June 2026 (tc39.es/ecma262 and ecma-international.org/publications-and-standards/standards/ecma-262, checked 2026-10-17)

Consulté le: 2026-10-17