Skip to content

Commit de9f791

Browse files
authored
Merge pull request #43 from TevaHenry/master
Translate Decorators and forwarding, call/apply into French
2 parents 0881ee1 + 83be1f4 commit de9f791

File tree

11 files changed

+200
-201
lines changed

11 files changed

+200
-201
lines changed
Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
function spy(func) {
2-
// your code
2+
// votre code
33
}
44

55

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1 +1 @@
1-
Here we can use `calls.push(args)` to store all arguments in the log and `f.apply(this, args)` to forward the call.
1+
Ici, nous pouvons utiliser `calls.push(args)` pour stocker tous les arguments dans le log et `f.apply(this, args)` pour transférer l'appel.

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2,17 +2,17 @@ importance: 5
22

33
---
44

5-
# Spy decorator
5+
# Décorateur spy
66

7-
Create a decorator `spy(func)` that should return a wrapper that saves all calls to function in its `calls` property.
7+
Créez un décorateur `spy(func)` qui devrait renvoyer un wrapper qui enregistre tous les appels à la fonction dans sa propriété `calls`.
88

9-
Every call is saved as an array of arguments.
9+
Chaque appel est enregistré sous la forme d'un tableau d'arguments.
1010

11-
For instance:
11+
Par exemple:
1212

1313
```js
1414
function work(a, b) {
15-
alert( a + b ); // work is an arbitrary function or method
15+
alert( a + b ); // work est une fonction ou une méthode arbitraire
1616
}
1717

1818
*!*
@@ -27,4 +27,4 @@ for (let args of work.calls) {
2727
}
2828
```
2929

