diff --git a/files/fr/glossary/nullish/index.md b/files/fr/glossary/nullish/index.md
new file mode 100644
index 00000000000000..a6ade0717c72eb
--- /dev/null
+++ b/files/fr/glossary/nullish/index.md
@@ -0,0 +1,10 @@
+---
+title: Valeur nulle (Nullish value)
+slug: Glossary/Nullish
+l10n:
+  sourceCommit: ada5fa5ef15eadd44b549ecf906423b4a2092f34
+---
+
+{{GlossarySidebar}}
+
+En [JavaScript](/fr/docs/Glossary/JavaScript), une valeur nulle (dite «&nbsp;<i lang="en">nullish value</i>&nbsp;» en anglais) est une valeur qui peut être [`null`](/fr/docs/Web/JavaScript/Reference/Operators/null) ou [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined). Les valeurs nulles sont toujours «&nbsp;[<i lang="en">falsy</i>](/fr/docs/Glossary/Falsy)&nbsp;».
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..fc7396c08f960e 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:
+  sourceCommit: 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](/fr/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;
@@ -62,7 +78,7 @@ config({}); // { duration: 100, speed: 25 }
 
 ## Voir aussi
 
-- [L'opérateur de coalescence des nuls (`??`)](/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator)
-- [_Nullish_](/fr/docs/Glossary/Nullish)
-- [_Truthy_](/fr/docs/Glossary/Truthy)
-- [_Falsy_](/fr/docs/Glossary/Falsy)
+- [L'opérateur de coalescence des nuls (`??`)](/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
+- [Valeur nulle (<i lang="en">nullish</i>)](/fr/docs/Glossary/Nullish)
+- [<i lang="en">Truthy</i>](/fr/docs/Glossary/Truthy)
+- [<i lang="en">Falsy</i>](/fr/docs/Glossary/Falsy)