Susy201029

1-js/03-code-quality/02-coding-style/article.md

@@ -328,7 +328,7 @@ Aquí un ejemplo de un archivo `.eslintrc`:
   },
   "rules": {
     "no-console": 0,
-    "indent": ["warning", 2]
+    "indent": 2
   }
 }
 ```

1-js/03-code-quality/06-polyfills/article.md

@@ -1,3 +1,4 @@
+
 # Polyfills
 
 El lenguaje JavaScript evoluciona constantemente. Nuevas propuestas al lenguaje aparecen regularmente, son analizadas y, si se consideran valiosas, se agregan a la lista en <https://tc39.github.io/ecma262/> y luego avanzan hasta [specification](http://www.ecma-international.org/publications/standards/Ecma-262.htm).
@@ -22,7 +23,8 @@ En realidad, hay dos partes en Babel:
 
 2. Segundo, el polyfill.
 
-    El transpiler reescribe el código, por lo que se cubren las características de la sintaxis. Pero para funciones nuevas tenemos que escribir un script especial que las implemente. JavaScript es un lenguaje muy dinámico, puede que los scripts no solo agreguen nuevas funciones, sino también modifiquen las funciones incorporadas, para que actúen de forma correspondiente al estándar moderno.
+    Nuevas características del lenguaje pueden incluir no solo contrucciones sintácticas sino también funciones incorporadas.
+    El transpiler reescribe el código, transformando las contrucciones sintácticas nuevas al viejo formato. Pero para funciones nuevas, necesitamos implementarlas. JavaScript es un lenguaje muy dinámico, los scripts pueden agregar o modificar cualquier función para que actúen acorde al estándar moderno.
 
     Existe el término "polyfill" para scripts que "llenan"(fill in) el vacío y agregan las implementaciones que faltan.
 

1-js/04-object-basics/03-garbage-collection/article.md

@@ -13,6 +13,7 @@ Simple, los valores "alcanzables" son aquellos que son accesibles o se pueden ut
 1. Hay un conjunto base de valores inherentemente accesibles, que no se pueden eliminar por razones obvias.
 
     Por ejemplo:
+
     - Variables locales y parámetros de la función actual.
     - Variables y parámetros para otras funciones en la cadena actual de llamadas anidadas.
     - Variables Globales
@@ -22,7 +23,7 @@ Simple, los valores "alcanzables" son aquellos que son accesibles o se pueden ut
 
 2. Cualquier otro valor se considera accesible si es accesible desde una raíz(root) por una referencia o por una cadena de referencias.
 
-Por ejemplo, si hay un objeto en una variable local, y ese objeto tiene una propiedad que hace referencia a otro objeto, ese objeto se considera accesible. Y aquellos a los que hace referencia también son accesibles. Ejemplos detallados a seguir.
+    Por ejemplo, si hay un objeto en una variable local, y ese objeto tiene una propiedad que hace referencia a otro objeto, ese objeto se considera accesible. Y aquellos a los que hace referencia también son accesibles. Ejemplos detallados a seguir.
 
 Hay un proceso en segundo plano en el motor de JavaScript que se llama [recolector de basura] (https://es.wikipedia.org/wiki/Recolector_de_basura). Monitorea todos los objetos y elimina aquellos que se han vuelto inalcanzables.
 
@@ -96,7 +97,9 @@ let family = marry({
   name: "Ann"
 });
 ```
+
 La función `marry` "casa" dos objetos dándoles referencias entre sí y devuelve un nuevo objeto que los contiene a ambos.
+
 La estructura de memoria resultante:
 
 ![](family.svg)
@@ -178,12 +181,13 @@ Ahora los objetos que no se pudieron visitar en el proceso se consideran inalcan
 
 ![](garbage-collection-5.svg)
 
+Podemos imaginar el proceso como derramar un enorme cubo de pintura desde las raíces, que fluye a través de todas las referencias y marca todos los objetos alcanzables. Los elementos que no queden marcados son entonces eliminados.
+
 Ese es el concepto de cómo funciona la recolección de basura. El motor de JavaScript aplica muchas optimizaciones para que se ejecute más rápido y no afecte la ejecución.
 
-Algunas de las optimizaciones
+Algunas de las optimizaciones:
 
