Merge pull request #569 from joaquinelio/deko

joaquinelio · web-flow · commit b6fd46552158 · 2021-10-29T05:28:17.000-03:00
deco actualiz
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js b/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
+    // usamos ...args en lugar de arguments para almacenar un array "real" en wrapper.calls
     wrapper.calls.push(args);
     return func.apply(this, args);
   }
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js
@@ -1,5 +1,5 @@
 function spy(func) {
-  // your code
+  // tu código
 }
 
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Decorador espía
 
-Cree un decorador `spy(func)` que debería devolver un contenedor que guarde todas las llamadas para que funcionen en su propiedad `calls`
+Cree un decorador `spy(func)` que devuelva un contenedor el cual guarde todas las llamadas a la función en su propiedad `calls`
 
 Cada llamada se guarda como un array de argumentos.
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
@@ -14,7 +14,7 @@ let f1000 = delay(alert, 1000);
 f1000("test"); // mostrar "test" después de 1000ms
 ```
 
-Tenga en cuenta cómo se utiliza una función de flecha aquí. Como sabemos, las funciones de flecha no tienen contextos propios `this` ni `argumentos`, por lo que `f.apply(this, arguments)` toma `this` y `arguments` del contenedor.
+Tenga en cuenta cómo se utiliza una función de flecha aquí. Como sabemos, las funciones de flecha no tienen contextos propios `this` ni `arguments`, por lo que `f.apply(this, arguments)` toma `this` y `arguments` del contenedor.
 
 Si pasamos una función regular, `setTimeout` lo llamaría sin argumentos y `this = window` (suponiendo que estemos en el navegador).
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html b/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:
+La función <code>handler</code> se llama en este input:
 <br>
 <input id="input1" placeholder="type here">
 
 <p>
 
-Debounced function <code>debounce(handler, 1000)</code> is called on this input:
+La función <code>debounce(handler, 1000)</code> se llama en este input:
 <br>
 <input id="input2" placeholder="type here">
 
 <p>
-<button id="result">The <code>handler</code> puts the result here</button>
+<button id="result">El <code>handler</code> pone el resultado aquí</button>
 
 <script>
   function handler(event) {
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js
@@ -7,23 +7,23 @@ function throttle(func, ms) {
   function wrapper() {
 
     if (isThrottled) {
-      // memo last arguments to call after the cooldown
+      // memoriza el último arguments para llamarlos después del enfriamiento
       savedArgs = arguments;
       savedThis = this;
       return;
     }
 
-    // otherwise go to cooldown state
+    // de otro modo pasa al estado de enfriamiento
     func.apply(this, arguments);
 
     isThrottled = true;
 
-    // plan to reset isThrottled after the delay
+    // se prepara para reiniciar isThrottled después del delay
     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
+        // si hubo llamadas, savedThis/savedArgs tienen la última
+        // llamada recursivas ejecutan la función y establece el enfriamiento de nuevo
         wrapper.apply(savedThis, savedArgs);
         savedArgs = savedThis = null;
       }
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
@@ -16,14 +16,14 @@ En otras palabras, "throttle" es como una secretaria que acepta llamadas telefó
 
 Revisemos una aplicación de la vida real para comprender mejor ese requisito y ver de dónde proviene.
 
-**Por ejemplo, queremos rastrear los movimientos del mouse.**
+**Por ejemplo, queremos registrar los movimientos del mouse.**
 
 En un navegador, podemos configurar una función para que se ejecute en cada movimiento del mouse y obtener la ubicación del puntero a medida que se mueve. Durante un uso activo del mouse, esta función generalmente se ejecuta con mucha frecuencia, puede ser algo así como 100 veces por segundo (cada 10 ms).
 **Nos gustaría actualizar cierta información en la página web cuando se mueve el puntero.**
 
 ...Pero la función de actualización `update()` es demasiado pesada para hacerlo en cada micro-movimiento. Tampoco tiene sentido actualizar más de una vez cada 100 ms.
 
-Entonces lo envolveremos en el decorador: use `throttle(update, 100)` como la función para ejecutar en cada movimiento del mouse en lugar del original `update()`. Se llamará al decorador con frecuencia, pero reenviará la llamada a `update()` como máximo una vez cada 100 ms.
+Entonces lo envolveremos en el decorador: para ejecutar en cada movimiento del mouse, usamos `throttle(update, 100)` en lugar del `update()` original. Se llamará al decorador con frecuencia, pero reenviará la llamada a `update()` como máximo una vez cada 100 ms.
 
 Visualmente, se verá así:
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -1,12 +1,12 @@
 # Decoradores y redirecciones, call/apply
 
-JavaScript ofrece una flexibilidad excepcional cuando se trata de funciones. Se pueden pasar, usar como objetos, y ahora veremos cómo *redireccionar* las llamadas entre ellos y *decorarlos*.
+JavaScript ofrece una flexibilidad excepcional cuando se trata de funciones. Se pueden pasar, usar como objetos, y ahora veremos cómo *redirigir* las llamadas entre ellos y *decorarlos*.
 
 ## Caché transparente
 
 Digamos que tenemos una función `slow(x)` que es pesada para la CPU, pero sus resultados son estables. En otras palabras, la misma `x` siempre devuelve el mismo resultado.
 
-Si la función se llama con frecuencia, es posible que queramos almacenar en caché (recordar) los resultados para evitar perder tiempo extra en los nuevos cálculos.
+Si la función se llama con frecuencia, es posible que queramos almacenar en caché (recordar) los resultados para evitar perder tiempo extra en nuevos cálculos.
 
 Pero en lugar de agregar esa funcionalidad en `slow()` crearemos una función de contenedor, que agrega almacenamiento en caché. Como veremos, hacer esto trae beneficios.
 
@@ -37,7 +37,7 @@ function cachingDecorator(func) {
 slow = cachingDecorator(slow);
 
 alert( slow(1) ); // slow(1) es cacheado y se devuelve el resultado
-alert( "Again: " + slow(1) ); // el resultado slow(1) es devuelto desde cache
+alert( "Again: " + slow(1) ); // el resultado slow(1) es devuelto desde caché
 
 alert( slow(2) ); // slow(2) es cacheado y devuelve el resultado
 alert( "Again: " + slow(2) ); // el resultado slow(2) es devuelto desde caché
@@ -58,7 +58,7 @@ Desde un código externo, la función `slow` envuelta sigue haciendo lo mismo. S
 Para resumir, hay varios beneficios de usar un `cachingDecorator` separado en lugar de alterar el código de `slow` en sí mismo:
 
 - El `cachingDecorator` es reutilizable. Podemos aplicarlo a otra función.
-- La lógica de almacenamiento en caché es independiente, no aumentó la complejidad de `slow` en sí misma(si hubiera alguna).
+- La lógica de almacenamiento en caché es independiente, no aumentó la complejidad de `slow` en sí misma (si hubiera alguna).
 - Podemos combinar múltiples decoradores si es necesario.
 
 ## Usando "func.call" para el contexto
@@ -231,7 +231,7 @@ Anteriormente, para un solo argumento `x` podríamos simplemente usar `cache.set
 Hay muchas posibles soluciones:
 
 1. Implemente una nueva estructura de datos similar a un mapa (o use una de un tercero) que sea más versátil y permita múltiples propiedades.
