From 9e2ed77eddd362b7c50a99ce69578702b7376ff9 Mon Sep 17 00:00:00 2001
From: tristantheb <tristantheb@gmail.com>
Date: Wed, 17 Jan 2024 19:28:05 +0100
Subject: [PATCH] Update nullish coalescing assignment operator

* Fix #17920 example
* Update from en_US
---
 .../nullish_coalescing_assignment/index.md    | 46 +++++++++++++------
 1 file changed, 31 insertions(+), 15 deletions(-)

diff --git a/files/fr/web/javascript/reference/operators/nullish_coalescing_assignment/index.md b/files/fr/web/javascript/reference/operators/nullish_coalescing_assignment/index.md
index ed99571aae9fd4..96cba36128e337 100644
--- a/files/fr/web/javascript/reference/operators/nullish_coalescing_assignment/index.md
+++ b/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 «&nbsp;x&nbsp;» soit  une constante «&nbsp;const&nbsp;»&nbsp;:
 
-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 «&nbsp;setter&nbsp;»&nbsp;:
 
 ```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 «&nbsp;x&nbsp;» n'est pas nul, «&nbsp;y&nbsp;» 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;