Opérateurs d'affectation

Un opérateur d'affectation permet d'assigner une valeur à son opérande gauche en se basant sur la valeur de son opérande droit.

Description

L'opérateur utilisé pour l'affectation est le symbole égal (=), il permet d'affecter la valeur de l'opérande droit à son opérande gauche. Ainsi, quand on écrit x = y, on affecte la valeur de y à x. Les autres opérateurs d'affectation sont généralement des raccourcis pour des opérations standards. Ils sont décrits ci-après avec définitions et exemples.

Nom Opérateur (raccourci) Signification
Affectation x = y x = y
Affectation après addition x += y x = x + y
Affectation après soustraction x -= y x = x - y
Affectation après multiplication x *= y x = x * y
Affectation après division x /= y x = x / y
Affectation du reste x %= y x = x % y
Affectation après exponentiation x **= y x = x ** y
Affectation après décalage à gauche x <<= y x = x << y
Affectation après décalage à droite x >>= y x = x >> y
Affectation après décalage à droite non-signé x >>>= y x = x >>> y
Affectation après ET binaire x &= y x = x & y
Affectation après OU exclusif binaire x ^= y x = x ^ y
Affectation après OU binaire x |= y x = x | y

Affectation

L'opérateur d'affectation simple permet d'assigner une valeur à une variable. Le résultat de l'affectation est la valeur affectée. Il est possible de chaîner plusieurs opérateurs d'affectation afin d'assigner une même valeur à plusieurs variables. Voir l'exemple ci-après.

Syntaxe

Opérateur : x = y

Exemples

// Si on dispose des variables suivantes :
//  x = 5;
//  y = 10;
//  z = 25;

x = y;     // x vaudra désormais 10
x = y = z; // x, y et z valent désormais tous 25

Affectation après addition

Cet opérateur permet d'ajouter la valeur de l'opérande droit à une variable, le résultat de l'addition étant affecté à cette variable. Les types des deux opérandes déterminent le comportement de l'opérateur. Selon le type, on pourra en effet avoir une addition ou une concaténation. Voir la page sur l'opérateur d'addition for pour plus d'informations.

Syntaxe

Opérateur : x += y 
Signification :  x  = x + y

Exemples

// Si on dispose des variables suivantes :
//  toto = "toto";
//  truc = 5;
//  machin = true;


// Nombre + Nombre -> addition
truc += 2; // 7

// Booléen + Booléen -> addition
machin += 1; // 2

// Booléen + Booléen -> addition
machin += false; // 1

// Nombre + String -> concaténation
truc += "toto"; // "5toto"

// String + Booléen -> concaténation
toto += false; // "totofalse"

// String + String -> concaténation
toto += "truc"; // "totobar"

Affectation après soustraction

Cet opérateur soustrait la valeur de l'opérande droit à la variable puis affecte le résultat de cette soustraction à la variable. Voir la page sur l'opérateur de soustraction pour plus d'information.

Syntaxe

Opérateur : x -= y 
Signification :  x  = x - y

Exemples

// Si on a la variable suivante :
//  truc = 5;

truc -= 2;     // 3
truc -= "toto"; // NaN

Affectation après multiplication

Cet opérateur permet de multiplier une variable par la valeur de l'opérande droit et d'affecter le résultat de cette opération à la variable. Voir la page sur l'opérateur de multiplication pour plus d'informations.

Syntaxe

Opérateur : x *= y 
Signification :  x  = x * y

Exemples

// Si on a la variable suivante :
//  truc = 5;

truc *= 2;     // 10
truc *= "toto"; // NaN

Affectation après division

Cet opérateur permet de diviser une variable par la valeur de l'opérande droit et d'affecter le résultat de cette opération à la variable. Voir la page sur l'opérateur de division pour plus d'informations.

Syntaxe

Opérateur : x /= y 
Signification :  x  = x / y

Exemples

// Si on a la variable suivante :
//  truc = 5;

truc /= 2;     // 2.5
truc /= "toto"; // NaN
truc /= 0;     // Infinity

Affectation du reste

Cet opérateur permet de divisier une variable par la valeur de l'opérande droit et d'affecter le reste de cette division à la variable. Pour plus d'informations, voir la page sur l'opérateur reste.

Syntaxe

Opérateur : x %= y 
Signification :  x  = x % y

Exemples

// Si on a la variable suivante :
//  truc = 5;

truc %= 2;      // 1
truc %= "toto"; // NaN
truc %= 0;      // NaN

Affectation après exponentiation

Cette fonctionnalité fait partie des propositions pour Harmony (ECMAScript7) et est donc expérimentale.
Cette spécification technique n'a pas encore été stabilisée, veuillez consulter le tableau de compatibilité pour plus d'informations sur les éventuelles différences entre les navigateurs. Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur, en fonction des évolutions de la spécification.