-2. Use mapas anidados `cache.set(min)` será un `Map` que almacena el par `(max, result)`. Para que podamos obtener `result` como `cache.get(min).get(max)`.
+2. Use mapas anidados: `cache.set(min)` será un `Map` que almacena el par `(max, result)`. Así podemos obtener `result` como `cache.get(min).get(max)`.
 3. Una dos valores en uno. En nuestro caso particular, podemos usar un string `"min,max"` como la propiedad de `Map`. Por flexibilidad, podemos permitir proporcionar un *función hashing* para el decorador, que sabe hacer un valor de muchos.
 
 Para muchas aplicaciones prácticas, la tercera variante es lo suficientemente buena, por lo que nos mantendremos en esa opción.
@@ -382,22 +382,21 @@ Esto se debe a que el algoritmo interno del método nativo `arr.join (glue)` es
 
 Tomado de la especificación casi "tal cual":
 
-1. Deje que `glue` sea el primer argumento o, si no hay argumentos, entonces una coma `","`.
-2. Deje que `result` sea una cadena vacía.
-3. Agregue `this[0]` a `result`.
-4. Agregue `glue` y `this[1]`.
-5. Agregue `glue` y `this[2]`.
-6. ...hazlo hasta que los elementos `this.length` estén adheridos.
-7. Devuelva `result`.
+1. Hacer que `glue` sea el primer argumento o, si no hay argumentos, entonces una coma `","`.
+2. Hacer que `result` sea una cadena vacía.
+3. Adosar `this[0]` a `result`.
+4. Adherir `glue` y `this[1]`.
+5. Adherir `glue` y `this[2]`.
+6. ...hacerlo hasta que la cantidad `this.length` de elementos estén adheridos.
+7. Devolver `result`.
 
