Susy201113

1-js/06-advanced-functions/01-recursion/article.md

@@ -132,7 +132,7 @@ Podemos esbozarlo como:
   </li>
 </ul>
 
-Ahí es cuando la función comienza a ejecutarse. La condición `n == 1` es falsa, por lo que el flujo continúa en la segunda rama de` if`:
+Ahí es cuando la función comienza a ejecutarse. La condición `n == 1` es falsa, por lo que el flujo continúa en la segunda rama de `if`:
 
 ```js run
 function pow(x, n) {

1-js/08-prototypes/01-prototype-inheritance/article.md

@@ -27,7 +27,7 @@ let rabbit = {
 };
 
 *!*
-rabbit.__proto__ = animal;
+rabbit.__proto__ = animal; // establece rabbit.[[Prototype]] = animal
 */!*
 ```
 

1-js/11-async/01-callbacks/article.md

@@ -144,7 +144,7 @@ loadScript('/my/script.js', function(script) {
     });
 */!*
 
-  })
+  });
 
 });
 ```
@@ -221,7 +221,7 @@ loadScript('1.js', function(error, script) {
         });
 
       }
-    })
+    });
   }
 });
 ```
@@ -279,7 +279,7 @@ loadScript('1.js', function(error, script) {
           }
         });
       }
-    })
+    });
   }
 });
 -->
@@ -319,7 +319,7 @@ function step3(error, script) {
   } else {
     // ...continua despues que se han cargado todos los scripts (*)
   }
-};
+}
 ```
 
 ¿Lo Ves? Hace lo mismo, y ahora no hay anidamiento profundo porque convertimos cada acción en una función de nivel superior separada.

1-js/11-async/05-promise-api/article.md

@@ -176,15 +176,14 @@ Entonces para cada promesa obtendremos su estado y `value/error`.
 Si el browser no soporta `Promise.allSettled`, es fácil implementarlo:
 
 ```js
-if(!Promise.allSettled) {
-  Promise.allSettled = function(promises) {
-    return Promise.all(promises.map(p => Promise.resolve(p).then(value => ({
-      status: 'fulfilled',
-      value
-    }), reason => ({
-      status: 'rejected',
-      reason
-    }))));
+if (!Promise.allSettled) {
+  const rejectHandler = reason => ({ status: 'rejected', reason });
+
+  const resolveHandler = value => ({ status: 'fulfilled', value });
+
+  Promise.allSettled = function (promises) {
+    const convertedPromises = promises.map(p => Promise.resolve(p).then(resolveHandler, rejectHandler));
+    return Promise.all(convertedPromises);
   };
 }
 ```

1-js/11-async/06-promisify/article.md

@@ -25,15 +25,16 @@ function loadScript(src, callback) {
 
 Vamos a promisificarla. La función nueva `loadScriptPromise(src)` va a hacer lo mismo, pero solo acepta `src` (sin callback) y retorna una promesa.
 
+Aquí:
 ```js
 let loadScriptPromise = function(src) {
   return new Promise((resolve, reject) => {
     loadScript(src, (err, script) => {
-      if (err) reject(err)
+      if (err) reject(err);
       else resolve(script);
     });
-  })
-}
+  });
+};
 
 // uso:
 // loadScriptPromise('path/script.js').then(...)
@@ -66,7 +67,7 @@ function promisify(f) {
       f.call(this, ...args); // llama a la función original
     });
   };
-};
+}
 
 // uso:
 let loadScriptPromise = promisify(loadScript);
@@ -98,11 +99,11 @@ function promisify(f, manyArgs = false) {
       f.call(this, ...args);
     });
   };
-};
+}
 
 // Uso:
 f = promisify(f, true);
-f(...).then(arrayOfResults => ..., err => ...)
+f(...).then(arrayOfResults => ..., err => ...);
 ```
 En algunos casos, puede que `err` esté ausente: `callback(result)`, o que haya algo que no es habitual en el formato del callback, por lo que tendremos que promisificar tales funciones manualmente.
 

1-js/11-async/08-async-await/01-rewrite-async/task.md

@@ -12,7 +12,7 @@ function loadJson(url) {
       } else {
         throw new Error(response.status);
       }
-    })
+    });
 }
 
 loadJson('no-such-user.json')

1-js/11-async/08-async-await/02-rewrite-async-2/task.md

@@ -1,7 +1,7 @@
 
 # Reescribir "rethrow" con async/await
 
-Debajo puedes encontrar el ejemplo "rethrow" del capítulo <info:promise-chaining>. Rescríbelo usando `async/await` en vez de `.then/catch`.
+Debajo puedes encontrar el ejemplo "rethrow". Rescríbelo usando `async/await` en vez de `.then/catch`.
 
 Y deshazte de la recursión en favor de un bucle en `demoGithubUser`: con `async/await`, que se vuelve fácil de hacer.
 
@@ -22,7 +22,7 @@ function loadJson(url) {
       } else {
         throw new HttpError(response);
       }
-    })
+    });
 }
 
 // Pide nombres hasta que github devuelve un usuario válido

1-js/11-async/08-async-await/article.md

@@ -156,7 +156,7 @@ class Thenable {
     // resuelve con this.num*2 después de 1000ms
     setTimeout(() => resolve(this.num * 2), 1000); // (*)
   }
-};
+}
 
 async function f() {
   // espera durante 1 segundo, entonces el resultado se vuelve 2

1-js/12-generators-iterators/2-async-iterators-generators/article.md

@@ -363,9 +363,9 @@ Explayando más sobre cómo funciona:
     - La URL inicial es `https://api.github.com/repos/<repo>/commits`, y la siguiente página estará en la cabecera de `Link` de la respuesta.
     - El método `fetch` nos permite suministrar autorización y otras cabeceras si lo necesitamos, aquí GitHub requiere `User-Agent`.
 2. Los commits son devueltos en formato JSON.
