Function object, NFE

1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/solution.md

@@ -1,2 +1,2 @@
 
-The solution uses `count` in the local variable, but addition methods are written right into the `counter`. They share the same outer lexical environment and also can access the current `count`.
+La solución usa `count` en la variable local, pero los métodos de suma se escriben directamente en el `counter`. Comparten el mismo entorno léxico externo y también pueden acceder al `count` actual.

1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md

@@ -2,14 +2,14 @@ importance: 5
 
 ---
 
-# Set and decrease for counter
+# Establecer y disminuir un contador
 
-Modify the code of `makeCounter()` so that the counter can also decrease and set the number:
+Modifique el código de `makeCounter()` para que el contador también pueda disminuir y establecer el número:
 
-- `counter()` should return the next number (as before).
-- `counter.set(value)` should set the counter to `value`.
-- `counter.decrease()` should decrease the counter by 1.
+- `counter()` debería devolver el siguiente número (como antes).
+- `counter.set(value)` debería establecer el contador a `value`.
+- `counter.decrease()` debería disminuir el contador en 1.
 
-See the sandbox code for the complete usage example.
+Consulte el código en el entorno de pruebas para ver el ejemplo de uso completo.
 
-P.S. You can use either a closure or the function property to keep the current count. Or write both variants.
+P.D. Puedes usar un cierre o la propiedad de función para mantener el recuento actual. O escribe ambas variantes.

1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md

@@ -1,9 +1,9 @@
 
-1. For the whole thing to work *anyhow*, the result of `sum` must be function.
-2. That function must keep in memory the current value between calls.
-3. According to the task, the function must become the number when used in `==`. Functions are objects, so the conversion happens as described in the chapter <info:object-toprimitive>, and we can provide our own method that returns the number.
+1. Para que todo funcione *de cualquier forma*, el resultado de `sum` debe ser una función.
+2. Esa función debe mantener en la memoria el valor actual entre llamadas.
+3. Según la tarea, la función debe convertirse en el número cuando se usa en `==`. Las funciones son objetos, por lo que la conversión se realiza como se describe en el capítulo <info:object-toprimitive>, y podemos proporcionar nuestro propio método para devolver el número.
 
-Now the code:
+Ahora el código:
 
 ```js run
 function sum(a) {
@@ -28,28 +28,28 @@ alert( sum(6)(-1)(-2)(-3) ); // 0
 alert( sum(0)(1)(2)(3)(4)(5) ); // 15
 ```
 
-Please note that the `sum` function actually works only once. It returns function `f`.
+Tenga en cuenta que la función `sum` en realidad solo funciona una vez. Devuelve la función `f`.
 
-Then, on each subsequent call, `f` adds its parameter to the sum `currentSum`, and returns itself.
+Luego, en cada llamada posterior, `f` agrega su parámetro a la suma` currentSum`, y se devuelve.
 
-**There is no recursion in the last line of `f`.**
+**No hay recursividad en la última línea de `f`.**
 
-Here is what recursion looks like:
+Así es como se ve la recursividad:
 
 ```js
 function f(b) {
   currentSum += b;
-  return f(); // <-- recursive call
+  return f(); // <-- llamada recursiva
 }
 ```
 
-And in our case, we just return the function, without calling it:
+Y en nuestro caso, solo devolvemos la función, sin llamarla:
 
 ```js
 function f(b) {
   currentSum += b;
-  return f; // <-- does not call itself, returns itself
+  return f; // <-- no se llama a sí mismo, se devuelve
 }
 ```
 
-This `f` will be used in the next call, again return itself, so many times as needed. Then, when used as a number or a string -- the `toString` returns the `currentSum`. We could also use `Symbol.toPrimitive` or `valueOf` here for the conversion.
+Esta `f` se usará en la próxima llamada, nuevamente se devolverá, tantas veces como sea necesario. Luego, cuando se usa como un número o una cadena, el `toString` devuelve el `currentSum`. También podríamos usar `Symbol.toPrimitive` o `valueOf` para la conversión.

1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/task.md

@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Sum with an arbitrary amount of brackets
+# Suma con una cantidad arbitraria de paréntesis
 
-Write function `sum` that would work like this:
+Escriba la función `sum` que funcionaría así:
 
 ```js
 sum(1)(2) == 3; // 1 + 2
@@ -14,4 +14,4 @@ sum(6)(-1)(-2)(-3) == 0
 sum(0)(1)(2)(3)(4)(5) == 15
 ```
 
-P.S. Hint: you may need to setup custom object to primitive conversion for your function.
+P.D. Sugerencia: es posible que deba configurar una conversión personalizada "objeto a primitiva" en su función.