Minor fixes in '1-js/04-object-basics/07-optional-chaining/article.md'

Author: ArmandDelessert

1-js/04-object-basics/07-optional-chaining/article.md

@@ -32,19 +32,19 @@ Dans de nombreux cas pratiques, nous préférerions obtenir `undefined` au lieu
 let html = document.querySelector('.elem').innerHTML; // error if it's null
 ```
 
-Encore une fois, si l'élément n'existe pas, nous obtiendrons une erreur lors de l'accès à la propriété `.innerHTML` de` null`. Et dans certains cas, lorsque l'absence de l'élément est normale, nous aimerions éviter l'erreur et accepter simplement `html = null` comme résultat.
+Encore une fois, si l'élément n'existe pas, nous obtiendrons une erreur lors de l'accès à la propriété `.innerHTML` de `null`. Et dans certains cas, lorsque l'absence de l'élément est normale, nous aimerions éviter l'erreur et accepter simplement `html = null` comme résultat.
 
 Comment peut-on le faire ?
 
-La solution évidente serait de vérifier la valeur en utilisant `if` ou l'opérateur conditionnel `?`, Avant d'accéder à sa propriété, comme ceci :
+La solution évidente serait de vérifier la valeur en utilisant `if` ou l'opérateur conditionnel `?`, avant d'accéder à sa propriété, comme ceci :
 
 ```js
-let user = {};
+let user = {}; // l'utilisateur n'a pas d'adresse
 
 alert(user.address ? user.address.street : undefined);
 ```
 
-Cela fonctionne, il n'y a pas d'erreur ... Mais c'est assez inélégant. Comme vous pouvez le voir, `"user.address"` apparaît deux fois dans le code.
+Cela fonctionne, il n'y a pas d'erreur... Mais c'est assez inélégant. Comme vous pouvez le voir, `"user.address"` apparaît deux fois dans le code.
 
 Voici à quoi ressemblerait la même chose pour `document.querySelector` :
 
@@ -76,9 +76,9 @@ alert( user.address && user.address.street && user.address.street.name ); // und
 
 Et le chemin complet vers la propriété garantit que tous les composants existent (sinon, l'évaluation s'arrête), mais n'est pas non plus idéal.
 
-Comme vous pouvez le voir, les noms de propriétés sont toujours dupliqués dans le code. Par exemple. dans le code ci-dessus, `user.address` apparaît trois fois.
+Comme vous pouvez le voir, les noms de propriétés sont toujours dupliqués dans le code. Par exemple, dans le code ci-dessus, `user.address` apparaît trois fois.
 
-C'est pourquoi le chaînage facultatif `?.` A été ajouté au langage. Pour résoudre ce problème une fois pour toutes !
+C'est pourquoi le chaînage facultatif `?.` a été ajouté au langage. Pour résoudre ce problème une fois pour toutes !
 
 
 ## Chaînage optionnel
@@ -88,23 +88,24 @@ Le chaînage optionnel `?.` arrête l'évaluation si la valeur avant `?.` est `u
 **Plus loin dans cet article, par souci de brièveté, nous dirons que quelque chose "existe" si ce n'est pas "null" et non "undefined".**
 
 En d'autres termes, `value?.prop` :
+
 - est identique à `value.prop` si `value` existe,
-- sinon (lorsque `value` est `undefined/nul`), il renvoie `undefined`.
+- sinon (lorsque `value` est `undefined`/`null`), il renvoie `undefined`.
 
 Voici le moyen sûr d'accéder à `user.address.street` en utilisant `?.` :
 
 ```js run
 let user = {}; // l'utilisateur n'a pas d'adresse
 
-alert( user?.address?.street ); // undefined (no error)
+alert( user?.address?.street ); // undefined (pas d'erreur)
 ```
 
 Le code est court et propre, il n'y a aucune duplication.
 
 Voici un exemple avec `document.querySelector` :
 
 ```js run
-let html = document.querySelector('.elem')?.innerHTML; // will be undefined, if there's no element
+let html = document.querySelector('.elem')?.innerHTML; // sera undefined s'il n'y a pas d'élément
 ```
 
 La lecture de l'adresse avec `user?.address` fonctionne même si l'objet `user` n'existe pas :