-Entones, técnicamente `this` une `this[0]`, `this[1]` ...etc. Está escrito intencionalmente de una manera que permite cualquier tipo de array `this` (no es una coincidencia, muchos métodos siguen esta práctica). Es por eso que también funciona con `this = arguments`
+Entonces, técnicamente `this` une `this[0]`, `this[1]` ...etc. Está escrito intencionalmente de una manera que permite cualquier tipo de array `this` (no es una coincidencia, muchos métodos siguen esta práctica). Es por eso que también funciona con `this = arguments`
 
 ## Decoradores y propiedades de funciones
 
-Por lo general, es seguro reemplazar una función o un método con un decorador, excepto por una pequeña cosa. Si la función original tenía propiedades, como `func.calledCount` o cualquier otra, entonces la función decoradora no las proporcionará. Porque eso es una envoltura. Por lo tanto, se debe tener cuidado al usarlo.
+Por lo general, es seguro reemplazar una función o un método con un decorador, excepto por una pequeña cosa. Si la función original tenía propiedades (como `func.calledCount` o cualquier otra) entonces la función decoradora no las proporcionará. Porque es una envoltura. Por lo tanto, se debe tener cuidado al usarlo.
 
-
-E.j. en el ejemplo anterior, si la función `slow` tenía propiedades, entonces `cachingDecorator(slow)` sería un contenedor, pero sin contener dichas propiedades.
+En el ejemplo anterior, si la función `slow` tuviera propiedades, `cachingDecorator(slow)` sería un contenedor sin dichas propiedades.
 
 Algunos decoradores pueden proporcionar sus propias propiedades. P.ej. un decorador puede contar cuántas veces se invocó una función y cuánto tiempo tardó, y exponer esta información a través de propiedades de envoltura.
 
@@ -422,6 +421,6 @@ let wrapper = function() {
 };
 ```
 
-También vimos un ejemplo de *préstamo de método* cuando tomamos un método de un objeto y lo `llamamos` en el contexto de otro objeto. Es bastante común tomar métodos de array y aplicarlos a `argumentos`. La alternativa es utilizar el objeto de parámetros rest que es un array real.
+También vimos un ejemplo de *préstamo de método* cuando tomamos un método de un objeto y lo `llamamos` en el contexto de otro objeto. Es bastante común tomar métodos de array y aplicarlos al símil-array `arguments`. La alternativa es utilizar el objeto de parámetros rest que es un array real.
 
-Hay muchos decoradores a tu alrededor. Verifica si eres bueno resolviendo las tareas de este capítulo.
+Hay muchos decoradores a tu alrededor. Verifica qué tan bien los entendiste resolviendo las tareas de este capítulo.

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`function spy(func) {`
`2`	`2`
`3`	`3`	`function wrapper(...args) {`
`4`		`- // using ...args instead of arguments to store "real" array in wrapper.calls`
	`4`	`+ // usamos ...args en lugar de arguments para almacenar un array "real" en wrapper.calls`
`5`	`5`	`wrapper.calls.push(args);`
`6`	`6`	`return func.apply(this, args);`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`function spy(func) {`
`2`		`- // your code`
	`2`	`+ // tu código`
`3`	`3`	`}`
`4`	`4`
`5`	`5`