Pull request last update

1-js/02-first-steps/12-while-for/article.md

@@ -212,7 +212,7 @@ Mais nous pouvons forcer la sortie à tout moment. Il y a une directive spécial
 
 Par exemple, la boucle ci-dessous demande à l'utilisateur une série de chiffres, mais "se casse" quand aucun numéro n'est entré :
 
-```js
+```js run
 let sum = 0;
 
 while (true) {

1-js/02-first-steps/15-function-expressions-arrows/article.md

@@ -352,7 +352,7 @@ welcome(); // ok maintenant
 ```smart header="Quand choisir la fonction déclaration par rapport à la fonction expression ?"
 En règle générale, lorsque nous devons déclarer une fonction, la première chose à prendre en compte est la syntaxe de la fonction déclaration, celle que nous utilisions auparavant. Cela donne plus de liberté dans l'organisation de notre code, car nous pouvons appeler de telles fonctions avant qu'elles ne soient déclarées.
 
-C’est également meilleur pour la lisibilité, car il est plus facile de rechercher la `fonction f(…) {…}` dans le code que `let f = function(…) {…}`. Les fonction déclarations sont plus "accrocheuses".
+C’est également meilleur pour la lisibilité, car il est plus facile de rechercher la `fonction f(…) {…}` dans le code que `let f = function(…) {…};`. Les fonction déclarations sont plus "accrocheuses".
 
 … Mais si une déclaration de fonction ne nous convient pas pour une raison quelconque (nous en avons vu un exemple ci-dessus), alors il convient d'utiliser une Fonction Expression.
 ```

1-js/04-object-basics/04-object-methods/3-why-this/task.md

@@ -4,7 +4,7 @@ importance: 3
 
 # Expliquez la valeur de "this"
 
-Dans le code ci-dessous, nous avons l'intention d'appeler la méthode `user.go()` 4 fois de suite.
+Dans le code ci-dessous, nous avons l'intention d'appeler la méthode `obj.go()` 4 fois de suite.
 
 Mais les appels `(1)` et `(2)` fonctionnent différemment de `(3)` et `(4)`. Pourquoi ?
 

1-js/04-object-basics/05-object-toprimitive/article.md

@@ -53,21 +53,27 @@ let greater = user1 > user2;
 `"default"`
 : Se produit dans de rares cas où l'opérateur n'est "pas sûr" du type auquel il doit s'attendre.
 
-Par exemple, le binaire plus `+` peut fonctionner à la fois avec des chaînes de caractères (les concaténer) et des nombres (les ajouter). Ou quand un objet est comparé en utilisant `==` avec une chaîne, un numéro ou un symbole, il est également difficile de savoir quelle conversation doit être faite.
+    Par exemple, le binaire plus `+` peut fonctionner à la fois avec des chaînes de caractères (les concaténer) et des nombres (les ajouter), donc les chaînes de caractères et les chiffres feraient l'affaire. Donc, si le plus binaire obtient un objet sous forme d'argument, il utilise l'indicateur `"default"` pour le convertir.
 
-```js
-// binary plus
-let total = car1 + car2;
+    En outre, si un objet est comparé à l'aide de `==` avec une chaîne de caractères, un nombre ou un symbole, il est également difficile de savoir quelle conversion doit être effectuée, par conséquent l'indicateur `"default"` est utilisé.
 
-// obj == string/number/symbol
-if (user == 1) { ... };
-```
+    ```js
+    // binary plus uses the "default" hint
+    let total = obj1 + obj2;
+
+    // obj == number uses the "default" hint
+    if (user == 1) { ... };
+    ```
 
-L'opérateur supérieur / inférieur `<>` peut également utiliser des chaînes de caractères et des nombres. Néanmoins, il utilise un indice `"number"` non `"default"`. C’est pour des raisons historiques.
+    Les opérateurs de comparaison supérieurs et inférieurs, tels que `<` `>`, peuvent également fonctionner avec des chaînes de caractères et des nombres. Néanmoins, ils utilisent l'indicateur `"number"`, pas `default`. C'est pour des raisons historiques,
 
-En pratique, tous les objets intégrés, à l'exception d'un cas (l'objet `Date`, nous l'apprendrons plus tard) implémentent la conversion `"default"` de la même manière que `"number"`. Et probablement nous devrions faire la même chose.
+    En pratique cependant, nous n'avons pas besoin de nous souvenir de ces détails particuliers, car tous les objets intégrés, à l'exception d'un cas (l'objet `Date`, nous l'apprendrons plus tard), implémentent la conversion `'default'` de la même manière que `"number"`. Et nous pouvons faire la même chose.
 
-Veuillez noter qu'il n'y a que trois "hints" ("indices"). C'est simple. Il n'y a pas d'indice "booléen" (tous les objets sont vrais dans un contexte booléen) ou autre chose. Et si nous traitons `"default"` et `"number"` de la même manière, comme le font la plupart des programmes intégrés, il n'y a que deux conversions.
+```smart header="Pas d'indice `\"boolean\"`"
+Veuillez noter qu'il n'y a que trois indices. C'est aussi simple que cela.
+
+Il n'y a pas d'indice "boolean" (tous les objets sont `true` dans un contexte booléen) ou autre chose. Et si nous traitons de la même manière `'default'` et `'number'`, comme le font la plupart des programmes intégrés, il n'y a au final que deux conversions.
+```
 
 **Pour effectuer la conversion, JavaScript essaie de trouver et d'appeler trois méthodes d'objet :**
 
@@ -119,7 +125,29 @@ S'il n'y a pas de `Symbol.toPrimitive`, alors JavaScript essaye de les trouver e
 - `toString -> valueOf` pour le hint "string".
 - `valueOf -> toString` sinon.
 
-Par exemple, ici `user` fait la même chose que ci-dessus en combinant `toString` et `valueOf` :
+Ces méthodes doivent renvoyer une valeur primitive. Si `toString` ou `valueOf` renvoie un objet, il est ignoré (comme s'il n'y avait pas de méthode).
+
+Par défaut, un objet brut a les méthodes `toString` et `valueOf` suivantes :
+
+- La méthode `toString` renvoie une chaîne de caractères `"[object Object]"`.
+- La méthode `valueOf` renvoie un objet.
+
+Voici la démo :
+
+```js run
+let user = {name: "John"};
+
+alert(user); // [object Object]
+alert(user.valueOf() === user); // true
+```
+
+Donc, si nous essayons d'utiliser un objet en tant que chaîne de caractères, comme dans un `alert` ou autre chose, nous voyons par défaut `[object Object]`.
+
+Et la valeur par défaut `valueOf` n'est mentionnée ici que par souci d'exhaustivité, afin d'éviter toute confusion. Comme vous pouvez le constater, l'objet est renvoyé et est donc ignoré. Ne me demandez pas pourquoi, c'est pour des raisons historiques. Nous pouvons donc supposer que cela n'existe pas.
+
+Implémentons ces méthodes.
+
+Par exemple, ici, `user` fait la même chose que ci-dessus en combinant `toString` et `valueOf` au lieu de `Symbol.toPrimitive` :
 
 ```js run
 let user = {
@@ -166,7 +194,7 @@ En l'absence de `Symbol.toPrimitive` et de `valueOf`, `toString` gérera toutes
 
 La chose importante à savoir sur toutes les méthodes de conversion de primitives est qu'elles ne renvoient pas nécessairement la primitive "hinted".
 
-Il n'y a pas de control pour vérifier si `ToString()` renvoie exactement une chaîne de caractères ou si la méthode `Symbol.toPrimitive` renvoie un nombre pour un indice "number".
+Il n'y a pas de control pour vérifier si `ToString()` renvoie exactement une chaîne de caractères ou si la méthode `Symbol.toPrimitive` renvoie un nombre pour un indice `"number"`.
 
 **La seule chose obligatoire : ces méthodes doivent renvoyer une primitive, pas un objet.**
 
@@ -176,35 +204,41 @@ Pour des raisons historiques, si `toString` ou `valueOf` renvoie un objet, il n
 En revanche, `Symbol.toPrimitive` doit renvoyer une primitive, sinon une erreur se produira.
 ```
 
-## Autres opérations
+## Autres conversions
+
+Comme nous le savons déjà, de nombreux opérateurs et fonctions effectuent des conversions de types, par exemple la multiplication `*` convertit les opérandes en nombres.
 
-Une opération qui a initié la conversion obtient cette primitive, puis continue à travailler avec elle, en appliquant d'autres conversions si nécessaire.
+Si nous passons un objet en argument, il y a deux étapes :
+1. L'objet est converti en primitive (en utilisant les règles décrites ci-dessus).
+2. Si la primitive résultante n'est pas du bon type, elle est convertie.
 
 Par exemple :
 
-- Les opérations mathématiques, sauf binaire plus, convertissent la primitive en nombre :
+```js run
+let obj = {
+  // toString gère toutes les conversions en l'absence d'autres méthodes
+  toString() {
+    return "2";
+  }
+};
 
-    ```js run
-    let obj = {
-      // toString gère toutes les conversions en l'absence d'autres méthodes
-      toString() {
-        return "2";
-      }
-    };
+alert(obj * 2); // 4, objet converti en primitive "2", puis la multiplication le transforme en un nombre
+```
 
-    alert(obj * 2); // 4, objet converti en primitive "2", puis multiplié par un nombre
-    ```
+1. La multiplication `obj * 2` convertit d'abord l'objet en primitive (cela devient une chaîne de caractère `"2"`).
+2. Ensuite `"2" * 2` devient `2 * 2` (la chaîne de caractères est convertie en nombre).
 
-- Le binaire plus va concaténer des chaînes dans la même situation :
-    ```js run
-    let obj = {
-      toString() {
-        return "2";
-      }
-    };
+Le binaire plus va concaténer des chaînes de caractères dans la même situation, car il accepte volontiers une chaîne de caractères :
 
-    alert(obj + 2); // 22 (la conversion en primitive a renvoyé une chaîne de caractères => concaténation)
-    ```
+```js run
+let obj = {
+  toString() {
+    return "2";
+  }
+};
+
+alert(obj + 2); // 22 ("2" + 2), la conversion en primitive a renvoyé une chaîne de caractères => concaténation
+```
 
 ## Résumé
 

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

@@ -398,7 +398,7 @@ Il existe 3 méthodes en JavaScript pour obtenir un substring : `substring`, `su
 
     ```js run
     let str = "st*!*ringify*/!*";
-    alert( str.slice(2) ); // ringify, à partir de la 2e position jusqu'à la fin
+    alert( str.slice(2) ); // 'ringify', à partir de la 2e position jusqu'à la fin
     ```
 
     Des valeurs négatives pour `start/end` sont également possibles. Elles veulent dire que la position est comptée à partir de la fin de la chaîne de caractères :
@@ -407,7 +407,7 @@ Il existe 3 méthodes en JavaScript pour obtenir un substring : `substring`, `su
     let str = "strin*!*gif*/!*y";
 
     // commence à la 4ème position à partir de la droite, se termine au 1er à partir de la droite
-    alert( str.slice(-4, -1) ); // gif
+    alert( str.slice(-4, -1) ); // 'gif'
     ```
 
 `str.substring(start [, end])`
@@ -439,14 +439,14 @@ Il existe 3 méthodes en JavaScript pour obtenir un substring : `substring`, `su
 
     ```js run
     let str = "st*!*ring*/!*ify";
-    alert( str.substr(2, 4) ); // ring, à partir de la 2ème position on obtient 4 caractères
+    alert( str.substr(2, 4) ); // 'ring', à partir de la 2ème position on obtient 4 caractères
     ```
 
     Le premier argument peut être négatif, pour compter à partir de la fin :
 
     ```js run
     let str = "strin*!*gi*/!*fy";
-    alert( str.substr(-4, 2) ); // gi, à partir de la 4ème position on obtient 2 caractères
+    alert( str.substr(-4, 2) ); // 'gi', à partir de la 4ème position on obtient 2 caractères
     ```
 
 Récapitulons ces méthodes pour éviter toute confusion :

1-js/05-data-types/05-array-methods/4-sort-back/task.md

@@ -2,12 +2,12 @@ importance: 4
 
 ---
 
-# Trier dans l'ordre inverse
+# Trier par ordre décroissant
 
 ```js
 let arr = [5, 2, 1, -10, 8];
 
-// ...  votre code pour le trier dans l'ordre inverse
+// ...  votre code pour le trier par ordre décroissant
 
 alert( arr ); // 8, 5, 2, 1, -10
 ```

1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md

@@ -1,5 +1,3 @@
 
 - Please note how methods are stored. They are simply added to `this.methods` property.
 - All tests and numeric conversions are done in the `calculate` method. In future it may be extended to support more complex expressions.
-
-[js src="_js/solution.js"]

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

@@ -36,7 +36,7 @@ C'est normal, car `delete obj.key` supprime une valeur par la` clé`. C'est tout
 
 Des méthodes spéciales doivent donc être utilisées.
 
-La méthode [arr.splice(str)](mdn:js/Array/splice) est un couteau suisse pour les tableaux. Elle peut tout faire : ajouter, supprimer et remplacer des éléments.
+La méthode [arr.splice(start)](mdn:js/Array/splice) est un couteau suisse pour les tableaux. Elle peut tout faire : ajouter, supprimer et remplacer des éléments.
 
 La syntaxe est la suivante:
 
@@ -270,7 +270,7 @@ alert( arr.includes(NaN) );// true (correct)
 
 Imaginez que nous ayons un tableau d'objets. Comment pouvons-nous trouver un objet avec la condition spécifique?
 
-Ici la méthode [arr.find](mdn:js/Array/find) se révèle vraiment pratique.
+Ici la méthode [arr.find(fn)](mdn:js/Array/find) se révèle vraiment pratique.
 
 La syntaxe est la suivante:
 ```js
@@ -577,7 +577,7 @@ Le flux de calcul:
 
 Ou sous la forme d'un tableau, où chaque ligne représente un appel de fonction sur l'élément de tableau suivant:
 
-|   |`sum`|`current`|`result`|
+|   |`sum`|`current`|result|
 |---|-----|---------|---------|
 |premier appel|`0`|`1`|`1`|
 |deuxième appel|`1`|`2`|`3`|

1-js/05-data-types/06-iterable/article.md

@@ -142,15 +142,17 @@ for (let char of str) {
 
 Pour mieux comprendre, voyons comment utiliser explicitement un itérateur.
 
-Nous allons parcourir une chaîne de caractères de la même manière que `for..of`, mais avec des appels directs. Ce code obtient un itérateur de chaîne de caractères et en récupère la valeur "manuellement":
+Nous allons parcourir une chaîne de caractères de la même manière que `for..of`, mais avec des appels directs. Ce code crée un itérateur de chaîne de caractères et en récupère la valeur "manuellement":
 
 ```js run
 let str = "Hello";
 
 // fait la même chose que
 // for (let char of str) alert(char);
 
+*!*
 let iterator = str[Symbol.iterator]();
+*/!*
 
 while (true) {
   let result = iterator.next();

1-js/05-data-types/09-keys-values-entries/article.md

@@ -10,7 +10,7 @@ Ils sont pris en charge par:
 
 - `Map`
 - `Set`
-- `Array` (sauf `arr.values()`)
+- `Array` 
 
 Les objets simples prennent également en charge des méthodes similaires, mais la syntaxe est un peu différente.
 

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

@@ -187,7 +187,7 @@ L'affectation par décomposition fonctionne également avec les objets.
 La syntaxe de base est la suivante :
 
 ```js
-let {var1, var2} = {var1:…, var2…}
+let {var1, var2} = {var1:…, var2:…}
 ```
 
 Nous avons un objet existant à droite que nous souhaitons scinder en variables. Le côté gauche contient un "pattern" pour les propriétés correspondantes. Dans ce cas simple, c’est une liste de noms de variables dans `{...}`.

1-js/05-data-types/12-json/article.md

@@ -425,9 +425,9 @@ alert( numbers[1] ); // 1
 Ou pour les objets imbriqués:
 
 ```js run
-let user = '{ "name": "John", "age": 35, "isAdmin": false, "friends": [0,1,2,3] }';
+let userData = '{ "name": "John", "age": 35, "isAdmin": false, "friends": [0,1,2,3] }';
 
-user = JSON.parse(user);
+let user = JSON.parse(userData);
 
 alert( user.friends[1] ); // 1
 ```

1-js/06-advanced-functions/01-recursion/article.md

@@ -459,6 +459,7 @@ let list = { value: 1 };
 list.next = { value: 2 };
 list.next.next = { value: 3 };
 list.next.next.next = { value: 4 };
+list.next.next.next.next = null;
 ```
 
 Ici, nous pouvons voir encore plus clairement qu'il y a plusieurs objets, chacun ayant les valeurs `value` et` next` pointant vers le voisin. La variable `list` est le premier objet de la chaîne. Par conséquent, en suivant les pointeurs `next`, nous pouvons atteindre n'importe quel élément.