Merge pull request #286 from HachemiH/master

Conflicts fixed after sync with upstream @ 7533c71

Author: HachemiH

1-js/01-getting-started/2-manuals-specifications/article.md

@@ -12,11 +12,7 @@ Une nouvelle version de la spécification est publiée chaque année. La derniè
 
 Pour en savoir plus sur les fonctionnalités à venir, y compris celles qui sont "presque standards" (appelées aussi "stage 3"), vous pouvez consulter les propositions à cette adresse : <https://github.com/tc39/proposals>.
 
-<<<<<<< HEAD
-Si vous développez spécifiquement pour le navigateur, il existe d’autres spécifications couvertes dans la [seconde partie](info:browser-environment) du tutoriel.
-=======
-Also, if you're developing for the browser, then there are other specifications covered in the [second part](info:browser-environment) of the tutorial.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+De plus, si vous développez pour le navigateur, d'autres spécifications sont couvertes dans la [seconde partie](info:browser-environment) du tutoriel.
 
 ## Manuels
 

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md

@@ -9,14 +9,8 @@ true + false = 1
 "$" + 4 + 5 = "$45"
 "4" - 2 = 2
 "4px" - 2 = NaN
-<<<<<<< HEAD
-7 / 0 = Infinity
-" -9  " + 5 = " -9  5" // (3)
-" -9  " - 5 = -14 // (4)
-=======
 "  -9  " + 5 = "  -9  5" // (3)
 "  -9  " - 5 = -14 // (4)
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
 null + 1 = 1 // (5)
 undefined + 1 = NaN // (6)
 " \t \n" - 2 = -2 // (7)

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md

@@ -16,14 +16,8 @@ true + false
 "$" + 4 + 5
 "4" - 2
 "4px" - 2
-<<<<<<< HEAD
-7 / 0
-"  -9\n" + 5
-"  -9\n" - 5
-=======
 "  -9  " + 5
 "  -9  " - 5
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
 null + 1
 undefined + 1
 " \t \n" - 2

1-js/02-first-steps/10-ifelse/2-check-standard/task.md

@@ -6,11 +6,7 @@ importance: 2
 
 En utilisant la construction `if..else`, écrivez le code qui demande : 'Quel est le nom "officiel" de JavaScript?'
 
-<<<<<<< HEAD
-Si le visiteur entre “ECMAScript”, alors éditez “Bonne réponse !”, Sinon -- retourne “Ne sait pas ? ECMAScript!"
-=======
-If the visitor enters "ECMAScript", then output "Right!", otherwise -- output: "You don't know? ECMAScript!"
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Si le visiteur entre "ECMAScript", alors éditez une sortie "Bonne réponse !", Sinon -- retourne "Ne sait pas ? ECMAScript!"
 
 ![](ifelse_task2.svg)
 

1-js/02-first-steps/11-logical-operators/article.md

@@ -1,10 +1,6 @@
 # Opérateurs logiques
 
-<<<<<<< HEAD
-Il y a trois opérateurs logiques en JavaScript : `||` (OR), `&&` (AND), `!` (NOT).
-=======
-There are four logical operators in JavaScript: `||` (OR), `&&` (AND), `!` (NOT), `??` (Nullish Coalescing). Here we cover the first three, the `??` operator is in the next article.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Il y a trois opérateurs logiques en JavaScript : `||` (OR), `&&` (AND), `!` (NOT), `??` (Coalescence des nulles). Nous couvrons ici les trois premiers, l'opérateur `??` est dans l'article suivant.
 
 Bien qu'ils soient appelés "logiques", ils peuvent être appliqués à des valeurs de tout type, pas seulement booléennes. Le résultat peut également être de tout type.
 

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -2,28 +2,17 @@
 
 [recent browser="new"]
 
-<<<<<<< HEAD
-Ici, dans cet article, nous dirons qu'une expression est `defined` lorsqu'elle n'est ni `null` ni `undefined`.
 
 L'opérateur de coalescence des nuls est écrit sous la forme de deux points d'interrogation `??`.
 
+Comme il traite `null` et `undefined` de la même manière, nous utiliserons un terme spécial ici, dans cet article. Nous dirons qu'une expression est "définie" lorsqu'elle n'est ni `null` ni `undefined`.
+
 Le résultat de `a ?? b` est :
 - si `a` est défini, alors `a`,
 - si `a` n'est pas défini, alors `b`.
 
 
 En d'autres termes, `??` renvoie le premier argument s'il n'est pas `nul/undefined`. Sinon, le second.