30-
P.S. That decorator is sometimes useful for unit-testing. Its advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
30+
P.S. Ce décorateur est parfois utile pour les tests unitaires. Sa forme avancée est `sinon.spy` dans la bibliothèque [Sinon.JS](http://sinonjs.org/).

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
The solution:
1+
La solution:
22

33
```js run demo
44
function delay(f, ms) {
@@ -11,22 +11,22 @@ function delay(f, ms) {
1111

1212
let f1000 = delay(alert, 1000);
1313

14-
f1000("test"); // shows "test" after 1000ms
14+
f1000("test"); // montre "test" après 1000ms
1515
```
1616

17-
Please note how an arrow function is used here. As we know, arrow functions do not have own `this` and `arguments`, so `f.apply(this, arguments)` takes `this` and `arguments` from the wrapper.
17+
Veuillez noter comment une fonction fléchée est utilisée ici. Comme nous le savons, les fonctions fléchées ne possèdent pas leurs propres `this` et `arguments`, aussi `f.apply(this, arguments)` prend `this` et `arguments` du wrapper.
1818

19-
If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (assuming we're in the browser).
19+
Si nous passons une fonction régulière, `setTimeout` l'appellera sans arguments et `this = window` (en supposant que nous sommes dans le navigateur).
2020

21-
We still can pass the right `this` by using an intermediate variable, but that's a little bit more cumbersome:
21+
Nous pouvons toujours passer le bon `this` en utilisant une variable intermédiaire, mais c'est un peu plus lourd:
2222

2323
```js
2424
function delay(f, ms) {
2525

2626
return function(...args) {
27-
let savedThis = this; // store this into an intermediate variable
27+
let savedThis = this; // stocker "this" dans une variable intermédiaire
2828
setTimeout(function() {
29-
f.apply(savedThis, args); // use it here
29+
f.apply(savedThis, args); // utilisez-le ici
3030
}, ms);
3131
};
3232

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2,25 +2,25 @@ importance: 5
22

33
---
44

5-
# Delaying decorator
5+
# Décorateur de retardement
66

7-
Create a decorator `delay(f, ms)` that delays each call of `f` by `ms` milliseconds.
7+
Créez un décorateur `delay(f, ms)` qui retarde chaque appel de `f` de `ms` millisecondes.
88

9-
For instance:
9+
Par exemple:
1010

1111
```js
1212
function f(x) {
1313
alert(x);
1414
}
1515

16-
// create wrappers
16+
// créer des wrappers
1717
let f1000 = delay(f, 1000);
1818
let f1500 = delay(f, 1500);
1919

20-
f1000("test"); // shows "test" after 1000ms
21-
f1500("test"); // shows "test" after 1500ms
20+
f1000("test"); // montre "test" après 1000ms
21+
f1500("test"); // montre "test" après 1500ms
2222
```
2323

24-
In other words, `delay(f, ms)` returns a "delayed by `ms`" variant of `f`.
24+
En d'autres termes, `delay(f, ms)` renvoie une variante "retardée de `ms`" de `f`.
2525

26-
In the code above, `f` is a function of a single argument, but your solution should pass all arguments and the context `this`.
26+
Dans le code ci-dessus, `f` est une fonction d'un seul argument, mais votre solution doit transmettre tous les arguments et le contexte `this`.

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -16,13 +16,13 @@ function debounce(f, ms) {
1616
}
1717
```
1818

19-
A call to `debounce` returns a wrapper. There may be two states:
19+
Un appel à `debounce` renvoie un wrapper. Il peut y avoir deux états:
2020

21-
- `isCooldown = false` -- ready to run.
22-
- `isCooldown = true` -- waiting for the timeout.
21+
- `isCooldown = false` -- prêt à exécuter.
22+
- `isCooldown = true` -- en attente du timeout.
2323

24-
In the first call `isCooldown` is falsy, so the call proceeds, and the state changes to `true`.
24+
Lors du premier appel, `is Cooldown` est fausse. L'appel se poursuit et l'état passe à` true`.
2525

26-
While `isCooldown` is true, all other calls are ignored.
26+
Alors que `isCooldown` est vrai, tous les autres appels sont ignorés.
2727

28-
Then `setTimeout` reverts it to `false` after the given delay.
28+
Ensuite, `setTimeout` le rétablit à `false` après le délai imparti.

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -2,23 +2,23 @@ importance: 5
22

33
---
44

5-
# Debounce decorator
5+
# Décorateur debounce
66

7-
The result of `debounce(f, ms)` decorator should be a wrapper that passes the call to `f` at maximum once per `ms` milliseconds.
7+
Le résultat du décorateur `debounce(f, ms)` devrait être un wrapper qui transmet l'appel à `f` au maximum une fois par `ms`, millisecondes.
88

9-
In other words, when we call a "debounced" function, it guarantees that all other future in the closest `ms` milliseconds will be ignored.
9+
En d’autres termes, lorsque nous appelons une fonction "debounce", elle garantit que tous les autres appels futurs dans les millisecondes `ms` les plus proches seront ignorés.
1010

11-
For instance:
11+
Par exemple:
1212

1313
```js no-beautify
1414
let f = debounce(alert, 1000);
1515

16-
f(1); // runs immediately
17-
f(2); // ignored
16+
f(1); // exécute immédiatement
17+
f(2); // ignorée
1818

19-
setTimeout( () => f(3), 100); // ignored ( only 100 ms passed )
20-
setTimeout( () => f(4), 1100); // runs
21-
setTimeout( () => f(5), 1500); // ignored (less than 1000 ms from the last run)
19+
setTimeout( () => f(3), 100); // ignorée (seulement 100 ms passé)
20+
setTimeout( () => f(4), 1100); // exécute
21+
setTimeout( () => f(5), 1500); // ignorée (moins de 1000 ms à partir de la dernière exécution)
2222
```
2323

24-
In practice `debounce` is useful for functions that retrieve/update something when we know that nothing new can be done in such a short period of time, so it's better not to waste resources.
24+
En pratique, `debounce` est utile pour les fonctions qui récupèrent/mettent à jour quelque chose quand on sait que rien de nouveau ne peut être fait dans un laps de temps aussi court, il est donc préférable de ne pas gaspiller de ressources.

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -7,23 +7,23 @@ function throttle(func, ms) {
77
function wrapper() {
88

99
if (isThrottled) {
10-
// memo last arguments to call after the cooldown
10+
// mémo derniers arguments à appeler après le temps de recharge
1111
savedArgs = arguments;
1212
savedThis = this;
1313
return;
1414
}
1515

16-
// otherwise go to cooldown state
16+
// sinon aller en état de recharge
1717
func.apply(this, arguments);
1818

1919
isThrottled = true;
2020

21-
// plan to reset isThrottled after the delay
21+
// prévoir de réinitialiser isThrottled après le délai
2222
setTimeout(function() {
2323
isThrottled = false;
2424
if (savedArgs) {
25-
// if there were calls, savedThis/savedArgs have the last one
26-
// recursive call runs the function and sets cooldown again
25+
// s'il y a eu des appels, savedThis/savedArgs auront le dernier
26+
// appel récursif exécute la fonction et redéfinit le temps de recharge
2727
wrapper.apply(savedThis, savedArgs);
2828
savedArgs = savedThis = null;
2929
}

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -30,10 +30,10 @@ function throttle(func, ms) {
3030
}
3131
```
3232

33-
A call to `throttle(func, ms)` returns `wrapper`.
33+
Un appel à `throttle(func, ms)` retourne `wrapper`.
3434

35-
1. During the first call, the `wrapper` just runs `func` and sets the cooldown state (`isThrottled = true`).
36-
2. In this state all calls memorized in `savedArgs/savedThis`. Please note that both the context and the arguments are equally important and should be memorized. We need them simultaneously to reproduce the call.
37-
3. ...Then after `ms` milliseconds pass, `setTimeout` triggers. The cooldown state is removed (`isThrottled = false`). And if we had ignored calls, then `wrapper` is executed with last memorized arguments and context.
35+
1. Lors du premier appel, le `wrapper` exécute simplement `func` et définit l'état de refroidissement (`isThrottled = true`).
36+
2. Dans cet état, tous les appels sont mémorisés dans `savedArgs/savedThis`. Veuillez noter que le contexte et les arguments sont d'égale importance et doivent être mémorisés. Nous avons besoin d'eux simultanément pour reproduire l'appel.
37+
3. ...Ensuite, après le passage de `ms` millisecondes,`setTimeout` se déclenche. L'état de refroidissement est supprimé (`isThrottled = false`). Et si nous avions ignoré les appels, alors `wrapper` est exécuté avec les derniers arguments et contextes mémorisés.
3838

39-
The 3rd step runs not `func`, but `wrapper`, because we not only need to execute `func`, but once again enter the cooldown state and setup the timeout to reset it.
39+
La 3ème étape n’exécute pas `func`, mais `wrapper`, car nous devons non seulement exécuter `func`, mais encore une fois entrer dans l’état de refroidissement et configurer le délai d’expiration pour le réinitialiser.

1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -2,47 +2,47 @@ importance: 5
22

33
---
44

5-
# Throttle decorator
5+
# Décorateur d'étranglement
66

7-
Create a "throttling" decorator `throttle(f, ms)` -- that returns a wrapper, passing the call to `f` at maximum once per `ms` milliseconds. Those calls that fall into the "cooldown" period, are ignored.
7+
Créez un décorateur "d'étranglement" `throttle(f, ms)` - qui retourne un wrapper, en passant l'appel à `f` au maximum une fois par `ms` millisecondes. Les appels qui tombent dans le "temps de recharge" sont ignorés.
88

9-
**The difference with `debounce` -- if an ignored call is the last during the cooldown, then it executes at the end of the delay.**
9+
**La différence avec `debounce` - si un appel ignoré est le dernier pendant le temps de recharge, il s'exécute à la fin du délai.**
1010

11-
Let's check the real-life application to better understand that requirement and to see where it comes from.
11+
Examinons l'application réelle pour mieux comprendre cette exigence et voir d'où elle vient.
1212

13-
**For instance, we want to track mouse movements.**
13+
**Par exemple, nous voulons suivre les mouvements de la souris.**
1414

15-
In browser we can setup a function to run at every mouse movement and get the pointer location as it moves. During an active mouse usage, this function usually runs very frequently, can be something like 100 times per second (every 10 ms).
15+
Dans le navigateur, nous pouvons configurer une fonction à exécuter à chaque mouvement de la souris et obtenir l’emplacement du pointeur à mesure qu’il se déplace. Pendant une utilisation active de la souris, cette fonction est généralement utilisée très souvent et peut atteindre 100 fois par seconde (toutes les 10 ms).
1616

17-
**The tracking function should update some information on the web-page.**
17+
**La fonction de suivi devrait mettre à jour certaines informations sur la page Web.**
1818

19-
Updating function `update()` is too heavy to do it on every micro-movement. There is also no sense in making it more often than once per 100ms.
19+
La mise à jour de la fonction `update()` est trop lourde pour le faire à chaque micro-mouvement. Cela n’a également aucun sens de le faire plus d’une fois toutes les 100 ms.
2020

21-
So we'll wrap it into the decorator: use `throttle(update, 100)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but `update()` will be called at maximum once per 100ms.
21+
Nous allons donc l'envelopper dans le décorateur: utilisez `throttle(update, 100)` comme fonction à exécuter à chaque déplacement de souris à la place de `update()` d'origine. Le décorateur sera appelé souvent, mais `update()` sera appelé au maximum une fois toutes les 100 ms.
2222

23-
Visually, it will look like this:
23+
Visuellement, cela ressemblera à ceci:
2424

25-
1. For the first mouse movement the decorated variant passes the call to `update`. That's important, the user sees our reaction to their move immediately.
26-
2. Then as the mouse moves on, until `100ms` nothing happens. The decorated variant ignores calls.
27-
3. At the end of `100ms` -- one more `update` happens with the last coordinates.
28-
4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` with last coordinates. So, perhaps the most important, the final mouse coordinates are processed.
25+
1. Pour le premier mouvement de souris, la variante décorée passe l'appel à `update`. Cela est important, l'utilisateur voit notre réaction à leur mouvement immédiatement.
26+
2. Puis, alors que la souris continue d'avancer, il ne se passe plus rien jusqu'à 100ms. La variante décorée ignore les appels.
27+
3. À la fin de `100ms` - une autre `update` se produit avec les dernières coordonnées.
28+
4. Enfin, la souris s’arrête quelque part. La variante décorée attend que `100ms` expire, puis lance `update` avec les dernières coordonnées. Donc, peut-être le plus important, les coordonnées finales de la souris sont traitées.
2929

30-
A code example:
30+
Un exemple de code:
3131

3232
```js
3333
function f(a) {
3434
console.log(a)
3535
};
3636

37-
// f1000 passes calls to f at maximum once per 1000 ms
37+
// f1000 passe les appels à f au maximum une fois toutes les 1000 ms
3838
let f1000 = throttle(f, 1000);
3939

40-
f1000(1); // shows 1
41-
f1000(2); // (throttling, 1000ms not out yet)
42-
f1000(3); // (throttling, 1000ms not out yet)
40+
f1000(1); // montre 1
41+
f1000(2); // (étranglement, 1000ms pas encore écoulée)
42+
f1000(3); // (étranglement, 1000ms pas encore écoulée)
4343

44-
// when 1000 ms time out...
45-
// ...outputs 3, intermediate value 2 was ignored
44+
// quand 1000ms expirent...
45+
// ...sort 3, la valeur intermédiaire 2 a été ignorée
4646
```
4747

48-
P.S. Arguments and the context `this` passed to `f1000` should be passed to the original `f`.
48+
P.S. Les arguments et le contexte `this` transmis à `f1000` doivent être transmis à `f` d'origine.

0 commit comments

Comments
 (0)