-- **Colección generacional** -- los objetos se dividen en dos conjuntos: 
-"nuevos" y "antiguos". Aparecen muchos objetos, hacen su trabajo y mueren rápido, se pueden limpiar agresivamente. Aquellos que sobreviven el tiempo suficiente, se vuelven "viejos" y son examinados con menos frecuencia.
+- **Colección generacional** -- los objetos se dividen en dos conjuntos: "nuevos" y "antiguos". Aparecen muchos objetos, hacen su trabajo y mueren rápido, se pueden limpiar agresivamente. Aquellos que sobreviven el tiempo suficiente, se vuelven "viejos" y son examinados con menos frecuencia.
 - **Colección incremental** -- Si hay muchos objetos y tratamos de caminar y marcar todo el conjunto de objetos a la vez, puede llevar algún tiempo e introducir retrasos visibles en la ejecución. Entonces el motor intenta dividir la recolección de basura en pedazos. Luego las piezas se ejecutan una por una, por separado. Eso requiere una contabilidad adicional entre ellos para rastrear los cambios, pero tenemos muchos pequeños retrasos en lugar de uno grande.
 - **Recolección de tiempo inactivo** -- el recolector de basura trata de ejecutarse solo mientras la CPU está inactiva, para reducir el posible efecto en la ejecución.
 