-=======
-The nullish coalescing operator is written as two question marks `??`.
-
-As it treats `null` and `undefined` similarly, we'll use a special term here, in this article. We'll say that an expression is "defined" when it's neither `null` nor `undefined`.
-
-The result of `a ?? b` is:
-- if `a` is defined, then `a`,
-- if `a` isn't defined, then `b`.
-
-In other words, `??` returns the first argument if it's not `null/undefined`. Otherwise, the second one.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
 
 L'opérateur de coalescence des nuls n'est pas complètement nouveau. C'est juste une belle syntaxe pour obtenir la première valeur "defined" des deux.
 
@@ -33,29 +22,19 @@ Nous pouvons réécrire `result = a ?? b` en utilisant les opérateurs que nous
 result = (a !== null && a !== undefined) ? a : b;
 ```
 
-<<<<<<< HEAD
-Le cas d'utilisation courant de `??` est de fournir une valeur par défaut pour une variable potentiellement indéfinie.
-
-Par exemple, ici nous montrons `Anonymous` si `user` n'est pas défini :
-=======
-Now it should be absolutely clear what `??` does. Let's see where it helps.
+Maintenant, il devrait être absolument clair ce que fait `??`. Voyons où cela aide.
 
-The common use case for `??` is to provide a default value for a potentially undefined variable.
+Le cas d'utilisation courant de `??` est de fournir une valeur par défaut pour une variable potentiellement indéfinie.
 
-For example, here we show `user` if defined, otherwise `Anonymous`:
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Par exemple, ici nous affichons `user` s'il est défini, sinon `Anonymous` :
 
 ```js run
 let user;
 
 alert(user ?? "Anonymous"); // Anonymous (user not defined)
 ```
 
-<<<<<<< HEAD
-Bien sûr, si `user` avait une valeur à l'exception de `null/undefined`, alors nous la verrions à la place :
-=======
-Here's the example with `user` assigned to a name:
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Voici l'exemple avec `user` attribué à un nom :
 
 ```js run
 let user = "John";
@@ -65,15 +44,9 @@ alert(user ?? "Anonymous"); // John (user defined)
 
 Nous pouvons également utiliser une séquence de `??` pour sélectionner la première valeur dans une liste qui n'est pas `null/undefined`.
 
-<<<<<<< HEAD
 Disons que nous avons les données d'un utilisateur dans les variables `firstName`, `lastName` ou `nickName`. Tous peuvent être indéfinis, si l'utilisateur décide de ne pas entrer de valeur.
 
 Nous aimerions afficher le nom d'utilisateur en utilisant l'une de ces variables, ou afficher "Anonymous" si toutes ne sont pas définies.
-=======
-Let's say we have a user's data in variables `firstName`, `lastName` or `nickName`. All of them may be not defined, if the user decided not to enter a value.
-
-We'd like to display the user name using one of these variables, or show "Anonymous" if all of them aren't defined.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
 
 Utilisons l'opérateur `??` pour cela :
 
