path: root/files/fr/conflicting/web/javascript/reference/operators/index.html

---
title: Opérateurs arithmétiques
slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques
tags:
  - JavaScript
  - Operator
  - Reference
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
---
<div>{{jsSidebar("Operators")}}</div>

<p><strong>Les opérateurs arithmétiques </strong>utilisent des valeurs numériques (variables ou littéraux) comme opérandes et renvoient une valeur numérique. Les opérateurs arithmétiques standard sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/).</p>

<div>{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}</div>

<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>

<h2 id="Addition_2"><a name="Addition">Addition (+)</a></h2>

<p>L'opérateur d'addition permet d'obtenir la somme des opérandes numériques ou bien la concaténation de chaînes de caractères.</p>

<h3 id="Syntaxe">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : x + y</pre>

<h3 id="Exemples">Exemples</h3>

<pre class="brush: js">// nombre + nombre -&gt; addition
1 + 2 // 3

// booléen + nombre -&gt; addition
true + 1 // 2

// booléen + booléen -&gt; addition
false + false // 0

// nombre + chaîne de caractères -&gt; concaténation
5 + "

 concaténation
"toto" + false // "totofalse"

// chaîne de caractères + chaîne de caractères -&gt; concaténation
"toto" + "truc" // "tototruc"
</pre>

<h2 id="Soustraction_-"><a name="Subtraction">Soustraction (-)</a></h2>

<p>L'opérateur de soustraction soustrait les deux opérandes pour obtenir leur différence.</p>

<h3 id="Syntaxe_2">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : x - y</pre>

<h3 id="Exemples_2">Exemples</h3>

<pre class="brush:js">5 - 3 // 2
3 - 5 // -2
"toto" - 3 // NaN
</pre>

<h2 id="Division_2"><a name="Division">Division (/)</a></h2>

<p>L'opérateur de division produit le quotient de ces opérandes avec l'opérande gauche comme numérateur et l'opérande droit comme dénominateur.</p>

<h3 id="Syntaxe_3">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : x / y</pre>

<h3 id="Exemples_3">Exemples</h3>

<pre class="brush: js">1 / 2      // renvoie 0.5 en JavaScript
1 / 2      // renvoie 0 en Java
// (aucun des deux opérandes n'est un nombre flottant de façon explicite)

1.0 / 2.0  // renvoie 0.5 en JavaScript et Java

2.0 / 0    // renvoie Infinity (pour l'infini) en JavaScript
2.0 / 0.0  // renvoie Infinity également
2.0 / -0.0 // renvoie -Infinity en JavaScript</pre>

<h2 id="Multiplication_*"><a name="Multiplication">Multiplication (*)</a></h2>

<p>L'opérateur de multiplication permet d'obtenir le produit des opérandes.</p>

<h3 id="Syntaxe_4">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : x * y</pre>

<h3 id="Exemples_4">Exemples</h3>

<pre class="brush: js">2 * 2 // 4
-2 * 2 // -4
Infinity * 0 // NaN
Infinity * Infinity // Infinity
"toto" * 2 // NaN
</pre>

<h2 id="Reste"><a name="Remainder">Reste (%)</a></h2>

<p>L'opérateur « reste » renvoie le reste de la division du premier opérande par le second. Le résultat obtenu a toujours le signe du numérateur (la quantité divisée).</p>

<h3 id="Syntaxe_5">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : var1 % var2</pre>

<h3 id="Exemples_5">Exemples</h3>

<pre class="brush: js">12 % 5  // 2
-1 % 2  // -1
1 % -2  // 1
NaN % 2 // NaN
1 % 2   // 1
2 % 3   // 2
-4 % 2  // -0
5.5 % 2 // 1.5</pre>

<h2 id="Exponentiation_**"><a id="Exponentiation" name="Exponentiation">Exponentiation (**)</a></h2>

<p>L'opérateur d'exponentiation (aussi appelé opérateur de puissance) renvoie le résultat de l'élévation d'un nombre (premier opérande) à une puissance donnée (deuxième opérande). Par exemple : <code>var1 ** var2</code> sera équivalent à <code>var1<sup>var2</sup></code> en notation mathématique. Cet opérateur est associatif à droite, autrement dit <code>a ** b ** c</code> est égal à <code>a ** (b ** c)</code>.</p>

<h3 id="Syntaxe_6">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : var1 ** var2</pre>

<h3 id="Notes">Notes</h3>

<p>Dans la plupart des langages (par exemple PHP, Python, etc.), l'opérateur d'exponentiation est défini avec une précédence supérieure à celle des opérateurs unaires tels que le plus unaire et le moins unaire. Des exceptions existent comme Bash où l'opérateur ** a une précédence inférieure à celle des opérateurs unaires. En JavaScript, il est impossible d'écrire une expression ambigüe avec l'exponentiation : il est impossible de placer un opérateur unaire juste avant le nombre.</p>

<pre class="brush: js">-2 ** 2;
// vaut 4 en Bash ou -4 avec d'autres langages
// C'est invalide en JavaScript car il y
// une ambiguïté liée à l'expression

- (2 ** 2);
// -4 en JavaScript car les parenthèses lèvent
// l'ambiguïté
</pre>

<h3 id="Exemples_6">Exemples</h3>

<pre class="brush: js">2 ** 3 // 8
3 ** 2 // 9
3 ** 2.5 // 15.588457268119896
10 ** -1 // 0.1
NaN ** 2 // NaN

