Decorators and forwarding, call/apply

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js

@@ -1,7 +1,7 @@
 function spy(func) {
 
   function wrapper(...args) {
-    // using ...args instead of arguments to store "real" array in wrapper.calls
+    // usando ...args ao invés de arguments para guardar o "verdadeiro" array dentro de wrapper.calls
     wrapper.calls.push(args);
     return func.apply(this, args);
   }

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js

@@ -1,5 +1,4 @@
 function spy(func) {
-  // your code
+  // o seu código
 }
 
-

1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/test.js

@@ -1,5 +1,5 @@
 describe("spy", function() {
-  it("records calls into its property", function() {
+  it("guarde as chamadas dentro da sua propriedade", function() {
     function work() {}
 
     work = spy(work);
@@ -17,7 +17,7 @@ describe("spy", function() {
     ]);
   });
 
-  it("transparently wraps functions", function() {
+  it("encapsula transparentemente as funções", function() {
 
     let sum = sinon.spy((a, b) => a + b);
 
@@ -28,7 +28,7 @@ describe("spy", function() {
   });
 
 
-  it("transparently wraps methods", function() {
+  it("encapsula transparentemente os métodos", function() {
 
     let calc = {
       sum: sinon.spy((a, b) => a + b)

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

@@ -1 +1 @@
-The wrapper returned by `spy(f)` should store all arguments and then use `f.apply` to forward the call.
+O encapsulador retornado por `spy(f)` deve guardar todos os argumentos e depois usar `f.apply` para encaminhar a chamada.

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

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Spy decorator
+# Decorador Spy (espião)
 
-Create a decorator `spy(func)` that should return a wrapper that saves all calls to function in its `calls` property.
+Crie um decorador `spy(func)` que retorne um encapsulador que guarde todas as chamadas de uma função na sua propriedade `calls`.
 
-Every call is saved as an array of arguments.
+Todas as chamadas são guardadas num array de argumentos.
 
-For instance:
+Por exemplo:
 
 ```js
 function work(a, b) {
-  alert( a + b ); // work is an arbitrary function or method
+  alert( a + b ); // work é uma função ou método arbitrários
 }
 
 *!*
@@ -27,4 +27,4 @@ for (let args of work.calls) {
 }
 ```
 
-P.S. That decorator is sometimes useful for unit-testing. Its advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
+P.S. Esse decorador é algumas vezes útil para testes unitários. Sua forma avançada é `sinon.spy` na biblioteca [Sinon.JS](http://sinonjs.org).

1-js/06-advanced-functions/09-call-apply-decorators/02-delay/_js.view/test.js

@@ -7,7 +7,7 @@ describe("delay", function() {
     this.clock.restore();
   });
 
-  it("calls the function after the specified timeout", function() {
+  it("chama a função depois do limite de tempo especificado", function() {
     let start = Date.now();
 
     function f(x) {
@@ -18,10 +18,10 @@ describe("delay", function() {
     let f1000 = delay(f, 1000);
     f1000("test");
     this.clock.tick(2000);
-    assert(f.calledOnce, 'calledOnce check fails');
+    assert(f.calledOnce, 'A verificação do calledOnce falhou');
   });
 
-  it("passes arguments and this", function() {
+  it("passa os argumentos e this", function() {
     let start = Date.now();
     let user = {
       sayHi: function(phrase, who) {
@@ -41,6 +41,6 @@ describe("delay", function() {
 
     this.clock.tick(2000);
 
-    assert(spy.calledOnce, 'calledOnce check failed');
+    assert(spy.calledOnce, 'A verificação do calledOnce falhou');
   });
 });

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

@@ -1,4 +1,4 @@
-The solution:
+A solução:
 
 ```js run demo
 function delay(f, ms) {
@@ -11,22 +11,22 @@ function delay(f, ms) {
 
 let f1000 = delay(alert, 1000);
 
-f1000("test"); // shows "test" after 1000ms
+f1000("test"); // exibe "test" depois de 1000ms
 ```
 
-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.
+Por favor note como uma função seta (arrow function) é usada aqui. Tal como sabemos, funções seta não têm seus próprios `this` e `arguments`, então `f.apply(this, arguments)` recebe `this` e `arguments` a partir do encapsulador.
 
-If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (assuming we're in the browser).
+Se passássemos uma função normal, `setTimeout` iria chamá-la sem argumentos nem `this=window` (assumindo que estávamos no browser).
 
-We still can pass the right `this` by using an intermediate variable, but that's a little bit more cumbersome:
+Ainda podemos passar o `this` certo atráves do uso de uma variável intermédia, porém é um pouco mais difícil:
 
 ```js
 function delay(f, ms) {
 
   return function(...args) {
-    let savedThis = this; // store this into an intermediate variable
+    let savedThis = this; // guarde isto numa variável intermédia
     setTimeout(function() {
-      f.apply(savedThis, args); // use it here
+      f.apply(savedThis, args); // use-a aqui
     }, ms);
   };
 

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

@@ -2,25 +2,25 @@ importance: 5
 
 ---
 
-# Delaying decorator
+# Atrasando o decorador
 
-Create a decorator `delay(f, ms)` that delays each call of `f` by `ms` milliseconds.
+Crie um decorador `delay(f, ms)` que atrase cada chamada de `f` por `ms` milissegundos.
 
-For instance:
+Por exemplo:
 
 ```js
 function f(x) {
   alert(x);
 }
 
-// create wrappers
+// cria encapsuladores
 let f1000 = delay(f, 1000);
 let f1500 = delay(f, 1500);
 
-f1000("test"); // shows "test" after 1000ms
-f1500("test"); // shows "test" after 1500ms
+f1000("test"); // exibe "test" depois de 1000ms
+f1500("test"); // exibe "test" depois de 1500ms
 ```
 
-In other words, `delay(f, ms)` returns a "delayed by `ms`" variant of `f`.
+Por outras palavras, `delay(f, ms)` retorna uma variante de `f` "atrasada em `ms`".
 
-In the code above, `f` is a function of a single argument, but your solution should pass all arguments and the context `this`.
+No código acima, `f` é uma função com um único argumento, porém a sua solução deve passar todos os argumentos e o `this` do contexto.

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/_js.view/test.js

@@ -7,33 +7,33 @@ describe('debounce', function () {
     this.clock.restore();
   });
 
-  it('for one call - runs it after given ms', function () {
+  it('para uma chamada - executa-o depois de dados milissegundos', function () {
     const f = sinon.spy();
     const debounced = debounce(f, 1000);
 
     debounced('test');
-    assert(f.notCalled, 'not called immediately');
+    assert(f.notCalled, 'não é chamada imediatamente');
     this.clock.tick(1000);
-    assert(f.calledOnceWith('test'), 'called after 1000ms');
+    assert(f.calledOnceWith('test'), 'é chamada depois de 1000ms');
   });
 
-  it('for 3 calls - runs the last one after given ms', function () {
+  it('para 3 chamadas - execute a última depois de dados milissegundos', function () {
     const f = sinon.spy();
     const debounced = debounce(f, 1000);
 
     debounced('a');
-    setTimeout(() => debounced('b'), 200); // ignored (too early)
-    setTimeout(() => debounced('c'), 500); // runs (1000 ms passed)
+    setTimeout(() => debounced('b'), 200); // ignorada (cedo demais)
+    setTimeout(() => debounced('c'), 500); // executa (1000ms passados)
     this.clock.tick(1000);
 
-    assert(f.notCalled, 'not called after 1000ms');
+    assert(f.notCalled, 'não é chamada depois de 1000ms');
 
     this.clock.tick(500);
 
-    assert(f.calledOnceWith('c'), 'called after 1500ms');
+    assert(f.calledOnceWith('c'), 'é chamada depois de 1500ms');
   });
 
-  it('keeps the context of the call', function () {
+  it('preserva o contexto da chamada', function () {
     let obj = {
       f() {
         assert.equal(this, obj);

1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html

@@ -1,18 +1,18 @@
 <!doctype html>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 
-Function <code>handler</code> is called on this input:
+A função <code>handler</code> é chamada neste campo de entrada:
 <br>
 <input id="input1" placeholder="type here">
 
 <p>
 
-Debounced function <code>debounce(handler, 1000)</code> is called on this input:
+A função de debounce <code>debounce(handler, 1000)</code> é chamada neste campo de entrada:
 <br>
 <input id="input2" placeholder="type here">
 
 <p>
-<button id="result">The <code>handler</code> puts the result here</button>
+<button id="result">O <code>handler</code> coloca o resultado aqui</button>
 
 <script>
   function handler(event) {
@@ -21,4 +21,4 @@
 
   input1.oninput = handler;
   input2.oninput = _.debounce(handler, 1000);
-</script>
+</script>

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

@@ -9,5 +9,4 @@ function debounce(func, ms) {
 
 ```
 
-A call to `debounce` returns a wrapper. When called, it schedules the original function call after given `ms` and cancels the previous such timeout.
-
+Uma chamada de `debounce` retorna um encapsulador. Quando chamada, ela agenda a chamada original da função depois de certos `ms` e cancela o tempo de espera (timeout) anterior.

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

@@ -2,50 +2,50 @@ importance: 5
 
 ---
 
-# Debounce decorator
+# O decorador Debounce
 
-The result of `debounce(f, ms)` decorator is a wrapper that suspends calls to `f` until there's `ms` milliseconds of inactivity (no calls, "cooldown period"), then invokes `f` once with the latest arguments.
+O resultado do decorador `debounce(f, ms)` é um encapsulador que suspende chamadas de `f` até haver `ms` milissegundos de inactividade (nenhuma chamada, "período de espera"), depois invoca `f` uma vez com os últimos argumentos.
 
-In other words, `debounce` is like a secretary that accepts "phone calls", and waits until there's `ms` milliseconds of being quiet. And only then it transfers the latest call information to "the boss" (calls the actual `f`).
+Por outras palavras, `debounce` é como uma secretária que aceita "chamadas telefónicas", e espera até existirem `ms` milissegundos de inatividade. E, somente então transfere a informação da última chamada para "o chefe" (chama a `f` atual).
 
-For instance, we had a function `f` and replaced it with `f = debounce(f, 1000)`.
+Por exemplo, tinhamos uma função `f` e a substituimos por `f = debounce(f, 1000)`.
 
-Then if the wrapped function is called at 0ms, 200ms and 500ms, and then there are no calls, then the actual `f` will be only called once, at 1500ms. That is: after the cooldown period of 1000ms from the last call.
+Então se a função encapsulada for chamada aos 0ms, 200ms, e 500ms, e depois não houver chamadas, a `f` atual será somente chamada uma vez, aos 1500ms. Ou seja, depois do período de espera de 1000ms após a última chamada.
 
 ![](debounce.svg)
 
-...And it will get the arguments of the very last call, other calls are ignored.
+...E receberá os argumentos da última chamada, outras chamadas são ignoradas.
 
-Here's the code for it (uses the debounce decorator from the [Lodash library](https://lodash.com/docs/4.17.15#debounce)):
+Aqui está o código para isso (que usa o decorador debounce da [biblioteca Lodash](https://lodash.com/docs/4.17.15#debounce)):
 
 ```js
 let f = _.debounce(alert, 1000);
 
 f("a");
 setTimeout( () => f("b"), 200);
 setTimeout( () => f("c"), 500);
-// debounced function waits 1000ms after the last call and then runs: alert("c")
+// a função de debounce espera 1000ms após a última chamada e depois executa: alert("c")
 ```
 
-Now a practical example. Let's say, the user types something, and we'd like to send a request to the server when the input is finished.
+Agora um exemplo prático. Vamos dizer, que o usuário digita alguma coisa, e gostaríamos de fazer um pedido ao servidor quando a entrada tiver terminado.
 
-There's no point in sending the request for every character typed. Instead we'd like to wait, and then process the whole result.
+Não adianta enviar um pedido por cada caractere digitado. Ao invés disso gostariamos de esperar, e então processar todo o resultado.
 
-In a web-browser, we can setup an event handler -- a function that's called on every change of an input field. Normally, an event handler is called very often, for every typed key. But if we `debounce` it by 1000ms, then it will be only called once, after 1000ms after the last input.
+Num navegador, nós podemos configurar um gerenciador de eventos -- uma função que é chamada em todas as alterações no campo de entrada. Normalmente, um gerenciador de eventos é chamado com frequência, a cada tecla pressionada. Porém, se nós fizermos o `debounce` dele por 1000ms, então ele será chamando apenas uma vez, depois de 1000ms após a última entrada.
 
 ```online
 
-In this live example, the handler puts the result into a box below, try it:
+Neste exemplo online, o gerenciador coloca o resultado na caixa abaixo, experimente:
 
 [iframe border=1 src="debounce" height=200]
 
-See? The second input calls the debounced function, so its content is processed after 1000ms from the last input.
+Você vê? A segunda entrada chama a função de debounce, assim o seu conteúdo será processado após 1000ms depois da última entrada.
 ```
 
-So, `debounce` is a great way to process a sequence of events: be it a sequence of key presses, mouse movements or something else.
+Portanto, `debounce` é uma excelente maneira de processar uma sequência de eventos: seja ela uma sequência de teclas pressionadas, movimentos do rato ou alguma outra coisa.
 
-It waits the given time after the last call, and then runs its function, that can process the result.
+Ela espera o tempo dado depois da última chamada, e depois executa a sua tarefa, que pode processar o resultado.
 
-The task is to implement `debounce` decorator.
+A tarefa é implementar o decorador `debounce`.
 
-Hint: that's just a few lines if you think about it :)
+Dica: são apenas uma poucas linhas se você estiver a pensar nisso :)

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

@@ -7,28 +7,28 @@ function throttle(func, ms) {
   function wrapper() {
 
     if (isThrottled) {
-      // memo last arguments to call after the cooldown
+      // memorizar os últimos argumentos para a chamada depois da espera
       savedArgs = arguments;
       savedThis = this;
       return;
     }
 
-    // otherwise go to cooldown state
+    // caso contrário vá para o estado de espera
     func.apply(this, arguments);
 
     isThrottled = true;
 
-    // plan to reset isThrottled after the delay
+    // planeia reinicializar isThrottled depois do atraso
     setTimeout(function() {
       isThrottled = false;
       if (savedArgs) {
-        // if there were calls, savedThis/savedArgs have the last one
-        // recursive call runs the function and sets cooldown again
+        // se houver chamadas, savedThis/saveArgs tem a última
+        // a chamada recursiva executa a função e configura a espera novamente
         wrapper.apply(savedThis, savedArgs);
         savedArgs = savedThis = null;
       }
     }, ms);
   }
 
   return wrapper;
-}
+}