@@ -104,11 +77,7 @@ alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 */!*
 ```
 
-<<<<<<< HEAD
-L'opérateur OR `||` existe depuis le début de JavaScript, donc les développeurs l'utilisaient à de telles fins depuis longtemps.
-=======
-Historically, the OR `||` operator was there first. It exists since the beginning of JavaScript, so developers were using it for such purposes for a long time.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Historiquement, l'opérateur OR `||` était là en premier. Il existe depuis le début de JavaScript, donc les développeurs l'utilisaient à de telles fins depuis longtemps.
 
 D'un autre côté, l'opérateur de coalescence des nuls `??` n'a été ajouté à JavaScript que récemment, et la raison en était que les gens n'étaient pas tout à fait satisfaits de `||`.
 
@@ -129,33 +98,18 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-<<<<<<< HEAD
-- L'expression `height || 100` vérifie que "height" est une valeur erronée, et c'est vraiment le cas,
-    - donc le résultat est le deuxième argument, `100`.
+- L'expression `height || 100` vérifie que `height` est une valeur fausse, et c'est `0`, elle est fausse en effet.
+    - donc le résultat de `||` est le deuxième argument, `100`.
 - L'expression `height ?? 100` vérifie que `height` est `null/undefined`, et ce n'est pas le cas,
     - donc le résultat est `height` "tel quel", c'est-à-dire `0`.
 
-Si la hauteur zéro est une valeur valide, elle ne doit pas être remplacée par la valeur par défaut, alors `??` fait exactement ce qu'il faut.
+En pratique, la hauteur zéro est souvent une valeur valide, qui ne doit pas être remplacée par la valeur par défaut. Alors `??` fait ce qu'il faut.
 
 ## Priorité
-=======
-- The `height || 100` checks `height` for being a falsy value, and it's `0`, falsy indeed.
-    - so the result of `||` is the second argument, `100`.
-- The `height ?? 100` checks `height` for being `null/undefined`, and it's not,
-    - so the result is `height` "as is", that is `0`.
-
-In practice, the zero height is often a valid value, that shouldn't be replaced with the default. So `??` does just the right thing.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
-
-La priorité de l'opérateur `??` est plutôt faible : `5` dans le [tableau MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
 
-<<<<<<< HEAD
-La priorité de l'opérateur «??» est plutôt faible: «5» dans le [tableau MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table). Ainsi, `??` est évalué avant `=` et `?`, Mais après la plupart des autres opérations, telles que `+`, `*`.
-=======
-The precedence of the `??` operator is about the same as `||`, just a bit lower. It equals `5` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table), while `||` is `6`.
+La priorité de l'opérateur `??` est à peu près la même que celle de `||`, juste un peu plus basse. Il est égal à `5` dans le [tableau MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table), tandis que `||` est `6`.
 
-That means that, just like `||`, the nullish coalescing operator `??` is evaluated before `=` and `?`, but after most other operations, such as `+`, `*`.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Cela signifie que, tout comme `||`, l'opérateur de coalescence des nuls `??` est évalué avant `=` et `?`, Mais après la plupart des autres opérations, telles que `+`, `*`.
 
 Donc, si nous voulons choisir une valeur avec `??` dans une expression avec d'autres opérateurs, pensez à ajouter des parenthèses :
 
@@ -189,11 +143,7 @@ Le code ci-dessous déclenche une erreur de syntaxe :
 let x = 1 && 2 ?? 3; // Syntax error
 ```
 
-<<<<<<< HEAD
-La limitation est sûrement discutable, mais elle a été ajoutée à la spécification du langage dans le but d'éviter les erreurs de programmation, car les gens commencent à passer à `??` à partir de `||`.
-=======
-The limitation is surely debatable, it was added to the language specification with the purpose to avoid programming mistakes, when people start to switch from `||` to `??`.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+La limitation est sûrement discutable, mais elle a été ajoutée à la spécification du langage dans le but d'éviter les erreurs de programmation, quand les gens commencent à passer de `||` à `??`.
 
 Utilisez des parenthèses explicites pour la contourner :
 

1-js/04-object-basics/02-object-copy/article.md

@@ -187,13 +187,9 @@ let clone = Object.assign({}, user);
 
 Cela copie toutes les propriétés de `user` dans l'objet vide et le retourne.
 
-<<<<<<< HEAD
-## Clonage imbriqué
-=======
-There are also other methods of cloning an object, e.g. using the [spread operator](info:rest-parameters-spread) `clone = {...user}`, covered later in the tutorial.
+Il existe également d'autres méthodes de clonage d'un objet, par ex. en utilisant la [syntaxe spread](info:rest-parameters-spread) `clone = {...user}`, abordé plus loin dans le tutoriel.
 
-## Nested cloning
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+## Clonage imbriqué
 
 Jusqu'à maintenat on suppose que toutes les propriétés de `use` sont des primitives. Mais les propriétés peuvent être des références vers d'autres objets. Comment gèrer ces cas-là ?
 

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