@@ -116,9 +117,9 @@ alert( user?.address ); // undefined
 alert( user?.address.street ); // undefined
 ```
 
-Remarque: la syntaxe `?.` Rend facultative la valeur qui la précède, mais pas plus.
+Remarque : la syntaxe `?.` rend facultative la valeur qui la précède, mais pas plus.
 
-Par exemple. dans `user?.address.street.name` le `?.` permet à `user` d'être en toute sécurité `null/undefined` (et renvoie `undefined` dans ce cas), mais ce n'est que pour `user`. D'autres propriétés sont accessibles de manière régulière. Si nous voulons que certaines d'entre elles soient optionnelles, alors nous devrons remplacer plus de `.` par `?.`.
+Par exemple, dans `user?.address.street.name` le `?.` permet à `user` d'être en toute sécurité `null`/`undefined` (et renvoie `undefined` dans ce cas), mais ce n'est que pour `user`. D'autres propriétés sont accessibles de manière régulière. Si nous voulons que certaines d'entre elles soient optionnelles, alors nous devrons remplacer plus de `.` par `?.`.
 
 ```warn header="N'abusez pas du chaînage optionnel"
 Nous ne devrions utiliser `?.` que là où il est normal que quelque chose n'existe pas.
@@ -179,15 +180,15 @@ userAdmin.admin?.(); // I am admin
 */!*
 
 *!*
-userGuest.admin?.(); // nothing happens (no such method)
+userGuest.admin?.(); // rien ne se passe (aucune méthode de ce nom)
 */!*
 ```
 
 Ici, dans les deux lignes, nous utilisons d'abord le point (`userAdmin.admin`) pour obtenir la propriété `admin`, car nous supposons que l'objet `user` existe, il peut donc être lu en toute sécurité.
 
-Puis `?.()` Vérifie la partie gauche : si la fonction `admin` existe, alors elle s'exécute (c'est le cas pour `userAdmin`). Sinon (pour `userGuest`) l'évaluation s'arrête sans erreur.
+Puis `?.()` vérifie la partie gauche : si la fonction `admin` existe, alors elle s'exécute (c'est le cas pour `userAdmin`). Sinon (pour `userGuest`) l'évaluation s'arrête sans erreur.
 
-La syntaxe `?.[]` Fonctionne également, si nous voulons utiliser des crochets `[]` pour accéder aux propriétés au lieu du point `.`. Similaire aux cas précédents, il permet de lire en toute sécurité une propriété à partir d'un objet qui peut ne pas exister.
+La syntaxe `?.[]` fonctionne également, si nous voulons utiliser des crochets `[]` pour accéder aux propriétés au lieu du point `.`. Similaire aux cas précédents, il permet de lire en toute sécurité une propriété à partir d'un objet qui peut ne pas exister.
 
 ```js run
 let key = "firstName";
@@ -224,13 +225,13 @@ Ce n'est tout simplement pas si intelligent.
 
 ## Résumé
 
-Le chaînage optionnel '?.' A trois formes :
+Le chaînage optionnel '?.' a trois formes :
 
 1. `obj?.prop` -- retourne `obj.prop` si `obj` existe, sinon `undefined`.
 2. `obj?.[prop]` -- retourne `obj[prop]` si `obj` existe, sinon `undefined`.
-3. `obj?.method()` -- appel `obj.method()` si `obj.method` existe, sinon retourne `undefined`.
+3. `obj.method?.()` -- appel `obj.method()` si `obj.method` existe, sinon retourne `undefined`.
 
-Comme nous pouvons le voir, tous sont simples et simples à utiliser. Le `?.` vérifie la partie gauche pour `null/undefined` et permet à l'évaluation de se poursuivre si ce n'est pas le cas.
+Comme nous pouvons le voir, tous sont simples et simples à utiliser. Le `?.` vérifie la partie gauche pour `null`/`undefined` et permet à l'évaluation de se poursuivre si ce n'est pas le cas.
 
 Une chaîne de `?.` permet d'accéder en toute sécurité aux propriétés imbriquées.