2 ** 3 ** 2 // 512
2 ** (3 ** 2) // 512
(2 ** 3) ** 2 // 64</pre>

<div class="note">
<p><strong>Note :</strong> JavaScript possède également <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(XOR_binaire)">un opérateur binaire ^ (XOR logique)</a>. <code>**</code> et <code>^</code> sont deux opérateurs bien différents. Par exemple <code>2 ** 3 === 8</code> et <code>2 ^ 3 === 1</code>.</p>
</div>

<h2 id="Incrément"><a name="Increment">Incrément (++)</a></h2>

<p>L'opérateur d'incrément ajoute une unité à son opérande et renvoie une valeur.</p>

<ul>
 <li>Si l'opérateur est utilisé en suffixe (par exemple : x++), il renvoie la valeur avant l'incrémentation.</li>
 <li>Si l'opérateur est utilisé en préfixe (par exemple : ++x), il renvoie la valeur après l'incrémentation.</li>
</ul>

<h3 id="Syntaxe_7">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : x++ ou ++x</pre>

<h3 id="Exemples_7">Exemples</h3>

<pre class="brush: js">// Suffixe
var x = 3;
y = x++; // y = 3, x = 4

// Préfixe
var a = 2;
b = ++a; // a = 3, b = 3
</pre>

<h2 id="Décrément_--"><a name="Decrement">Décrément (--)</a></h2>

<p>L'opérateur de décrément soustrait une unité à son opérande et renvoie une valeur.</p>

<ul>
 <li>Si l'opérateur est utilisé en suffixe (par exemple : x--), il renvoie la valeur avant la décrémentation.</li>
 <li>Si l'opérateur est utilisé en préfixe (par exemple : --x), il renvoie la valeur après la décrémentation.</li>
</ul>

<h3 id="Syntaxe_8">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : x-- ou --x</pre>

<h3 id="Exemples_8">Exemples</h3>

<pre class="brush: js">// Suffixe
var x = 3;
y = x--; // y = 3, x = 2

// Préfixe
var a = 2;
b = --a; // a = 1, b = 1
</pre>

<h2 id="Négation_unaire_-"><a name="Unary_negation">Négation unaire (-)</a></h2>

<p>L'opérateur de négation unaire précède son opérande et prend l'opposé de celui-ci (après l'avoir converti en nombre si besoin).</p>

<h3 id="Syntaxe_9">Syntaxe</h3>

<pre class="syntaxbox">Opérateur : -x</pre>

<h3 id="Exemples_9">Exemples</h3>

<pre class="brush: js">var x = 3;
y = -x; // y = -3, x = 3

// La négation unaire permet de convertir
// un opérande en nombre
var y = "4";
var z = -y; // z = -4
</pre>

<h2 id="Plus_unaire"><a name="Unary_plus">Plus unaire</a> (+)</h2>

<p>L'opérateur unaire plus (+) précède son opérande, l'évaluation correspond à son opérande, converti en nombre si possible et si ce n'est pas déjà un nombre. Bien que l'opérateur de négation unaire (-) puisse également convertir les expressions qui ne sont pas des nombres, le plus unaire est la méthode la plus efficace et celle la plus utilisée pour convertir quelque chose en un nombre car la conversion est la seule opération effectuée. Cet opérateur permet de convertir les chaînes de caractères représentant des nombres entiers, des nombres flottants ainsi que les valeurs <code>true</code>, <code>false</code>, et <code>null</code>. Les entiers, représentés sous forme décimale ou hexadécimale (préfixés par "0x"), sont supportés. Les nombres négatifs sont également supportés (mais pas au format hexadécimal). Si l'opérateur ne peut pas analyser l'opérande fourni, il sera évalué à <a href="/fr/docs/JavaScript/Reference/Propriétés_globales/NaN">NaN</a>.</p>

<h3 id="Syntaxe_10">Syntaxe</h3>

<pre class="syntaxbox">Opérator : +x</pre>

<h3 id="Exemples_10">Exemples</h3>

<pre class="brush: js">+3     // 3
+"3"   // 3
+true  // 1
+false // 0
+null  // 0
+function(val){ return val; } // NaN
</pre>

<h2 id="Spécifications">Spécifications</h2>

<table class="standard-table">
 <thead>
  <tr>
   <th scope="col">Spécification</th>
   <th scope="col">État</th>
   <th scope="col">Commentaires</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-additive-operators')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ES2017', '#sec-postfix-expressions')}}</td>
   <td>{{Spec2('ES2017')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td>
   <td>{{Spec2('ES2016')}}</td>
   <td><a href="https://github.com/rwaldron/exponentiation-operator">Ajout de l'opérateur d'exponentiation.</a></td>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td>Définis au sein de plusieurs sections de cette spécification : <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Opérateurs additifs</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">opérateurs multiplicatifs</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">expressions postfixes</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">opérateurs unaires</a>.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td>Définis au sein de plusieurs sections de cette spécification : <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Opérateurs additifs</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.5">opérateurs multiplicatifs</a>,<a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.3"> expressions postfixes</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.4">opérateurs unaires</a>.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Définition initiale</td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>

<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>

<p>{{Compat("javascript.operators.arithmetic")}}</p>

<h2 id="Voir_aussi">Voir aussi</h2>

<ul>
 <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">Opérateurs d'affectation</a></li>
</ul>