full update & cleanup in french

Author: rztprog

1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js

@@ -1,8 +1,10 @@
 function camelize(str) {
   return str
-    .split('-') // my-long-word -> ['my', 'long', 'word']
+    .split('-') // divise 'my-long-word' en tableau ['my', 'long', 'word']
     .map( 
+	// capitalise les premières lettres de tous les éléments du tableau sauf le premier
+     	// convertit ['my', 'long', 'word'] en ['my', 'Long', 'Word']
       (word, index) => index == 0 ? word : word[0].toUpperCase() + word.slice(1)
-    ) // ['my', 'long', 'word'] -> ['my', 'Long', 'Word']
-    .join(''); // ['my', 'Long', 'Word'] -> myLongWord
+    )
+    .join(''); // rejoint ['my', 'Long', 'Word'] en -> myLongWord
 }

1-js/05-data-types/05-array-methods/11-array-unique/solution.md

@@ -1,6 +1,6 @@
-Let's walk the array items:
-- For each item we'll check if the resulting array already has that item.
-- If it is so, then ignore, otherwise add to results.
+Parcourons les éléments du tableau:
+- Pour chaque élément, nous vérifierons si le tableau résultant contient déjà cet élément.
+- S'il en est ainsi, alors ignorez-le, sinon ajoutez aux résultats.
 
 ```js run
 function unique(arr) {
@@ -22,18 +22,18 @@ let strings = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(strings) ); // Hare, Krishna, :-O
 ```
 
-The code works, but there's a potential performance problem in it.
+Le code fonctionne, mais il comporte un problème de performances potentiel.
 
-The method `result.includes(str)` internally walks the array `result` and compares each element against `str` to find the match.
+La méthode `result.includes(str)` parcourt en interne le tableau `result` et compare chaque élément à `str` pour trouver la correspondance.
 
-So if there are `100` elements in `result` and no one matches `str`, then it will walk the whole `result` and do exactly `100` comparisons. And if `result` is large, like `10000`, then there would be `10000` comparisons.
+Donc, s'il y a `100` éléments dans` result` et que personne ne correspond à `str`, alors il parcourra tout le `result` et fera exactement les `100` comparaisons. Et si `result` est grand, exemple `10000`, alors il y aura des `10000` comparaisons .
 
-That's not a problem by itself, because JavaScript engines are very fast, so walk `10000` array is a matter of microseconds.
+Ce n'est pas un problème en soi, parce que les moteurs JavaScript sont très rapides, alors parcourir un tableau de `10000` éléments  est une question de microsecondes.
 
-But we do such test for each element of `arr`, in the `for` loop.
+Mais nous faisons ce test pour chaque élément de `arr`, dans la boucle` for`.
 
-So if `arr.length` is `10000` we'll have something like `10000*10000` = 100 millions of comparisons. That's a lot.
+Donc, si `arr.length` vaut `10000`, nous aurons quelque chose comme `10000*10000` = 100 millions de comparaisons. C'est beaucoup.
 
-So the solution is only good for small arrays.
+La solution n’est donc valable que pour les petits tableaux.
 
-Further in the chapter <info:map-set-weakmap-weakset> we'll see how to optimize it.
+Plus loin dans le chapitre <info:map-set-weakmap-weakset>, nous verrons comment l'optimiser.

1-js/05-data-types/05-array-methods/2-filter-range/solution.md

@@ -0,0 +1,14 @@
+```js run demo
+function filterRange(arr, a, b) {
+  // ajout de crochets autour de l'expression pour une meilleure lisibilité
+  return arr.filter(item => (a <= item && item <= b));
+}
+
+let arr = [5, 3, 8, 1];
+
+let filtered = filterRange(arr, 1, 4);
+
+alert( filtered ); // 3,1 (valeur correspondate)
+
+alert( arr ); // 5,3,8,1 (non modifié)
+```

1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js

@@ -1,15 +1,14 @@
 
-
 function filterRangeInPlace(arr, a, b) {
 
   for (let i = 0; i < arr.length; i++) {
     let val = arr[i];
-
-    // remove if outside of the interval
+	  
+	// enleve si en dehors de l'intervalle
     if (val < a || val > b) {
       arr.splice(i, 1);
       i--;
     }
   }
 
-}
+}

1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md

@@ -0,0 +1,21 @@
+```js run demo
+function filterRangeInPlace(arr, a, b) {
+
+  for (let i = 0; i < arr.length; i++) {
+    let val = arr[i];
+
+    // enleve si en dehors de l'intervalle
+    if (val < a || val > b) {
+      arr.splice(i, 1);
+      i--;
+    }
+  }
+
+}
+
+let arr = [5, 3, 8, 1];
+
+filterRangeInPlace(arr, 1, 4); // supprime les nombres sauf de 1 à 4
+
+alert( arr ); // [3, 1]
+```

