Affectation (=)

Exemple interactif

let x = 2;
const y = 3;

console.log(x);
// Résultat attendu : 2

console.log((x = y + 1)); // 3 + 1
// Résultat attendu : 4

console.log((x = x * y)); // 4 * 3
// Résultat attendu : 12

Syntaxe

x = y

Paramètres

x

Une cible d'affectation valide, y compris un identifiant ou un accès à une propriété. Cela peut également être un modèle de déstructuration.

y

Une expression définissant la valeur à assigner à x.

Valeur de retour

La valeur de y.

Exceptions

ReferenceError

Levée en mode strict si l'on assigne à un identifiant qui n'est pas déclaré dans la portée.

TypeError

Levée en mode strict si l'on assigne à une propriété qui n'est pas modifiable.

Description

L'opérateur d'affectation est complètement différent du signe égal (=) utilisé comme séparateur syntaxique dans d'autres contextes, qui incluent :

• Les opérateurs d'initialisation et de déclarations var, let et const
• Valeurs par défaut de la destructuration
• Paramètres par défaut
• Les opérateurs d'initialisation des champs de classe

Tous ces endroits acceptent une expression d'affectation sur le côté droit du =, donc si vous avez plusieurs signes égaux enchaînés :

const x = y = 5;

C'est l'équivalent de :

const x = (y = 5);

Ce qui signifie que y doit être une variable préexistante, et que x est une nouvelle variable const. y se voit assigner la valeur 5, et x est initialisée avec la valeur de l'expression y = 5, qui est également 5. Si y n'est pas une variable préexistante, une variable globale y est implicitement créée en mode non strict, ou une ReferenceError est levée en mode strict. Pour déclarer deux variables dans la même déclaration, utilisez :

const x = 5,
  y = 5;

Exemples

Affectation simple et variables chaînées

let x = 5;
let y = 10;
let z = 25;

x = y; // x vaut 10
x = y = z; // x, y et z valent toutes 25

Valeur des expressions d'affectation

L'expression d'affectation elle-même est évaluée à la valeur du côté droit, vous pouvez donc enregistrer la valeur et l'affecter à une variable en même temps.

let x;
console.log(x); // undefined
console.log(x = 2); // 2
console.log(x); // 2

Affectation à un identifiant non qualifié

L'objet global se trouve en haut de la chaîne de portée. Lorsqu'on tente de résoudre un nom en une valeur, la chaîne de portée est parcourue. Cela signifie que les propriétés de l'objet global sont facilement visibles depuis chaque portée, sans avoir à qualifier les noms avec globalThis. ou window. ou global..

Comme l'objet global possède une propriété String (Object.hasOwn(globalThis, "String")), vous pouvez utiliser le code suivant :

function toto() {
  String("s"); // La fonction `String` est globalement disponible
}

Ainsi, l'objet global est finalement recherché pour les identifiants non qualifiés. Vous n'avez pas à taper globalThis.String ; vous pouvez simplement taper String non qualifié. Pour rendre cette fonctionnalité plus cohérente sur le plan conceptuel, l'affectation à des identifiants non qualifiés suppose que vous souhaitez créer une propriété portant ce nom sur l'objet global (avec globalThis. omis), s'il n'existe pas de variable du même nom déclarée dans la chaîne de portée.

toto = "t"; // En mode non strict, suppose que vous voulez créer une propriété nommée `toto` sur l'objet global
Object.hasOwn(globalThis, "toto"); // true

En mode strict, l'affectation à un identifiant non qualifié en mode strict entraîne une ReferenceError, afin d'éviter la création accidentelle de propriétés sur l'objet global.

Notez que l'implication de ce qui précède est que, contrairement à une idée reçue, JavaScript n'a pas de variables implicites ou non déclarées. Il confond simplement l'objet global avec la portée globale et permet d'omettre le qualificateur de l'objet global lors de la création de propriétés.

Affectation avec déstructuration

Le côté gauche peut également être un modèle d'affectation. Cela permet d'affecter plusieurs variables en même temps.

const resultat = /(a+)(b+)(c+)/.exec("aaabcc");
let a = "",
  b = "",
  c = "";
[, a, b, c] = resultat;
console.log(a, b, c); // "aaa" "b" "cc"

Pour plus d'informations, voir Déstructuration.

Spécifications

Compatibilité des navigateurs

Voir aussi

• Les opérateurs d'affectation dans le guide JavaScript
• Déstructuration