Decorators and forwarding, call/apply

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

@@ -1,7 +1,8 @@
 function spy(func) {
 
   function wrapper(...args) {
-    // using ...args instead of arguments to store "real" array in wrapper.calls
+    // usar `...args` ao invés de `arguments`
+    // para armazenar o vetor "real" no `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 teu código
 }
 
-

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

@@ -18,18 +18,17 @@ describe("spy", function() {
   });
 
   it("transparently wraps functions", function() {
-
+    
     let sum = sinon.spy((a, b) => a + b);
 
     let wrappedSum = spy(sum);
 
     assert.equal(wrappedSum(1, 2), 3);
-    assert(sum.calledWith(1, 2));
+    assert(sum.calledWidth(1, 2));
   });
 
-
   it("transparently wraps methods", function() {
-
+    
     let calc = {
       sum: sinon.spy((a, b) => a + b)
     };
@@ -40,5 +39,4 @@ describe("spy", function() {
     assert(calc.sum.calledWith(1, 2));
     assert(calc.sum.calledOn(calc));
   });
-
-});
+});

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 embrulhador retornado pela `spy(f)` deve armazenar todos os argumentos e então 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 de Espionagem
 
-Create a decorator `spy(func)` that should return a wrapper that saves all calls to function in its `calls` property.
+Cria um decorador `spy(func)` que retorna um embrulhador que guarde todas as chamadas à função na sua propriedade `calls`.
 
-Every call is saved as an array of arguments.
+Toda chamada é guardada num vetor 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ário
 }
 
 *!*
@@ -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-escrito: Este 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 após o tempo de espera especificado", function() {
     let start = Date.now();
 
     function f(x) {
@@ -16,12 +16,12 @@ describe("delay", function() {
     f = sinon.spy(f);
 
     let f1000 = delay(f, 1000);
-    f1000("test");
+    f1000("teste");
     this.clock.tick(2000);
-    assert(f.calledOnce, 'calledOnce check fails');
+    assert(f.calledOnce, 'a verificação de calledOnce falha');
   });
 
-  it("passes arguments and this", function() {
+  it("passa os argumentos e o contexto de this", function() {
     let start = Date.now();
     let user = {
       sayHi: function(phrase, who) {
@@ -37,10 +37,10 @@ describe("delay", function() {
     let spy = user.sayHi;
     user.sayHi = delay(user.sayHi, 1500);
 
-    user.sayHi("Hello", "John");
+    user.sayHi("Olá", "John");
 
     this.clock.tick(2000);
 
-    assert(spy.calledOnce, 'calledOnce check failed');
+    assert(spy.calledOnce, 'a verificação de 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("teste"); // exibe "teste" após 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.
+Nota como é utilizada aqui uma função de seta (ou função anónima). Como sabemos, as funções de seta não possuem `this` e `arguments` próprios, então `f.apply(this, arguments)` recebe o `this` e `arguments` da função envolvente.
 
-If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (assuming we're in the browser).
+Se passarmos uma função normal, `setTimeout` a chamaria sem argumentos e `this=window` (assumindo que estamos no navegador).
 
-We still can pass the right `this` by using an intermediate variable, but that's a little bit more cumbersome:
+Nós podemos ainda passar o `this` correto utilizando uma variável intermediária, mas isso é um pouco mais complicado:
 
 ```js
 function delay(f, ms) {
 
   return function(...args) {
-    let savedThis = this; // store this into an intermediate variable
+    let savedThis = this; // armazenar isto numa variável intermédia
     setTimeout(function() {
-      f.apply(savedThis, args); // use it here
+      f.apply(savedThis, args); // utilizá-lo aqui
     }, ms);
   };
 

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

@@ -2,25 +2,25 @@ importance: 5
 
 ---
 
-# Delaying decorator
+# Decorador de Atraso
 
-Create a decorator `delay(f, ms)` that delays each call of `f` by `ms` milliseconds.
+Crie um decorador `delay(f, ms)` que atrasa cada chamada de `f` por `ms` milissegundos.
 
-For instance:
+Por exemplo:
 
 ```js
 function f(x) {
   alert(x);
 }
 
-// create wrappers
+// criar funções envolventes
 let f1000 = delay(f, 1000);
 let f1500 = delay(f, 1500);
 
-f1000("test"); // shows "test" after 1000ms
-f1500("test"); // shows "test" after 1500ms
+f1000("teste"); // exibe "teste" após 1000ms
+f1500("teste"); // exibe "teste" após 1500ms
 ```
 
-In other words, `delay(f, ms)` returns a "delayed by `ms`" variant of `f`.
+Por outras palavras, `delay(f, ms)` retorna uma variante "atrasada por `ms`" de `f`.
 
-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 de um único argumento, mas a sua solução deve passar todos os argumentos e o contexto de `this`.

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 - execute-a após um determinado ms', 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 após 1000ms');
   });
 
-  it('for 3 calls - runs the last one after given ms', function () {
+  it('para 3 chamadas - executa a última após determinados ms', 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 (demasiado cedo)
+    setTimeout(() => debounced('c'), 500); // executar (1000ms passados)
     this.clock.tick(1000);
 
-    assert(f.notCalled, 'not called after 1000ms');
+    assert(f.notCalled, 'não é chamada após 1000ms');
 
     this.clock.tick(500);
 
-    assert(f.calledOnceWith('c'), 'called after 1500ms');
+    assert(f.calledOnceWith('c'), 'chamada após 1500ms');
   });
 
-  it('keeps the context of the call', function () {
+  it('mantém 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 nesta entrada:
 <br>
 <input id="input1" placeholder="type here">
 
 <p>
 
-Debounced function <code>debounce(handler, 1000)</code> is called on this input:
+A função <code>debounce(handler, 1000)</code> reduzida é chamada nesta entrada:
 <br>
 <input id="input2" placeholder="type here">
 
 <p>
-<button id="result">The <code>handler</code> puts the result here</button>
+<button id="result">A <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 à `debounce` retorna um embrulhador. Quando chamado, este agenda a chamada da função original depois de dados `ms` e cancela o tempo de espera anterior.