-3. Deberíamos obtener la siguiente URL de la página del `enlace` en el encabezado de la respuesta. Esto tiene un formato especial, por lo que usamos una expresión regular para eso. 
+3. Deberíamos obtener la siguiente URL de la página del `enlace` en el encabezado de la respuesta. Esto tiene un formato especial, por lo que usamos una expresión regular para eso (aprenderemos esta característica en [Regular expressions](info:regular-expressions)). 
     - La URL de la página siguiente puede verse así `https://api.github.com/repositories/93253246/commits?page=2`. Eso es generado por el propio Github.
-4. Luego entregamos todas las confirmaciones recibidas, y cuando finalizan, se activará la siguiente iteración `while(url)` haciendo una solicitud más.
+4. Luego entregamos uno por uno todos los "commit" recibidos y, cuando finalizan, se activará la siguiente iteración `while(url)` haciendo una solicitud más.
 
 Un ejemplo de uso (muestra autores de commit en la consola):
 

1-js/13-modules/01-modules-intro/article.md

@@ -260,7 +260,7 @@ Abajo compare con un script normal:
 
 <script>
 *!*
-  alert(typeof button); // Error: button es indefinido, el script no puede ver los elementos de abjo
+  alert(typeof button); // button es indefinido, el script no puede ver los elementos de abajo
 */!*
   // los scripts normales corren inmediatamente, antes que el resto de la página sea procesada
 </script>

1-js/99-js-misc/01-proxy/01-error-nonexisting/solution.md

