Update nullish coalescing assignment operator

* Fix mdn#17920 example
* Update from en_US

files/fr/web/javascript/reference/operators/nullish_coalescing_assignment/index.md

@@ -1,46 +1,62 @@
 ---
 title: Affectation après coalescence des nuls (??=)
 slug: Web/JavaScript/Reference/Operators/Nullish_coalescing_assignment
+l10n:
+  commitSource: 71cf0cb885d46d83af054ae4df350248e246f006
 ---
 
 {{jsSidebar("Operators")}}
 
-L'opérateur d'affectation après coalescence des nuls (`x ??= y`) effectue une affectation uniquement si l'opérande de gauche (`x`) vaut [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null) ou [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null).
+L'opérateur d'**affectation de coalescence des nuls (`??=`)**, également connu sous le nom d'opérateur **affectation logique nulle**, évalue uniquement l'opérande de droite et l'attribue à gauche si l'opérande de gauche est [nulle](/fr/docs/Glossary/Nullish) (`null` ou `undefined`).
 
-{{EmbedInteractiveExample("pages/js/expressions-logical-nullish-assignment.html")}}
+{{EmbedInteractiveExample("pages/js/expressions-nullish-coalescing-assignment.html")}}
 
 ## Syntaxe
 
-```js
-expr1 ??= expr2;
+```js-nolint
+x ??= y
 ```
 
 ## Description
 
-### Évaluation en court-circuit
-
-L'opérateur de [coalescence des nuls](/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator) est évalué de gauche à droite et le moteur teste s'il est possible d'utiliser un court-circuit grâce à la règle suivante :
+L'opérateur de coalescence des nuls est un [_court-circuit_](/fr/docs/Web/JavaScript/Reference/Operators/Operator_precedence#court-circuit), ce qui signifie que `x ??= y` est équivalent à `x ?? (x = y)`, sauf que l'expression `x` n'est évaluée qu'une seule fois.
 
-`(une expression qui renvoie null ou undefined) ?? expr` sera court-circuité pour fournir l'opérande gauche si celle-ci ne vaut ni `null` ni `undefined`.
+Aucune affectation n'est effectuée si le côté gauche n'est pas nul, en raison d'un court-circuit de l'opérateur de [coalescence des nuls](/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing). Par exemple, ce qui suit ne génère pas d'erreur, bien que « x » soit  une constante « const » :
 
-Ce « court-circuit » implique que l'expression `expr` **n'est pas évaluée** si ce n'est pas nécessaire. Ainsi, tout effet de bord lié à celle-ci n'aura pas lieu (par exemple, si `expr` appelle une fonction, cette dernière n'est pas exécutée).
+```js
+const x = 1;
+x ??= 2;
+```
 
-L'opérateur d'affectation après coalescence des nuls obéit également à cette logique. Ainsi, `x ??= y` sera équivalent à :
+Les éléments suivants ne déclencheront pas non plus le « setter » :
 
 ```js
-x ?? (x = y);
+const x = {
+  get value() {
+    return 1;
+  },
+  set value(v) {
+    console.log("Assignation appelée");
+  },
+};
+
+x.value ??= 2;
 ```
 
-En revanche, ce ne sera pas équivalent à l'expression suivante qui effectue une affectation quoi qu'il arrive :
+En fait, si « x » n'est pas nul, « y » n'est pas du tout évalué.
 
-```js example-bad
-x = x ?? y;
+```js
+const x = 1;
+x ??= console.log("y est évalué");
+// Ne génère pas de sortie
 ```
 
-## Exemples
+## Exemple
 
 ### Utiliser l'opérateur d'affectation après coalescence des nuls
 
+Vous pouvez utiliser l'opérateur d'affectation de coalescence des nuls pour appliquer des valeurs par défaut aux propriétés d'objet. Par rapport à l'utilisation de la déstructuration et des [valeurs par défaut](/fr/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#valeurs-par-défaut), `??=` applique également la valeur par défaut si la propriété a pour valeur `null`.
+
 ```js
 function config(options) {
   options.duration ??= 100;