L'opérateur d'affectation après exponentiation renvoie le résultat de l'élévation du premier opérande à la puissance donnée par le second opérande. Pour plus de détails, voir la page sur l'opérateur d'exponentiation for more details.

Syntaxe

Opérateur : x **= y 
Signification :  x  = x ** y

Exemples

// Si on a la variable :
//  toto = 5

toto **= 2      // 25
toto **= "truc" // NaN

Affectation après décalage à gauche

Cet opérateur permet de décaler un nombre donné de bits vers la gauche, le résultat de l'opération est ensuite affecté à la variable. Voir la page sur l'opérateur de décalage à gauche pour plus d'informations.

Syntaxe

Opérateur : x <<= y 
Signification :  x   = x << y

Exemples

var toto = 5; //  (00000000000000000000000000000101)
toto <<= 2;   // 20 (00000000000000000000000000010100)

Affectation après décalage à droite

Cet opérateur permet de décaler un nombre donné de bits vers la droite, le résultat de l'opération est ensuite affecté à la variable. Voir la page sur l'opérateur de décalage à droite pour plus d'informations.

Syntaxe

Opérateur : x >>= y 
Signification :  x   = x >> y

Exemples

var toto = 5; //   (00000000000000000000000000000101)
toto >>= 2;   // 1 (00000000000000000000000000000001)

var toto -5; //    (-00000000000000000000000000000101)
toto >>= 2;  // -2 (-00000000000000000000000000000010)

Affectation après décalage à droite non-signé

Cet opérateur permet de décaler le contenu de la variable d'un nombre de bits donné pour ensuite affecter le résultat à la variable. Voir la page sur l'opérateur de décalage à droite non-signé pour plus de détails.

Syntaxe

Opérateur : x >>>= y 
Signification :  x    = x >>> y

Exemples

var toto = 5; //   (00000000000000000000000000000101)
toto >>>= 2;  // 1 (00000000000000000000000000000001)

var toto = -5; // (-00000000000000000000000000000101)
toto >>>= 2; // 1073741822 (00111111111111111111111111111110)

Affectation après ET binaire

Cet opérateur effectue une opération ET binaire sur les deux opérandes et affecte le résultat de l'opération à la variable (l'opérande gauche). Pour plus d'informations sur cette opération, voir la page sur l'opérateur binaire ET.

Syntaxe

Opérateur : x &= y 
Signification :  x  = x & y

Exemple

var truc = 5;
// 5:     00000000000000000000000000000101
// 2:     00000000000000000000000000000010
truc &= 2; // 0

Affectation après OU exclusif (XOR) binaire

Cet opérateur utilise une représentation binaire des deux opérandes, effectue une opération binaire avec un OU exclusif et affecte le résultat à la variable. Pour plus d'informations sur cette opération, voir la page sur l'opérateur binaire OU exclusif.

Syntaxe

Opérateur : x ^= y 
Signification :  x  = x ^ y

Exemple

var toto = 5;
toto ^= 2; // 7
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
// -----------------------------------
// 7: 00000000000000000000000000000111

Affectation après OU binaire

Cet opérateur utilise une représentation binaire des deux opérandes, effectue un OU logique binaire entre ces deux variables et affecte le résultat de l'opération à la variable. Pour plus de détails sur cette opération, voir la page sur l'opérateur OU binaire.

Syntaxe

Opérateur : x |= y 
Signification :  x  = x | y

Exemple

var toto = 5;
toto |= 2; // 7
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
// -----------------------------------
// 7: 00000000000000000000000000000111

Exemples

Opérande gauche utilisé avec un autre opérateur d'affectation

Dans certains cas, l'opérateur d'affectation (par exemple x += y) n'est pas identique à l'expression développée correspondante (respectivement x = x + y). Lorsque l'opérande gauche contient lui-même un opérateur d'affectation, l'opérande gauche n'est évalué qu'une fois. Ainsi :

a[i++] += 5         // i est évalué une fois
a[i++] = a[i++] + 5 // i est évalué deux fois

Spécifications

Spécification État Commentaires
ECMAScript 2017 Draft (ECMA-262)
La définition de 'Assignment operators' dans cette spécification.
Projet  
ECMAScript 2015 (6th Edition, ECMA-262)
La définition de 'Assignment operators' dans cette spécification.
Standard  
ECMAScript 5.1 (ECMA-262)
La définition de 'Assignment operators' dans cette spécification.
Standard  
ECMAScript 1st Edition (ECMA-262)
La définition de 'Assignment operators' dans cette spécification.
Standard Définition initiale

Compatibilité des navigateurs

Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
Support simple (Oui) (Oui) (Oui) (Oui) (Oui)
Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Support simple (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)

Voir aussi

Étiquettes et contributeurs liés au document

 Contributeurs à cette page : SphinxKnight, Goofy, teoli, Jeremie, BenoitL
 Dernière mise à jour par : SphinxKnight,