MDN may have intermittent access issues April 18 13:00 - April 19 01:00 UTC. See whistlepig.mozilla.org for all notifications.

mozilla
Vos résultats de recherche

    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 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. 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; // 0
    
    // 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 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 Statut Commentaires
    Première édition d'ECMAScript. Standard Définition initiale
    ECMAScript 5.1 (ECMA-262)
    La définition de 'Assignment operators' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'Assignment operators' dans cette spécification.
    En cours de validation comme recommandation  

    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

    Contributors to this page: BenoitL, Jeremie, Goofy, SphinxKnight, teoli
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale