Merge branch 'master' into sync-eda333d4

Author: HachemiH

1-js/03-code-quality/02-coding-style/article.md

@@ -60,27 +60,27 @@ Une construction sur une seule ligne, comme `if (condition) doSomething()`, est
 
 Voici les variantes annotées pour que vous puissiez juger de leur lisibilité :
 
-1. 😠 Beginners sometimes do that. Bad! Curly braces are not needed:
+1. 😠 Les débutants font parfois cela. C'est une mauvaise pratique! Les accolades ne sont pas nécessaires :
     ```js
     if (n < 0) *!*{*/!*alert(`Power ${n} is not supported`);*!*}*/!*
     ```
-2. 😠 Split to a separate line without braces. Never do that, easy to make an error when adding new lines:
+2. 😠 Lorsque vous n'utilisez pas d'accolades, évitez de passer pas à la ligne, il est facile de se tromper! :
     ```js
     if (n < 0)
       alert(`Power ${n} is not supported`);
     ```
-3. 😏 One line without braces - acceptable, if it's short:
+3. 😏 Ne pas utiliser d'accolade sur une seule ligne, est acceptable tant que cela reste court :
     ```js
     if (n < 0) alert(`Power ${n} is not supported`);
     ```
-4. 😃 The best variant:
+4. 😃 Voici une bonne manière de faire :
     ```js
     if (n < 0) {
       alert(`Power ${n} is not supported`);
     }
     ```
 
-For a very brief code, one line is allowed, e.g. `if (cond) return null`. But a code block (the last variant) is usually more readable.
+Pour un code tres court, une ligne est autorisée, par exemple. `if (cond) return null`. Mais la variante numéro 4 est généralement plus lisible.
 
 
 ### Longueur de la ligne

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

@@ -31,7 +31,7 @@ let user = {
 };
 ```
 
-Et ici comment elle est stockée en mémmoire :
+Et ici comment elle est stockée en mémoire :
 
 ![](variable-contains-reference.svg)
 
@@ -77,9 +77,9 @@ C'est comme si nous avions une armoire avec deux clés et que nous en utilisions
 
 ## Comparaison par référence
 
-Deux objets sont egaux seulement s'ils sont le même objet.
+Deux objets sont égaux seulement s'ils sont le même objet.
 
-Par exemple, ici `a` et `b` référence le même objet, aussi sont-ils similaires :
+Par exemple, ici `a` et `b` référencent le même objet, aussi sont-ils similaires :
 
 ```js run
 let a = {};
@@ -98,7 +98,7 @@ let b = {}; // 2 objets indépendants
 alert( a == b ); // false
 ```
 
-Pour des comparaisons comme `obj1 > obj2` ou des comparaisons avec une primitive `obj == 5`, les objets sont convertis en primitive. Nous étudierons comment les conversions d'objets fonctionnent très bientôt, mais pour dire la vérité, de telles comparaisons sont rarement nécessaires, en général elles sont le résultat d'une erreur de programmation.
+Pour des comparaisons comme `obj1 > obj2` ou des comparaisons avec une primitive `obj == 5`, les objets sont convertis en primitives. Nous étudierons comment les conversions d'objets fonctionnent très bientôt, mais pour dire la vérité, de telles comparaisons sont rarement nécessaires, en général elles sont le résultat d'une erreur de programmation.
 
 ## Clonage et fusion, Object.assign [#clonage-et-fusion-object-assign]
 
@@ -133,11 +133,8 @@ clone.name = "Pete"; // On change les données de celui-ci
 alert( user.name ); // c'est toujour john dans l'objet copié
 ```
 
-<<<<<<< HEAD
-On peu aussi utiliser la méthode [Object.assign](mdn:js/Object/assign) pour cela.
-=======
-Also we can use the method [Object.assign](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) for that.
->>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
+On peut aussi utiliser la méthode [Object.assign](mdn:js/Object/assign) pour cela.
+
 
 La syntaxe est :
 
@@ -147,7 +144,7 @@ Object.assign(dest, [src1, src2, src3...])
 
 - Le premier argument `dest` est l'objet cible
 - Les arguments suivants `src1, ..., srcN` (cela peut-être tant que l'on veut) sont les objets à copier.
-- La méthode copie les propriétés de toutes les objets à copier `src1, ..., srcN` dans l'objet `dest`. En d'autres mots, les propriétés de tous les arguments à partir du deuxième sont copiés dans le premier argument.
+- La méthode copie les propriétés de tous les objets à copier `src1, ..., srcN` dans l'objet `dest`. En d'autres mots, les propriétés de tous les arguments à partir du deuxième sont copiés dans le premier argument.
 - L'appel retourne `dest`.
 
 Par exemple, on peut l'utiliser pour fusioner plusieurs objets en un seul :
@@ -176,7 +173,7 @@ Object.assign(user, { name: "Pete" });
 alert(user.name); // on a user = { name: "Pete" }
 ```
 
-On peut aussi utiliser `Object.assign` to replace `for..in` boucle pour un clonage simple.
+On peut aussi utiliser `Object.assign` pour remplacer la boucle `for..in` pour un clonage simple.
 
 ```js
 let user = {
@@ -232,7 +229,7 @@ user.sizes.width++;       // on modifie la propriété à un endroit
 alert(clone.sizes.width); // 51, on peut voir la modification dans un autre endroit
 ```
 
-Pour régler ça, on doit utiliser la boucle de clonage qui examine chaque valeur de `user[key]` et, si c'est un objet, répliquer sa structure aussi. On appelle cela un "clone réél" (deep clone).
+Pour régler ça, on doit utiliser la boucle de clonage qui examine chaque valeur de `user[key]` et, si c'est un objet, répliquer sa structure aussi. On appelle cela un "clone réel" (deep clone).
 
 On peut utiliser la récursion pour l'implémenter. Ou, pour ne pas réinventer la roue, prendre un implémentation existante. par exemple [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) de la librairie [lodash](https://lodash.com).
 

1-js/05-data-types/02-number/article.md

@@ -276,7 +276,7 @@ Essayez de lancer ceci:
 alert( 9999999999999999 ); // affiche 10000000000000000
 ```
 
-La cause est encore une fois le manque de précision. Le nombre comporte 64 bits, dont 52 peuvent être utilisés pour stocker des chiffres, mais cela ne suffit pas. Alors, les cihffres les moins significatifs disparaissent.
+La cause est encore une fois le manque de précision. Le nombre comporte 64 bits, dont 52 peuvent être utilisés pour stocker des chiffres, mais cela ne suffit pas. Alors, les chiffres les moins significatifs disparaissent.
 
 JavaScript ne déclenche pas d'erreur dans de tels événements. il fait de son mieux pour adapter le nombre au format souhaité, mais malheureusement, ce format n'est pas assez grand.
 ````

1-js/05-data-types/03-string/article.md

@@ -119,15 +119,15 @@ alert( `I'm the Walrus!` ); // I'm the Walrus!
 
 Veuillez noter que le backslash `\` sert à la lecture correcte de la chaîne de caractères par JavaScript, puis disparaît. La chaîne de caractères en mémoire ne contient pas `\`. Vous pouvez le voir clairement dans l'`alert` à partir des exemples ci-dessus.
 
-Mais que faire si nous devons afficher un réel backslash `\` à l'intérieur de la chaine de caractères ?
+Mais que faire si nous devons afficher un réel backslash `\` à l'intérieur de la chaîne de caractères ?
 
 C’est possible, mais nous devons le doubler comme ceci `\\` :
 
 ```js run
 alert( `The backslash: \\` ); // The backslash: \
 ```
 
-## Longueur de chaine de caractères
+## Longueur de chaîne de caractères
 
 
 La propriété `length` a la longueur de la chaîne de caractères :
@@ -161,7 +161,7 @@ alert( str[str.length - 1] ); // o
 
 Les crochets sont un moyen moderne d’obtenir un caractère, tandis que `charAt` existe principalement pour des raisons historiques.
 
-La seule différence entre eux est que si aucun caractère  n'est trouvé, `[]` retourne `undefined`, et `charAt` retourne une chaine de caractères vide :
+La seule différence entre eux est que si aucun caractère  n'est trouvé, `[]` retourne `undefined`, et `charAt` retourne une chaîne de caractères vide :
 
 ```js run
 let str = `Hello`;
@@ -178,7 +178,7 @@ for (let char of "Hello") {
 }
 ```
 
-## Les chaine de caractères sont immuables 
+## Les chaînes de caractères sont immuables 
 
 Les chaînes de caractères ne peuvent pas être changées en JavaScript. Il est impossible de modifier un caractère.
 
@@ -198,7 +198,7 @@ Par exemple :
 ```js run
 let str = 'Hi';
 
-str = 'h' + str[1];  // remplace la chaine de caractères
+str = 'h' + str[1];  // remplace la haine de caractères
 
 alert( str ); // hi
 ```
@@ -220,7 +220,7 @@ Ou, si nous voulons un seul caractère minuscule :
 alert( 'Interface'[0].toLowerCase() ); // 'i'
 ```
 
-## Rechercher un substring (partie de la chaine de caractères)
+## Rechercher un substring (partie de la chaîne de caractères)
 
 Il existe plusieurs façons de rechercher une partie d'une chaîne de caractères.
 
@@ -379,7 +379,7 @@ alert( "Widget".startsWith("Wid") ); // true, "Widget" commence avec "Wid"
 alert( "Widget".endsWith("get") );   // true, "Widget" fini avec "get"
 ```
 
-## Obtenir un substring (sous-chaine de caractères)
+## Obtenir un substring (sous-chaîne de caractères)
 
 Il existe 3 méthodes en JavaScript pour obtenir un substring : `substring`, `substr` et `slice`.
 
@@ -426,7 +426,7 @@ Il existe 3 méthodes en JavaScript pour obtenir un substring : `substring`, `su
 
     // ...mais pas pour slice :
     alert( str.slice(2, 6) ); // "ring" (le même résultat)
-    alert( str.slice(6, 2) ); // "" (une chaine de caractères vide)
+    alert( str.slice(6, 2) ); // "" (une chaîne de caractères vide)
 
     ```
 

1-js/05-data-types/05-array-methods/article.md

@@ -139,7 +139,7 @@ alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)
 alert( arr.slice(-2) ); // s,t (copy from -2 till the end)
 ```
 
-We can also call it without arguments: `arr.slice()` creates a copy of `arr`. That's often used to obtain a copy for further transformations that should not affect the original array.
+Nous pouvons aussi l'appeler sans arguments : `arr.slice()` créer une copie de `arr`. Cela est souvent utilisé pour obtenir une copie pour d'autres transformations qui ne devraient pas affecter le tableau d'origine.
 
 ### concat