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
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) |