Apply minor fixes in '1-js/06-advanced-functions/09-call-apply-decorators/article.md'

Author: ArmandDelessert

1-js/06-advanced-functions/09-call-apply-decorators/article.md

@@ -10,7 +10,7 @@ Si la fonction est appelée souvent, nous voudrons peut-être mettre en mémoire
 
 Mais au lieu d’ajouter cette fonctionnalité à `slow()`, nous allons créer une fonction wrapper qui ajoute la mise en cache. Comme nous le verrons, cela présente de nombreux avantages.
 
-Voici le code, et les explications suivent:
+Voici le code, et les explications suivent :
 
 ```js run
 function slow(x) {
@@ -29,7 +29,7 @@ function cachingDecorator(func) {
 
     let result = func(x);  // sinon appeler func
 
-    cache.set(x, result);  // et cache (se souvenir) le résultat
+    cache.set(x, result);  // et mettre le résultat en cache
     return result;
   };
 }
@@ -43,30 +43,29 @@ alert( slow(2) ); // slow(2) est mis en cache et le résultat est renvoyé
 alert( "Again: " + slow(2) ); // le résultat slow(2) est retourné à partir du cache
 ```
 
-Dans le code ci-dessus, `cachingDecorator` est un *décorateur*: une fonction spéciale qui prend une autre fonction et modifie son comportement.
+Dans le code ci-dessus, `cachingDecorator` est un *décorateur* : une fonction spéciale qui prend une autre fonction et modifie son comportement.
 
 L'idée est que nous pouvons appeler `cachingDecorator` pour n'importe quelle fonction, ce qui renverra le wrapper de mise en cache. C'est formidable, car nous pouvons avoir de nombreuses fonctions qui pourraient utiliser une telle fonctionnalité, et tout ce que nous avons à faire est de leur appliquer `cachingDecorator`.
 
 En séparant la mise en cache du code de la fonction principale, nous simplifions également le code principal.
 
-Le résultat de `cachingDecorator(func)` est un "wrapper": `function(x)` qui "encapsule" l'appel de `func(x)` dans la logique de mise en cache:
+Le résultat de `cachingDecorator(func)` est un "wrapper" : `function(x)` qui "encapsule" l'appel de `func(x)` dans la logique de mise en cache :
 
 ![](decorator-makecaching-wrapper.svg)
 
 Depuis un code extérieur, la fonction encapsulée `slow` fait toujours la même chose. Un comportement de mise en cache vient d’être ajouté à son comportement.
 
-Pour résumer, il y a plusieurs avantages à utiliser un `cachingDecorator` distinct au lieu de modifier le code de `slow` lui-même:
+Pour résumer, il y a plusieurs avantages à utiliser un `cachingDecorator` distinct au lieu de modifier le code de `slow` lui-même :
 
 - Le `cachingDecorator` est réutilisable. Nous pouvons l'appliquer à une autre fonction.
