Opérateurs arithmétiques [Les opérations]

Opérateurs arithmétiques

Objectif

Connaître les opérateurs arithmétiques les plus communs et savoir les utiliser

Mise en situation

Dans un cours précédent, nous avons vu que les variables servaient à stocker des données afin de les réutiliser et les manipuler par la suite. Dans le cas des données de type numérique (integer, float), différentes opérations sont possibles par le biais des opérateurs arithmétiques. Nous allons voir à quoi ils servent et comment les utiliser.

Les opérateurs arithmétiques standards

Les opérateurs arithmétiques utilisent des valeurs numériques comme opérandes, sous forme de littéraux ou de variables, et renvoient une valeur numérique. Les plus utilisés sont l'addition, la soustraction, la multiplication et la division.

Les opérateurs arithmétiques standards (+, -, * et /) fonctionnent de la même manière que toute opération classique.

const maVariableNumerique = 10;
const addition = maVariableNumerique + 5;
// addition vaudra 15
const soustraction = maVariableNumerique - 5;
// soustraction vaudra 5
const multiplication = maVariableNumerique * 5;
// multiplication vaudra 50
const division = maVariableNumerique / 5;
// division vaudra 2

const maVariableNumerique = 10;

const addition = maVariableNumerique + 5;
// addition vaudra 15

const soustraction = maVariableNumerique - 5;
// soustraction vaudra 5


const multiplication = maVariableNumerique * 5;
// multiplication vaudra 50


const division = maVariableNumerique / 5;
// division vaudra 2

Remarque :

En plus des opérateurs arithmétiques standards, JavaScript fournit quelques opérateurs arithmétiques supplémentaires, comme le modulo (%), l'incrémentation (++), la décrémentation (--), le plus et la négation unaire (+ et -).

Le modulo

Le modulo (%) est un opérateur qui renvoie le reste entier de la division entre deux opérandes. Ce reste est toujours plus petit que la valeur du diviseur.

const monNumerateur = 63;
const monDenominateur = 5;
const modulo = monNumerateur % monDenominateur;
// modulo vaudra 3

const monNumerateur = 63;
const monDenominateur = 5;

const modulo = monNumerateur % monDenominateur;
// modulo vaudra 3

let modulo = 63 % 5;
// modulo vaudra 3
modulo = -63 % 5;
// modulo vaudra -3
modulo = 63 % -5;
// modulo vaudra 3
modulo = -63 % -5;
// modulo vaudra -3

let modulo = 63 % 5;
// modulo vaudra 3

modulo = -63 % 5;
// modulo vaudra -3

modulo = 63 % -5;
// modulo vaudra 3

modulo = -63 % -5;
// modulo vaudra -3

L'incrémentation et la décrémentation

L'incrémentation permet d'ajouter 1 à l'opérande et renvoie une valeur numérique. Si l'opérateur est utilisé en suffixe (variable++), il renvoie la valeur avant l'incrémentation. S'il est utilisé en préfixe (++variable), il renvoie la valeur après l'incrémentation.

let maVariable = 5;
const incrementationSuffixe = maVariable++;
// incrementationSuffixe vaudra 5 et maVariable vaudra 6
const incrementationPrefixe = ++maVariable;
// incrementationPrefixe vaudra 6 et maVariable vaudra 6

let maVariable = 5;

const incrementationSuffixe = maVariable++;
// incrementationSuffixe vaudra 5 et maVariable vaudra 6

const incrementationPrefixe = ++maVariable;
// incrementationPrefixe vaudra 6 et maVariable vaudra 6

La décrémentation permet de soustraire 1 à l'opérande et renvoie une valeur numérique. Si l'opérateur est utilisé en suffixe (variable--), il renvoie la valeur avant la décrémentation. S'il est utilisé en préfixe (--variable), il renvoie la valeur après la décrémentation.

let maVariable = 12;
const decrementationSuffixe = maVariable--;
// decrementationSuffixe vaudra 12 et maVariable vaudra 11
const decrementationPrefixe = --maVariable;
// decrementationPrefixe vaudra 11 et maVariable vaudra 11

let maVariable = 12;

const decrementationSuffixe = maVariable--;
// decrementationSuffixe vaudra 12 et maVariable vaudra 11

const decrementationPrefixe = --maVariable;
// decrementationPrefixe vaudra 11 et maVariable vaudra 11

Le plus unaire et la négation unaire

Le plus unaire est situé avant l'opérande et retourne l'opérande, converti en nombre si cela est possible et que ce n'en est pas déjà un. Il permet donc de convertir des chaînes de caractères composées uniquement de nombres entiers ou flottants, ainsi que des booléens et la valeur null. Si l'opération ne peut pas être effectuée, la valeur retournée sera NaN.

NaN représente la valeur « Not a Number ». Cette propriété indique que la valeur n’est pas un nombre « légal » ou, plus simplement, la valeur n’est pas un nombre. Il est rare de l’utiliser dans un programme.

Généralement, on va le récupérer à la suite d’une fonction mathématique qui a échoué ou quand une fonction qui tente d’interpréter un nombre échoue (exemple : parseFloat(« coucou »)).

+12;
// Sera évalué à 12
+"12"
// Sera évalué à 12
+true
// Sera évalué à 1
+false
// Sera évalué à 0
+null
// Sera évalué à 0
+"chaîne de caractères"
// Sera évalué à NaN

+12;
// Sera évalué à 12
+"12"
// Sera évalué à 12
+true
// Sera évalué à 1
+false
// Sera évalué à 0
+null
// Sera évalué à 0
+"chaîne de caractères"
// Sera évalué à NaN

Le moins unaire est situé avant l'opérande et retourne l'opposé de l'opérande, après l'avoir converti en nombre si cela est possible et nécessaire.

let maVariable = 12;
-maVariable;
// Sera évalué à -12
maVariable = -12;
-maVariable;
// Sera évalué à 12
-"12"
// Sera évalué à -12
-true
// Sera évalué à -1
-false
// Sera évalué à 0
-null
// Sera évalué à 0
-"chaîne de caractères"
// Sera évalué à NaN

let maVariable = 12;
-maVariable;
// Sera évalué à -12

maVariable = -12;
-maVariable;
// Sera évalué à 12

-"12"
// Sera évalué à -12

-true
// Sera évalué à -1

-false
// Sera évalué à 0

-null
// Sera évalué à 0

-"chaîne de caractères"
// Sera évalué à NaN

Syntaxe : À retenir

Nous avons vu comment procéder à des opérations standards telles que les additions, soustractions, multiplications et divisions, mais aussi comment incrémenter et décrémenter une valeur, et obtenir le reste entier d'une division grâce au modulo.
Ces opérations sont les plus courantes en JavaScript et seront donc utiles dans de nombreuses situations.

Complément :

Opérateurs arithmétiques