1-js/05-data-types/05-array-methods/8-sort-objects/solution.md

@@ -11,7 +11,8 @@ let arr = [ john, pete, mary ];
 
 sortByName(arr);
 
-// now sorted is: [john, mary, pete]
+// maitenant trié il est: [john, mary, pete]
+alert(arr[0].name); // John
 alert(arr[1].name); // Mary
+alert(arr[2].name); // Pete
 ```
-

1-js/05-data-types/05-array-methods/8-sort-objects/task.md

@@ -18,6 +18,7 @@ let arr = [ john, pete, mary ];
 sortByName(arr);
 
 // maintenant: [john, mary, pete]
+alert(arr[0].name); // John
 alert(arr[1].name); // Mary
+alert(arr[2].name); // Pete
 ```
-

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

@@ -201,6 +201,35 @@ let arrayLike = {
 alert( arr.concat(arrayLike) ); // 1,2,something,else
 ```
 
+## Itérer: forEach (pourChaque)
+
+La méthode [arr.forEach] (mdn:js/Array/forEach) permet d’exécuter une fonction pour chaque élément du tableau.
+
+La syntaxe:
+```js
+arr.forEach(function(item, index, array) {
+  // ... fait quelques chose avec l'élément
+});
+```
+
+Par exemple, cela montre chaque élément du tableau:
+
+```js run
+// pour chaque élément appel l'alerte
+["Bilbo", "Gandalf", "Nazgul"].forEach(alert);
+```
+
+Et ce code est plus élaboré sur leurs positions dans le tableau cible:
+
+```js run
+["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
+  alert(`${item} est à l'index ${index} dans ${array}`);
+});
+```
+
+Le résultat de la fonction (s'il en renvoie) est jeté et ignoré.
+
+
 ## Recherche dans le tableau
 
 Ce sont des méthodes pour rechercher quelque chose dans un tableau.
@@ -247,6 +276,7 @@ La syntaxe est la suivante:
 ```js
 let result = arr.find(function(item, index, array) {
  // devrait retourner true si l'élément correspond à ce que nous recherchons
+ // pour le scénario de falsy(fausseté), renvoie undefined
 });
 ```
 
@@ -289,6 +319,7 @@ La syntaxe est à peu près identique à celle de `find`, mais elle renvoie un t
 ```js
 let results = arr.filter(function(item, index, array) {
   // devrait retourner true si l'élément passe le filtre
+  // retourne un tableau vide pour un scénario complet de falsy(fausseté)
 });
 ```
 
@@ -359,7 +390,6 @@ Littéralement, tous les éléments sont convertis en chaînes, puis comparés.
 Pour utiliser notre propre ordre de tri, nous devons fournir une fonction de deux arguments en tant qu'argument de `arr.sort()`.
 
 La fonction devrait fonctionner comme ceci:
-
 ```js
 function compare(a, b) {
   if (a > b) return 1;
@@ -446,7 +476,6 @@ Il retourne également le tableau `arr` après l'inversion.
 
 Voici une situation réele. Nous écrivons une application de messagerie et la personne entre dans la liste des destinataires délimités par des virgules: John, Pete, Mary. Mais pour nous, un tableau de noms serait beaucoup plus confortable qu'une simple chaîne. Alors, comment l'obtenir?
 
-
 La méthode [str.split(delim)](mdn:js/String/split) fait exactement cela. Il divise la chaîne en un tableau par le `délimiteur` donné.
 
 Dans l'exemple ci-dessous, nous les séparons par une virgule suivie d'un espace:
@@ -587,35 +616,6 @@ Il est donc conseillé de toujours spécifier la valeur initiale.
 La méthode [arr.reduceRight](mdn:js/Array/reduceRight) fait la même chose, mais va de droite à gauche.
 
 
-## Répéter: forEach
-
-La méthode [arr.forEach](mdn:js/Array/forEach) permet d'exécuter une fonction pour chaque élément du tableau.
-
-La syntaxe:
-```js
-arr.forEach(function(item, index, array) {
-  // ... fait quelque chose avec l'item
-});
-```
-
-Par exemple, on montre chaque élément du tableau:
-
-```js run
-// for each element call alert
-// pour chaque élément l'alerte est appelée
-["Bilbo", "Gandalf", "Nazgul"].forEach(alert);
-```
-
-Et ce code est plus élaboré sur leurs positions dans le tableau cible:
-
-```js run
-["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
-  alert(`${item} est à l'index ${index} dans ${array}`);
-});
-```
-
-Le résultat de la fonction (s'il en renvoie) est jeté et ignoré.
-
 ## Array.isArray
 
 Les tableaux ne forment pas un type de langue distinct. Ils sont basés sur des objets.