@@ -204,4 +208,5 @@ Un libro general "The Garbage Collection Handbook: The Art of Automatic Memory M
 Si estás familiarizado con la programación de bajo nivel, la información más detallada sobre el recolector de basura V8 se encuentra en el artículo [A tour of V8: Garbage Collection](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
 
 [V8 blog](http://v8project.blogspot.com/) también publica artículos sobre cambios en la administración de memoria de vez en cuando. Naturalmente, para aprender la recolección de basura, es mejor que se prepare aprendiendo sobre los componentes internos de V8 en general y lea el blog de [Vyacheslav Egorov](http://mrale.ph) que trabajó como uno de los ingenieros de V8. Estoy diciendo: "V8", porque se cubre mejor con artículos en Internet. Para otros motores, muchos enfoques son similares, pero la recolección de basura difiere en muchos aspectos.
+
 El conocimiento profundo de los motores es bueno cuando necesita optimizaciones de bajo nivel. Sería prudente planificar eso como el siguiente paso después de que esté familiarizado con el idioma.

1-js/04-object-basics/04-object-methods/article.md

@@ -34,7 +34,7 @@ user.sayHi(); // ¡Hola!
 
 Aquí simplemente usamos una expresión de función para crear la función y asignarla a la propiedad `user.sayHi` del objeto.
 
-Entonces la llamamos. ¡El usuario ahora puede hablar!
+Entonces la llamamos con `user.sayHi()`. ¡El usuario ahora puede hablar!
 
 Una función que es la propiedad de un objeto es denominada su *método*.
 
@@ -160,14 +160,16 @@ let user = {
 let admin = user;
 user = null; // sobrescribimos para hacer las cosas evidentes
 
-admin.sayHi(); // ¡oops! dentro de sayHi(), ¡Se usa el nombre viejo! ¡Error!
+*!*
+admin.sayHi(); // TypeError: No se puede leer la propiedad 'name' de null
+*/!*
 ```
 
 Si usamos `this.name` en vez de `user.name` dentro de `alert`, entonces el código funciona.
 
 ## "this" no es vinculado
 
-En JavaScript, la palabra clave `this` se comporta de manera distinta a la mayoría de otros lenguajes de programación. Puede ser usado en cualquier función.
+En JavaScript, la palabra clave `this` se comporta de manera distinta a la mayoría de otros lenguajes de programación. Puede ser usado en cualquier función, incluso si no es el método de un objeto.
 
 No hay error de sintaxis en el siguiente ejemplo:
 

1-js/04-object-basics/07-optional-chaining/article.md

@@ -35,7 +35,7 @@ Por ejemplo:
 ```js run
 let user = {}; // El usuario no tiene dirección
 
-alert( user && user.address && user.address.street ); // undefined (no error)
+alert( user.address && user.address.street && user.address.street.name ); // undefined (no error)
 ```
 
 Poniendo AND en el camino completo a la propiedad asegura que todos los componentes existen (si no, la evaluación se detiene), pero es engorroso de escribir.
@@ -113,17 +113,20 @@ Por ejemplo, `?.()` Se usa para llamar a una función que puede no existir.
 En el siguiente código, algunos de nuestros usuarios tienen el método `admin`, y otros no:
 
 ```js run
-let user1 = {
+let userAdmin = {
   admin() {
     alert("I am admin");
   }
-}
+};
+
+let userGuest = {};
 
-let user2 = {};
+*!*
+userAdmin.admin?.(); // I am admin
+*/!*
 
 *!*
-user1.admin?.(); // I am admin
-user2.admin?.();
+userGuest.admin?.(); // nothing (no such method)
 */!*
 ```
 

1-js/05-data-types/03-string/article.md

@@ -110,7 +110,7 @@ alert('Yo soy \'Walrus\''); // Yo soy 'Walrus'
 
 Como puedes ver, debimos anteponer un caracter de escape `\` antes de cada comilla ya que de otra manera hubiera indicado el final del string.
 
-Obviamente, eso se refiere sólo a las comillas que son iguales a las que están rodeando al string. Por lo que, una solución más elegante sería cambiar a comillas dobles o backticks:
+Obviamente, eso se refiere sólo a las comillas que son iguales a las que están rodeando al string. Una solución más elegante sería cambiar a comillas dobles o backticks:
 
 ```js run
 alert(`Yo soy "Walrus"`); // Yo soy "Walrus"

1-js/05-data-types/05-array-methods/2-filter-range/task.md

@@ -4,7 +4,7 @@ importance: 4
 
 # Filtrar un rango
 
-Escribe una función `filterRange(arr, a, b)` que obtenga un array `arr`, busque los elementos entre `a` y `b` y devuelva un array con los resultados. 
+Escribe una función `filterRange(arr, a, b)` que obtenga un array `arr`, busque los elementos con valor mayor o igual a `a` y menor o igual a `b` y devuelva un array con los resultados. 
 
 La función no debe modificar el array. Debe devolver un nuevo array.
 

1-js/05-data-types/05-array-methods/8-sort-objects/solution.md

@@ -1,6 +1,6 @@
 ```js run no-beautify
 function sortByAge(arr) {
-  arr.sort((a, b) => a.age > b.age ? 1 : -1);
+  arr.sort((a, b) => a.age - b.age);
 }
 
 let john = { name: "John", age: 25 };

1-js/05-data-types/05-array-methods/article.md

@@ -419,13 +419,14 @@ Ahora sí funciona como esperábamos.
 
 Demos un paso al costado un momento y pensemos que es lo que está pasando. El array `arr` puede ser un array de cualquier cosa, ¿no? Puede contener números, strings, objetos o lo que sea. Podemos decir que tenemos un conjunto de *ciertos items*. Para ordenarlos, necesitamos una *función de orden* que sepa cómo comparar los elementos. El orden por defecto es hacerlo como strings.
 
-El método `arr.sort(fn)` implementa un algorito genérico de orden. No necesitamos preocuparnos de cómo funciona internamente (la mayoría de las veces es una forma optimizada del algoritmo [quicksort](https://es.wikipedia.org/wiki/Quicksort)). Este método va a recorrer el array, comparar sus elementos usando la función dada y, finalmente, reordenarlos. Todo los que necesitamos hacer es proveer la `fn` que realiza la comparación.
+El método `arr.sort(fn)` implementa un algorito genérico de orden. No necesitamos preocuparnos de cómo funciona internamente (la mayoría de las veces es una forma optimizada del algoritmo [quicksort](https://es.wikipedia.org/wiki/Quicksort) o [Timsort](https://en.wikipedia.org/wiki/Timsort)). Este método va a recorrer el array, comparar sus elementos usando la función dada y, finalmente, reordenarlos. Todo los que necesitamos hacer es proveer la `fn` que realiza la comparación.
 
 Por cierto, si alguna vez queremos saber qué elementos son comparados -- nada nos impide ejecutar alert() en ellos:
 
 ```js run
 [1, -2, 15, 2, 0, 8].sort(function(a, b) {
   alert( a + " <> " + b );
+  return a - b;
 });
 ```
 
@@ -700,7 +701,7 @@ alert(soldiers[1].age); // 23
 
 Si en el ejemplo anterior usamos `users.filter(army.canJoin)`, entonces `army.canJoin` puede ser llamada como una función independiente, con `this=undefined`, lo que puede llevar a un error instantáneo.
 
-La llamada a `users.filter(army.canJoin, army)` puede ser reemplazada con `users.filter(user => army.canJoin(user))` que realiza lo mismo. La forma anterior se usa más a menudo, ya que es un poco más fácil de entender.
+La llamada a `users.filter(army.canJoin, army)` puede ser reemplazada con `users.filter(user => army.canJoin(user))` que realiza lo mismo. Esta última se usa más a menudo ya que es un poco más fácil de entender.
 
 ## Resumen
 
@@ -729,7 +730,7 @@ Veamos el ayudamemoria de métodos para arrays:
   - `sort(func)` -- ordena el array y lo devuelve.
   - `reverse()` -- ordena el array de forma inversa y lo devuelve.
   - `split/join` -- convierte una cadena en un array y viceversa.
-  - `reduce(func, initial)` -- calcula un solo valor para todo el array llamando a la `func` para cada elemento y pasando un resultado intermedio entre cada llamada.
+  - `reduce/reduceRight(func, initial)` -- calcula un solo valor para todo el array llamando a la `func` para cada elemento y pasando un resultado intermedio entre cada llamada.
 
 - Adicional:
   - `Array.isArray(arr)` comprueba que `arr` sea un array.
@@ -741,6 +742,8 @@ Estos métodos son los más utilizados y cubren el 99% de los casos. Pero existe
 - [arr.some(fn)](mdn:js/Array/some)/[arr.every(fn)](mdn:js/Array/every) comprueba el array.
 
   La función `fn` es llamada para cada elemento del array de manera similar a `map`. Si alguno/todos los  resultados son `true`, devuelve `true`, si no, `false`.
+
+  Estos métodos se comportan con similitud a los operadores `||` y `&&`: si `fn` devuelve un valor verdadero, `arr.some()` devuelve `true` y detiene la iteración de inmediato; si `fn`  devuelve un valor falso, `arr.every()` devuelve `false` y detiene la iteración también.
 
 Podemos usar `every` para comparar arrays:
   ```js run
@@ -755,6 +758,8 @@ Podemos usar `every` para comparar arrays:
 
 - [arr.copyWithin(target, start, end)](mdn:js/Array/copyWithin) -- copia sus elementos desde la posición `start` hasta la posición `end` en *si mismo*, a la posición `target` (reescribe lo existente).
 
+- [arr.flat(depth)](mdn:js/Array/flat)/[arr.flatMap(fn)](mdn:js/Array/flatMap) crea un nuevo array plano desde un array multidimensional .
+
 Para la lista completa, ver [manual](mdn:js/Array).
 
 A primera vista puede parecer que hay demasiados métodos para aprender y un tanto difíciles de recordar. Pero con el tiempo se vuelve más fácil.

1-js/05-data-types/08-weakmap-weakset/article.md

@@ -1,7 +1,6 @@
 # WeakMap y WeakSet
 
-
-Como sabemos por el capítulo  <info:garbage-collection>, el motor de JavaScript almacena un valor en la memoria mientras es accesible(y puede ser potencialmente usado).
+Como sabemos por el capítulo  <info:garbage-collection>, el motor de JavaScript almacena un valor en la memoria mientras es accesible (y puede ser potencialmente usado).
 
 Por ejemplo:
 ```js
@@ -31,7 +30,8 @@ let array = [ john ];
 john = null; // sobrescribe la referencia
 
 *!*
-// John se almacena dentro del array, por lo que no será recolectado por el recolector de basura
+// El objeto referenciado por John se almacena dentro del array, 
+// por lo que no será recolectado por el recolector de basura
 // Lo podemos obtener como array[0]
 */!*
 ```

1-js/06-advanced-functions/04-var/article.md

@@ -82,7 +82,7 @@ function sayHi() {
 }
 
 sayHi();
-alert(phrase); // Error: phrase no está definida (Revise consola de desarrollador)
+alert(phrase); // Error: phrase no está definida
 ```
 
 Como podemos ver, `var` atraviesa `if`, `for` u otros bloques. Esto es porque mucho tiempo atrás los bloques en JavaScript no tenían ambientes léxicos. Y `var` es un remanente de aquello.

1-js/06-advanced-functions/05-global-object/article.md

@@ -25,6 +25,8 @@ var gVar = 5;
 alert(window.gVar); // 5 (se convirtió en una propiedad del objeto global)
 ```
 
+El mismo efecto lo tienen la declaraciones de función (sentencias con la palabra clave `function` en el flujo principal del código, no las expresiones de función).
+
 ¡Por favor no te fíes de eso! Este comportamiento existe por razones de compatibilidad. Los scripts modernos hacen uso de [Módulos Javascript](info:modules) para que tales cosas no sucedan.
 
 Si usáramos `let` en su lugar, esto no sucedería:

1-js/06-advanced-functions/06-function-object/article.md

@@ -343,11 +343,11 @@ Aquí cubrimos sus propiedades:
 - `name` -- El nombre de la función. Por lo general, se toma de la definición de la función, pero si no hay ninguno, JavaScript intenta adivinarlo por el contexto (por ejemplo, una asignación).
 - `length` -- El número de argumentos en la definición de la función. Los *parámetros rest* no se cuentan.
 
-
 Si la función se declara como una Expresión de función (no en el flujo de código principal), y lleva el nombre, se llama Expresión de Función con Nombre *(Named Function Expression)*. El nombre se puede usar dentro para hacer referencia a sí mismo, para llamadas recursivas o similares.
 
 Además, las funciones pueden tener propiedades adicionales. Muchas bibliotecas de JavaScript conocidas hacen un gran uso de esta función.
 
 Crean una función "principal" y le asignan muchas otras funciones "auxiliares". Por ejemplo, la biblioteca [jQuery](https://jquery.com) crea una función llamada `$`. La biblioteca  [lodash](https://lodash.com) crea una función  `_`, y luego agrega `_.clone`, `_.keyBy` y otras propiedades (mira los [docs](https://lodash.com/docs) cuando quieras aprender más sobre ello). En realidad, lo hacen para disminuir su contaminación del espacio global, de modo que una sola biblioteca proporciona solo una variable global. Eso reduce la posibilidad de conflictos de nombres.
 
+
 Por lo tanto, una función puede hacer un trabajo útil por sí misma y también puede tener muchas otras funcionalidades en las propiedades.