@@ -19,5 +19,5 @@ function wrap(target) {
 user = wrap(user);
 
 alert(user.name); // John
-alert(user.age); // ReferenceError: Property doesn't exist "age"
+alert(user.age); // ReferenceError: Property doesn't exist: "age"
 ```

1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md

@@ -27,6 +27,6 @@ user = wrap(user);
 
 alert(user.name); // John
 *!*
-alert(user.age); // ReferenceError: Property doesn't exist "age"
+alert(user.age); // ReferenceError: Property doesn't exist: "age"
 */!*
 ```

1-js/99-js-misc/01-proxy/article.md

@@ -39,7 +39,7 @@ As there are no traps, all operations on `proxy` are forwarded to `target`.
 
 As we can see, without any traps, `proxy` is a transparent wrapper around `target`.
 
-![](proxy.svg)  
+![](proxy.svg)
 
 `Proxy` is a special "exotic object". It doesn't have own properties. With an empty `handler` it transparently forwards operations to `target`.
 
@@ -335,7 +335,7 @@ let user = {
   _password: "secret"
 };
 
-alert(user._password); // secret  
+alert(user._password); // secret
 ```
 
 Let's use proxies to prevent any access to properties starting with `_`.
@@ -376,7 +376,7 @@ user = new Proxy(user, {
   },
 *!*
   deleteProperty(target, prop) { // to intercept property deletion
-*/!*  
+*/!*
     if (prop.startsWith('_')) {
       throw new Error("Access denied");
     } else {
@@ -437,7 +437,7 @@ user = {
 ```
 
 
-A call to `user.checkPassword()` call gets proxied `user` as `this` (the object before dot becomes `this`), so when it tries to access `this._password`, the `get` trap activates (it triggers on any property read) and throws an error.
+A call to `user.checkPassword()` gets proxied `user` as `this` (the object before dot becomes `this`), so when it tries to access `this._password`, the `get` trap activates (it triggers on any property read) and throws an error.
 
 So we bind the context of object methods to the original object, `target`, in the line `(*)`. Then their future calls will use `target` as `this`, without any traps.
 

1-js/99-js-misc/04-reference-type/3-why-this/solution.md

@@ -5,7 +5,7 @@ Aquí está la explicación.
 
 2. Lo mismo, aquí los paréntesis no cambian el orden de las operaciones, el punto es el primero de todos modos.
 
-3. Aquí tenemos una llamada más compleja `(expression).method()`. La llamada funciona como si se dividiera en dos líneas:
+3. Aquí tenemos una llamada más compleja `(expression)()`. La llamada funciona como si se dividiera en dos líneas:
 
     ```js no-beautify
     f = obj.go; // Calcula la expresión
@@ -14,7 +14,7 @@ Aquí está la explicación.
 
     Aquí `f()` se ejecuta como una función, sin `this`.
 
-4. Lo mismo que `(3)`, a la izquierda del punto `.` tenemos una expresión.
+4. Lo mismo que `(3)`, a la izquierda de los paréntesis `()` tenemos una expresión.
 
 Para explicar el funcionamiento de `(3)` y `(4)` necesitamos recordar que los accesores de propiedad (punto o corchetes) devuelven un valor del Tipo de Referencia.  
 

1-js/99-js-misc/04-reference-type/article.md

@@ -93,7 +93,7 @@ Tipo de Referencia es un tipo interno de "intermediario", con el propósito de p
 
 Cualquier otra operación como la asignación `hi = user.hi` descarta el tipo de referencia como un todo, toma el valor de `user.hi` (una función) y lo pasa. Entonces cualquier operación "pierde" `this`.
 
-Entonces, como resultado, el valor de `this` solo se pasa de la manera correcta si la función se llama directamente usando una sintaxis de punto `obj.method()` o corchetes `obj['method']()` (aquí hacen lo mismo). Más adelante en este tutorial, aprenderemos varias formas de resolver este problema así como [func.bind()](/bind#solution-2-bind).
+Entonces, como resultado, el valor de `this` solo se pasa de la manera correcta si la función se llama directamente usando una sintaxis de punto `obj.method()` o corchetes `obj['method']()` (aquí hacen lo mismo). Hay varias formas de resolver este problema, como [func.bind()](/bind#solution-2-bind).
 
 ## Resumen
 

2-ui/1-document/05-basic-dom-node-properties/article.md

@@ -198,7 +198,7 @@ En el modo XML, el caso se mantiene "tal cual". Hoy en día, el modo XML rara ve
 
 ## innerHTML: los contenidos
 
-La propiedad [innerHTML](https://w3c.github.io/DOM-Parsing/#widl-Element-innerHTML) permite obtener el HTML dentro del elemento como un string.
+La propiedad [innerHTML](https://w3c.github.io/DOM-Parsing/#the-innerhtml-mixin) permite obtener el HTML dentro del elemento como un string.
 
 También podemos modificarlo. Así que es una de las formas más poderosas de cambiar la página.
 

2-ui/1-document/06-dom-attributes-and-properties/article.md

@@ -297,7 +297,7 @@ Por ejemplo, aquí para el estado del pedido se usa el atributo `order-state`:
 </div>
 ```
 
-¿Por qué sería preferible usar un atributo a tener clases como `.order-state-new`, `.order-state-pending`, `order-state-canceled`?
+¿Por qué sería preferible usar un atributo a tener clases como `.order-state-new`, `.order-state-pending`, `.order-state-canceled`?
 
 Porque un atributo es más conveniente de administrar. El estado se puede cambiar tan fácil como:
 

2-ui/5-loading/02-script-async-defer/article.md

@@ -99,8 +99,8 @@ El atributo `async` significa que el script es completamente independiente:
 
 - El navegador no se bloquea con scripts `async` (como `defer`).
 - Otros scripts no esperan por scripts `async`, y scripts `async` no espera por ellos.
-- El evento `DOMContentLoaded` y los scripts asincrónicos no se esperan entre sí:
-    - El evento `DOMContentLoaded` puede suceder antes que un script asincrónico (si un script asincrónico termina de cargar una vez la página está completa)
+- `DOMContentLoaded` y los scripts asincrónicos no se esperan entre sí:
+    - `DOMContentLoaded` puede suceder antes que un script asincrónico (si un script asincrónico termina de cargar una vez la página está completa)
     - ...o después de un script asincrónico (si tal script asincrónico es pequeño o está en cache)
 
 En otras palabras, los scripts `async` cargan en segundo plano y se ejecutan cuando están listos. El DOM y otros scripts no esperan por ellos, y ellos no esperan por nada. Un totalmente independiente script que se ejecuta en cuanto se ha cargado. Tan simple como es posible, ¿cierto? 

5-network/04-fetch-abort/article.md

@@ -65,7 +65,7 @@ fetch(url, {
 
 El método `fetch` conoce cómo trabajar con `AbortController`. Este escuchará eventos `abort` sobre `signal`.
 
-Ahora, para abortar, llamamo `controller.abort()`:
+Ahora, para abortar, llamamos `controller.abort()`:
 
 ```js
 controller.abort();

9-regular-expressions/16-regexp-sticky/article.md

@@ -15,7 +15,10 @@ E.g. we have a code string `subject:let varName = "value"`, and we need to read
 
 We'll look for variable name using regexp `pattern:\w+`. Actually, JavaScript variable names need a bit more complex regexp for accurate matching, but here it doesn't matter.
 
-A call to `str.match(/\w+/)` will find only the first word in the line. Or all words with the flag `pattern:g`. But we need only one word at position `4`.
+- A call to `str.match(/\w+/)` will find only the first word in the line (`let`). That's not it.
+- We can add the flag `pattern:g`. But then the call `str.match(/\w+/g)` will look for all words in the text, while we need one word at position `4`. Again, not what we need.
+
+**So, how to search for a regexp exactly at the given position?**
 
 To search from the given position, we can use method `regexp.exec(str)`.