docs: update call-apply-decorators/throttle article

Author: nazarepiedady

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

@@ -7,28 +7,33 @@ function throttle(func, ms) {
   function wrapper() {
 
     if (isThrottled) {
-      // memorizar os últimos argumentos para a chamada depois da espera
+      // memorizar os últimos argumentos a
+      // chamar depois arrefecimento
       savedArgs = arguments;
       savedThis = this;
       return;
     }
 
-    // caso contrário vá para o estado de espera
+    // caso contrário, passa ao estado
+    // de arrefecimento
     func.apply(this, arguments);
 
     isThrottled = true;
 
-    // planeia reinicializar isThrottled depois do atraso
+    // planear reiniciar `isThrottled`
+    // depois do atraso
     setTimeout(function() {
       isThrottled = false;
       if (savedArgs) {
-        // se houver chamadas, savedThis/saveArgs tem a última
-        // a chamada recursiva executa a função e configura a espera novamente
+        // se houve chamadas, `savedThis` ou
+        // `savedArgs` tem a última
+        // a chamada recursiva executa a função
+        // e define novamente o arrefecimento
         wrapper.apply(savedThis, savedArgs);
         savedArgs = savedThis = null;
       }
     }, ms);
   }
 
   return wrapper;
-}
+}

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

@@ -29,11 +29,11 @@ describe("throttle(f, 1000)", function() {
 
   it(" a terceira chamada espera 1000ms depois da segunda chamada", function() {
     this.clock.tick(100);
-    f1000(4); // (throttling - menos do que 1000ms desde a última execução)
+    f1000(4); // (regulação - menos do que 1000ms desde a última execução)
     this.clock.tick(100);
-    f1000(5); // (throttling - menos do que 1000ms desde a última execução)
+    f1000(5); // (regulação - menos do que 1000ms desde a última execução)
     this.clock.tick(700);
-    f1000(6); // (throttling - menos do que 1000ms desde a última execução)
+    f1000(6); // (regulação - menos do que 1000ms desde a última execução)
 
     this.clock.tick(100); // agora 100 + 100 + 700 + 100 = 1000ms se passaram
 
@@ -48,7 +48,7 @@ describe("throttle(f, 1000)", function() {
 
 describe('throttle', () => {
 
-  it('executa a chamada encaminhada uma vez', done => {
+  it('executa uma chamada encaminhada uma vez', done => {
     let log = '';
     const f = str => log += str;
     const f10 = throttle(f, 10);

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

@@ -29,10 +29,10 @@ function throttle(func, ms) {
 }
 ```
 
-Uma chamada de `throttle(func, ms)` retorna `wrapper`.
+Uma chamada a `throttle(func, ms)` retorna `wrapper`.
 
-1. Durante a primeira chamada, o `wrapper` apenas executa `func` e configura o estado de espera (`isThrottled = true`).
-2. Neste estado todas as chamadas são memorizadas em `savedArgs/savedThis`. Note que ambos, o contexto e os argumentos, são igualmente importantes e devem ser memorizados. Nós precisamos deles simultaneamente para reproduzir a chamada.
-3. Depois que `ms` milissegundos passam, `setTimeout` é acionada. O estado de espera é removido (`isThrottled = false`) e, se nós tivermos chamadas ignoradas , o `wrapper` é executado com os últimos argumentos e contexto memorizados.
+1. Durante a primeira chamada, o `wrapper` apenas executa a `func` e define o estado de arrefecimento (`isThrottled = true`).
+2. Neste estado todas as chamadas são memorizadas em `savedArgs/savedThis`. É de notar que tanto o contexto como os argumentos são igualmente importantes e devem ser memorizados. Nós precisamos destes simultaneamente para reproduzir a chamada.
+3. Após `ms` milissegundos, `setTimeout` é acionada. O estado de arrefecimento é removido (`isThrottled = false`) e, se tivermos ignorado chamadas, o `wrapper` é executado com os últimos argumentos e contexto memorizados.
 
-O terceiro passo executa não `func`, mas o `wrapper`, porque nós não só precisamos de executar `func`, mas mais uma vez, de entrar no estado de espera e configurar o tempo limite para reiniciá-lo.
+O terceiro passo não executa a `func`, mas sim o `wrapper`, porque não só precisamos de executar a `func`, como também entrar novamente no estado de arrefecimento e configurar o tempo de espera para reiniciá-lo.

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

@@ -2,52 +2,52 @@ importance: 5
 
 ---
 
-# O Decorador Throttle
+# Decorador Regulador
 
-Crie um decorador de "estrangulamento" `throttle(f, ms)` -- que retorne um encapsulador.
+Crie um decorador de "regulação" `throttle(f, ms)` -- que retorna uma função envolvente.
 
-Quando for chamado várias vezes, ele passa a chamada para `f` no máximo uma vez por `ms` milissegundos.
+Quando é chamado várias vezes, este passa a chamada a `f` no máximo uma vez por `ms` milissegundos.
 
-A diferença de debounce é que é um decorador completamente diferente:
-- `debounce` executa a função uma vez depois do período de "espera". Boa para processar o resultado final.
-- `throttle` não é executada mais do que uma vez em `ms` de tempo. Boa para atualizações regulares que não sejam efectuadas num intervalo de tempo pequeno.
+Em comparação com o decorador de redução, o comportamento é completamente diferente:
+- `debounce` executa a função uma vez após o período de "arrefecimento". Bom para processar o resultado final.
+- `throttle` executa a função não mais frequentemente do que o tempo dado `ms`. Bom para atualizações regulares que não devem ser muito frequentes.
 
-Por outras palavras, `throttle` é como uma secretária que aceita chamadas telefónicas, mas incomonda o chefe (chama a `f` atual) não mais do que uma vez por`ms` milissegundos.
+Por outras palavras, `throttle` é como uma secretária que aceita chamadas telefónicas, mas que incomoda a chefe (chama a verdadeira `f`) não mais do que uma vez por `ms` milissegundos.
 
-Vamos verificar a aplicação na vida real para melhor compreender esse requisito e ver de onde ele vem.
+Vejamos a aplicação na realidade para compreender melhor este requisito e ver de onde vem.
 
 **Por exemplo, queremos rastrear movimentos do rato**
 
-Num navegador, nós podemos configurar uma função para ser executada a cada movimento do rato e receber a localização do ponteiro à medida que ele se move. Num período de uso constante do rato, esta função geralmente é executada com muita frequência, pode ser algo como 100 vezes por segundo (a cada 10 ms).
-**Gostaríamos de atualizar alguma informação na página web sempre que o ponteiro se mover.**
+Num navegador, podemos configurar uma função para ser executada em cada movimento do rato e obter a localização do ponteiro à medida que este se move. Durante uma utilização ativa do rato, esta função é normalmente executada com muita frequência, podendo ser algo como 100 vezes por segundo (a cada 10 milissegundos).**Gostaríamos de atualizar algumas informações na página da Web quando o ponteiro se move.**
 
-A função de atualização `update()` é muito pesada de se fazer a cada micro-movimento. Também não faz sentido executar isso mais de uma vez por 100ms.
+...Mas a função de atualização `update()` é demasiado pesada para o fazer em cada micro-movimento. Também não faz sentido atualizar mais do que uma vez por 100ms.
 
-Portanto, vamos atribuir `throttle(update, 100)` como a função a ser executada a cada movimento de rato ao invés da `update()` original. O decorador será chamado com frequência, porém `update()` será chamada no máximo uma vez por 100ms.
+Por isso, a envolveremos no decorador: usamos `throttle(update, 100)` como uma função a ser executada em cada movimento do rato, em vez da `update` original. O decorador será chamado frequentemente, mas encaminhará a chamada a `update` no máximo uma vez a cada 100ms.
 
-Visualmente, se parecerá com algo assim:
+Visualmente, terá o seguinte aspeto:
 
 1. Para o primeiro movimento do rato a variante decorada passa a chamada para `update`. É importante que o usuário veja a nossa reação aos seus movimentos imediatamente.
-2. Depois, ao mover do rato, até `100ms` nada acontece. A variante decorada ignora as chamadas.
-3. Ao final de `100ms` -- mais um `update` acontece com as últimas coordenadas.
-4. Continuando, finalmente, o rato pára em algum lugar. A variante decorada espera até `100ms` expirarem e depois executa o `update` com as últimas coordenadas. Então, talvez o mais importante, as coordenadas finais do rato são processadas.
+1. Para o primeiro movimento do rato, a variante decorada passa imediatamente a chamada a `update`. Isso é importante, o usuário vê a nossa reação ao seu movimento imediatamente.
+2. Depois, à medida que o rato se move, até `100ms` nada acontece. A variante decorada ignora as chamadas.
+3. No final de `100ms` -- mais uma `update` acontece com as últimas coordenadas.
+4. Então, finalmente, o rato para em algum lugar. A variante decorada espera até `100ms` expiraram e depois executa a `update` com as últimas coordenadas. Assim, o mais importante, as últimas coordenadas do rato são processadas.
 
-Um código de exemplo:
+Um exemplo de código:
 
 ```js
 function f(a) {
   console.log(a);
 }
 
-// f1000 passa chamadas para f no máximo uma vez por 1000 ms
+// f1000 passa chamadas a `f` no máximo uma vez por 1000 ms
 let f1000 = throttle(f, 1000);
 
 f1000(1); // exibe 1
-f1000(2); // (estrangulamento, 1000ms ainda não passaram)
-f1000(3); // (estrangulamento, 1000ms ainda não passaram)
+f1000(2); // (regulação, 1000ms ainda não passaram)
+f1000(3); // (regulação, 1000ms ainda não passaram)
 
-// quando o tempo de 1000ms estiver esgotado...
+// quando o tempo de 1000ms se esgota...
 // ...exibe 3, o valor intermédio 2 foi ignorado
 ```
 
-P.S. Os argumentos e o contexto `this` passados para `f1000` devem ser passados para a função original `f`.
+P.S. Os argumentos e o contexto de `this` passados a `f1000` devem ser passados a `f` original.