-- La logique de mise en cache est séparée, elle n’a pas augmenté la complexité de `slow` lui-même (s’il en existait)
+- La logique de mise en cache est séparée, elle n’a pas augmenté la complexité de `slow` lui-même (s’il en existait).
 - Nous pouvons combiner plusieurs décorateurs si nécessaire (d'autres décorateurs suivront).
 
-
 ## Utilisation de "func.call" pour le contexte
 
 Le décorateur de mise en cache mentionné ci-dessus n'est pas adapté pour travailler avec des méthodes d'objet.
 
-Par exemple, dans le code ci-dessous `worker.slow()` cesse de fonctionner après la décoration:
+Par exemple, dans le code ci-dessous `worker.slow()` cesse de fonctionner après la décoration :
 
 ```js run
 // on ajoutera une fonctionalité de cache à worker.slow
@@ -106,11 +105,11 @@ alert( worker.slow(2) ); // Whoops! Error: Cannot read property 'someMethod' of
 */!*
 ```
 
-L'erreur se produit dans la ligne `(*)` qui tente d'accéder à `this.someMethod` et échoue. Pouvez-vous voir pourquoi?
+L'erreur se produit dans la ligne `(*)` qui tente d'accéder à `this.someMethod` et échoue. Pouvez-vous voir pourquoi ?
 
 La raison en est que le wrapper appelle la fonction d'origine sous la forme `func(x)` dans la ligne `(**)`. Et, lorsqu'elle est appelée comme ça, la fonction obtient `this = undefined`.
 
-Nous observerions un symptôme similaire si nous essayions d'executer:
+Nous observerions un symptôme similaire si nous essayions d'executer :
 
 ```js
 let func = worker.slow;
@@ -123,23 +122,24 @@ Réparons-le.
 
 Il existe une méthode de fonction intégrée spéciale [func.call(context, ...args)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/call) qui permet d'appeler explicitement une fonction en définissant `this`.
 
-La syntaxe est la suivante:
+La syntaxe est la suivante :
 
 ```js
 func.call(context, arg1, arg2, ...)
 ```
 
 Il exécute `func` en fournissant `this` comme le premier argument et les suivants en tant qu'arguments.
 
-Pour le dire simplement, ces deux appels font presque la même chose:
+Pour le dire simplement, ces deux appels font presque la même chose :
+
 ```js
 func(1, 2, 3);
 func.call(obj, 1, 2, 3)
 ```
 
 Ils appellent tous les deux `func` avec les arguments `1`, `2` et `3`. La seule différence est que `func.call` définit également `this` sur `obj`.
 
-Par exemple, dans le code ci-dessous, nous appelons `sayHi` dans le contexte de différents objets: `sayHi.call(user)` exécute `sayHi` fournissant `this = user`, et la ligne suivante définit `this = admin`:
+Par exemple, dans le code ci-dessous, nous appelons `sayHi` dans le contexte de différents objets : `sayHi.call(user)` exécute `sayHi` fournissant `this = user`, et la ligne suivante définit `this = admin` :
 
 ```js run
 function sayHi() {
@@ -154,8 +154,7 @@ sayHi.call( user ); // John
 sayHi.call( admin ); // Admin
 ```
 
-Et ici, nous utilisons `call` pour appeler `say` avec le contexte et la phrase donnés:
-
+Et ici, nous utilisons `call` pour appeler `say` avec le contexte et la phrase donnés :
 
 ```js run
 function say(phrase) {
@@ -204,22 +203,22 @@ alert( worker.slow(2) ); // ça fonctionne, n'appelle pas l'original (mis en cac
 
 Maintenant, tout va bien.
 
-Pour que tout soit clair, voyons plus en détail comment `this` est passé:
+Pour que tout soit clair, voyons plus en détail comment `this` est passé :
 
 1. Après la décoration, `worker.slow` est désormais le wrapper `function(x) {...}`.
 2. Ainsi, lorsque `worker.slow(2)` est exécuté, le wrapper obtient `2` en argument et `this = worker` (c'est l'objet avant le point).
-3. Dans le wrapper, en supposant que le résultat ne soit pas encore mis en cache, `func.call(this, x)` passe le `this` (`= worker`) actuel et l'argument actuel (`= 2`) à la méthode d'origine. .
+3. Dans le wrapper, en supposant que le résultat ne soit pas encore mis en cache, `func.call(this, x)` passe le `this` (`= worker`) actuel et l'argument actuel (`= 2`) à la méthode d'origine.
 
-## Passer plusieurs arguments 
+## Passer plusieurs arguments
 
 Rendons maintenant `cachingDecorator` encore plus universel. Jusqu'à présent, il ne travaillait qu'avec des fonctions à un seul argument.
 
-Maintenant, comment mettre en cache la méthode multi-argument `worker.slow`?
+Maintenant, comment mettre en cache la méthode multi-argument `worker.slow` ?
 
 ```js
 let worker = {
   slow(min, max) {
-    return min + max; // tache lourde est supposé
+    return min + max; // la tâche est supposée lourde
   }
 };
 
@@ -229,17 +228,17 @@ worker.slow = cachingDecorator(worker.slow);
 
 Auparavant, pour un seul argument, `x`, nous pouvions simplement `cache.set(x, result)` pour enregistrer le résultat et `cache.get(x)` pour le récupérer. Mais maintenant, nous devons nous rappeler le résultat pour une *combinaison d'arguments* `(min, max)`. Le `Map` natif prend une valeur unique en tant que clé.
 
-Il y a beaucoup de solutions possibles:
+Il y a beaucoup de solutions possibles :
 
 1. Mettre en œuvre une nouvelle structure de données similaire à `Map` (ou utiliser une par une tierce partie) plus polyvalent et permetant l'utilisation de plusieurs clés.
-2. Utilisez des maps imbriquées: `cache.set(min)` sera un `Map` qui stocke la paire `(max, result)`. Donc, nous pouvons obtenir `result` avec `cache.get (min).get(max)`.
+2. Utilisez des maps imbriquées : `cache.set(min)` sera un `Map` qui stocke la paire `(max, result)`. Donc, nous pouvons obtenir `result` avec `cache.get (min).get(max)`.
 3. Joignez deux valeurs en une. Dans notre cas particulier, nous pouvons simplement utiliser la chaîne `"min, max"` comme clé pour `Map`. Pour plus de flexibilité, nous pouvons permettre de fournir une *fonction de hachage* au décorateur, qui sait créer une valeur parmi plusieurs.
 
 Pour de nombreuses applications pratiques, la 3ème variante est suffisante, nous allons donc nous y tenir.
 
-Nous devons également transmettre non seulement `x`, mais tous les arguments dans `func.call`. Rappelons que dans une `function()` on peut obtenir un pseudo-tableau de ses arguments comme `arguments`, donc` func.call(this, x) `doit être remplacé par `func.call(this, ...arguments)`.
+Nous devons également transmettre non seulement `x`, mais tous les arguments dans `func.call`. Rappelons que dans une `function()` on peut obtenir un pseudo-tableau de ses arguments comme `arguments`, donc `func.call(this, x)` doit être remplacé par `func.call(this, ...arguments)`.
 
-Voici un plus puissant `cachingDecorator` :
+Voici un `cachingDecorator` plus puissant :
 
 ```js run
 let worker = {
@@ -280,7 +279,7 @@ alert( "Again " + worker.slow(3, 5) ); // pareil (mis en cache)
 
 Maintenant, cela fonctionne avec n'importe quel nombre d'arguments (bien que la fonction de hachage doive également être ajustée pour permettre n'importe quel nombre d'arguments. Une façon intéressante de gérer cela sera traitée ci-dessous).
 
-Il y a deux changements:
+Il y a deux changements :
 
 - Dans la ligne `(*)`, il appelle `hash` pour créer une clé unique à partir de `arguments`. Ici, nous utilisons une simple fonction "d'assemblage" qui transforme les arguments `(3, 5)` en la clé `"3,5"`. Les cas plus complexes peuvent nécessiter d'autres fonctions de hachage.
 - Ensuite `(**)` utilise `func.call(this, ...arguments)` pour transmettre le contexte et tous les arguments obtenus par le wrapper (pas seulement le premier) à la fonction d'origine.
@@ -329,7 +328,7 @@ When an external code calls such `wrapper`, it is indistinguishable from the cal
 
 ## Emprunter une méthode [#method-borrowing]
 
-Maintenant, apportons une autre amélioration mineure à la fonction de hachage:
+Maintenant, apportons une autre amélioration mineure à la fonction de hachage :
 
 ```js
 function hash(args) {
@@ -339,7 +338,7 @@ function hash(args) {
 
 Pour l'instant, cela ne fonctionne que sur deux arguments. Ce serait mieux s'il pouvait coller un nombre quelconque de `args`.
 
-La solution naturelle serait d'utiliser la méthode [arr.join](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/join):
+La solution naturelle serait d'utiliser la méthode [arr.join](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/join) :
 
 ```js
 function hash(args) {
@@ -349,7 +348,7 @@ function hash(args) {
 
 ... Malheureusement, ça ne marchera pas. Parce que nous appelons `hash(arguments)` et l’objet `arguments` est à la fois itérable et semblable à un tableau, mais pas un vrai tableau.
 
-Donc, appeler `join` échouerait, comme on peut le voir ci-dessous:
+Donc, appeler `join` échouerait, comme on peut le voir ci-dessous :
 
 ```js run
 function hash() {
@@ -361,7 +360,7 @@ function hash() {
 hash(1, 2);
 ```
 
-Néanmoins, il existe un moyen simple d’utiliser `join`:
+Néanmoins, il existe un moyen simple d’utiliser `join` :
 
 ```js run
 function hash() {
@@ -377,11 +376,11 @@ L'astuce s'appelle *method borrowing* (empruntage de méthode).
 
 Nous prenons (empruntons) la méthode `join` d'un tableau régulier (`[].join`) et utilisons `[].join.call` pour l'exécuter dans le contexte des `arguments`.
 
-Pourquoi ça marche?
+Pourquoi ça marche ?
 
 C'est parce que l'algorithme interne de la méthode native `arr.join(glue)` est très simple.
 
-Tiré de la spécification presque "tel quel":
+Tiré de la spécification presque "tel quel" :
 
 1. Soit `glue` le premier argument ou, s’il n’ya pas d’argument, une virgule `","`.
 2. Soit `result` une chaîne de caractères vide.
@@ -391,11 +390,11 @@ Tiré de la spécification presque "tel quel":
 6. ... Faites-le jusqu'à ce que `this.length` éléments soient collés.
 7. Retournez `result`.
 
-Donc, techniquement, cela prend `this` et associe `this[0]`, `this[1]`... etc. Il est intentionnellement écrit de manière à permettre à tout type de tableau `this` (pas une coïncidence, de nombreuses méthodes suivent cette pratique). C'est pourquoi cela fonctionne aussi avec `this = arguments`.
+Donc, techniquement, cela prend `this` et associe `this[0]`, `this[1]`... etc. Il est intentionnellement écrit de manière à permettre à tout type de tableau `this` (ce n'est pas une coïncidence, de nombreuses méthodes suivent cette pratique). C'est pourquoi cela fonctionne aussi avec `this = arguments`.
 
 ## Décorateurs et propriétés fonctionnelles
 
-Il est généralement prudent de remplacer une fonction ou une méthode par une fonction décorée, à une exception près. Si la fonction d'origine comportait des propriétés, telles que `func.calledCount` ou autre, la fonction décorée ne les fournira pas. Parce que c'est un emballage. Il faut donc faire attention si on les utilise.
+Il est généralement prudent de remplacer une fonction ou une méthode par une fonction décorée, à une exception près. Si la fonction d'origine comportait des propriétés, telles que `func.calledCount` ou autre, la fonction décorée ne les fournira pas. Parce que c'est un wrapper. Il faut donc faire attention si on les utilise.
 
 Dans l'exemple ci-dessus, si la fonction `slow` avait des propriétés, alors `cachingDecorator(slow)` est un wrapper sans elles.
 
@@ -407,14 +406,14 @@ Il existe un moyen de créer des décorateurs qui conservent l'accès aux propri
 
 *Decorator* est un wrapper autour d'une fonction qui modifie son comportement. Le travail principal est toujours effectué par la fonction.
 
-Les décorateurs peuvent être considérés comme des "caractéristiques" ou des "aspects" pouvant être ajoutés à une fonction. Nous pouvons en ajouter un ou en ajouter plusieurs. Et tout ça sans changer de code!
+Les décorateurs peuvent être considérés comme des "caractéristiques" ou des "aspects" pouvant être ajoutés à une fonction. Nous pouvons en ajouter un ou en ajouter plusieurs. Et tout ça sans changer son code !
 
-Pour implémenter `cachingDecorator`, nous avons étudié des méthodes:
+Pour implémenter `cachingDecorator`, nous avons étudié les méthodes :
 
 - [func.call(context, arg1, arg2...)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/call) -- appelle `func` avec un contexte et des arguments donnés.
 - [func.apply(context, args)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/apply) -- appelle `func` en passant `context` comme `this` et `args` sous forme de tableau dans une liste d'arguments.
 
-Le renvoi d'appel, *call forwarding*, est généralement effectué avec `apply`:
+Le renvoi d'appel, *call forwarding*, est généralement effectué avec `apply` :
 
 ```js
 let wrapper = function() {