@@ -175,15 +175,10 @@ userGuest.admin?.(); // nothing (no such method)
 */!*
 ```
 
-<<<<<<< HEAD
 
-Ici, dans les deux lignes, nous utilisons d'abord le point (`user1.admin`) pour obtenir la propriété `admin`, car l'objet utilisateur doit exister, donc il peut ê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 `user1`). Sinon (pour `user2`) l'évaluation s'arrête sans erreur.
-=======
-Here, in both lines we first use the dot (`userAdmin.admin`) to get `admin` property, because we assume that the user object exists, so it's safe read from it.
+Ici, dans les deux lignes, nous utilisons d'abord le point (`userAdmin.admin`) pour obtenir la propriété `admin`, car l'objet utilisateur doit exister, donc il peut être lu en toute sécurité.
 
-Then `?.()` checks the left part: if the admin function exists, then it runs (that's so for `userAdmin`). Otherwise (for `userGuest`) the evaluation stops without errors.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+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.

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -155,11 +155,7 @@ Nous pouvons échanger plus de deux variables de cette façon.
 
 ### Le rest '...'
 
-<<<<<<< HEAD
-Habituellement, si le tableau est plus long lorsque la liste est à gauche, les éléments "supplémentaires" sont omis.
-=======
-Usually, if the array is longer than the list at the left, the "extra" items are omitted.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Habituellement, si le tableau est plus long que la liste à gauche, les éléments "supplémentaires" sont omis.
 
 Par exemple, ici, seuls deux éléments sont pris et le reste est simplement ignoré :
 

1-js/06-advanced-functions/02-rest-parameters-spread/article.md

@@ -224,28 +224,19 @@ Mais il existe une différence subtile entre `Array.from(obj)` et `[...obj]` :
 Donc, pour transformer quelque chose en tableau, `Array.from` tend à être plus universel.
 
 
-<<<<<<< HEAD
-## Obtenez une nouvelle copie d'un tableau/objet
-=======
-## Copy an array/object
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+## Copier un tableau/objet
 
 Souvenez-vous quand nous avons parlé de `Object.assign()` [par le passé](info:object-copy#cloning-and-merging-object-assign) ?
 
 Il est possible de faire la même chose avec la syntaxe spread !
 
 ```js run
 let arr = [1, 2, 3];
-<<<<<<< HEAD
-let arrCopy = [...arr]; // répartir le tableau dans une liste de paramètres
-                        // puis mettre le résultat dans un nouveau tableau
-=======
 
 *!*
-let arrCopy = [...arr]; // spread the array into a list of parameters
-                        // then put the result into a new array
+let arrCopy = [...arr]; // répartir le tableau dans une liste de paramètres
+                        // puis mettre le résultat dans un nouveau tableau
 */!*
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
 
 // les tableaux ont-ils le même contenu ?
 alert(JSON.stringify(arr) === JSON.stringify(arrCopy)); // true
@@ -263,16 +254,11 @@ Notez qu'il est possible de faire la même chose pour faire une copie d'un objet
 
 ```js run
 let obj = { a: 1, b: 2, c: 3 };
-<<<<<<< HEAD
-let objCopy = { ...obj }; // répartir l'objet dans une liste de paramètres
-                          // puis retourne le résultat dans un nouvel objet
-=======
 
 *!*
-let objCopy = { ...obj }; // spread the object into a list of parameters
-                          // then return the result in a new object
+let objCopy = { ...obj }; // répartir l'objet dans une liste de paramètres
+                          // puis retourne le résultat dans un nouvel objet
 */!*
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
 
 // les objets ont-ils le même contenu ?
 alert(JSON.stringify(obj) === JSON.stringify(objCopy)); // true
@@ -286,11 +272,7 @@ alert(JSON.stringify(obj)); // {"a":1,"b":2,"c":3,"d":4}
 alert(JSON.stringify(objCopy)); // {"a":1,"b":2,"c":3}
 ```
 
-<<<<<<< HEAD
-Cette façon de copier un objet est beaucoup plus courte que `let objCopy = Object.assign({}, obj);` ou pous un tableau `let arrCopy = Object.assign([], arr);` nous préférons donc l'utiliser chaque fois que nous le pouvons.
-=======
-This way of copying an object is much shorter than `let objCopy = Object.assign({}, obj)` or for an array `let arrCopy = Object.assign([], arr)` so we prefer to use it whenever we can.
->>>>>>> 7533c719fbf62ba57188d6d51fe4c038b282bd0c
+Cette façon de copier un objet est beaucoup plus courte que `let objCopy = Object.assign({}, obj)` ou pour un tableau `let arrCopy = Object.assign([], arr);` nous préférons donc l'utiliser chaque fois que nous le pouvons.
 
 
 ## Résumé