Merge enstream 241104

Author: joaquinelio

Diff for: .github/FUNDING.yml

@@ -0,0 +1 @@
+github: iliakan

Diff for: 1-js/02-first-steps/04-variables/article.md

@@ -1,6 +1,6 @@
 # Variables
 
-La mayoría del tiempo, una aplicación de JavaScript necesita trabajar con información. Aquí hay 2 ejemplos:
+La mayor parte del tiempo, una aplicación JavaScript necesita trabajar con información. Dos ejemplos:
 1. Una tienda en línea -- La información puede incluir los bienes a la venta y un "carrito de compras".
 2. Una aplicación de chat -- La información puede incluir los usuarios, mensajes, y mucho más.
 
@@ -18,7 +18,7 @@ La siguiente declaración genera (en otras palabras: *declara* o *define*) una v
 let message;
 ```
 
-Ahora podemos introducir datos en ella al utilizar el operador de asignación `=`:
+Ahora podemos introducir datos en ella, utilizando el operador de asignación `=`:
 
 ```js
 let message;
@@ -47,7 +47,7 @@ let message = 'Hola!'; // define la variable y asigna un valor
 alert(message); // Hola!
 ```
 
-También podemos declarar variables múltiples en una sola línea:
+También podemos declarar múltiples variables en una sola línea:
 
 ```js no-beautify
 let user = 'John', age = 25, message = 'Hola';
@@ -63,15 +63,15 @@ let age = 25;
 let message = 'Hola';
 ```
 
-Algunas personas también definen variables múltiples en estilo multilínea:
+Hay quienes prefieren definir múltiples variables en estilo multilínea:
 
 ```js no-beautify
 let user = 'John',
   age = 25,
   message = 'Hola';
 ```
 
-...Incluso en este estilo "coma primero":
+... o con el estilo "coma primero":
 
 ```js no-beautify
 let user = 'John'
@@ -97,7 +97,7 @@ Existen sutiles diferencias entre `let` y `var`, pero no nos interesan en este m
 
 Podemos comprender fácilmente el concepto de una "variable" si nos la imaginamos como una "caja" con una etiqueta de nombre único pegada en ella.
 
-Por ejemplo, podemos imaginar la variable `message` como una caja etiquetada `"message"` con el valor `"Hola!"` adentro:
+Por ejemplo, la variable `message` puede ser imaginada como una caja etiquetada `"message"` con el valor `"Hola!"` dentro:
 
 ![](variable.svg)
 
@@ -205,7 +205,7 @@ let имя = '...';
 let 我 = '...';
 ```
 
-Técnicamente, no existe ningún error aquí. Tales nombres están permitidos, pero existe una tradición internacional de utilizar inglés en el nombramiento de variables. Incluso si estamos escribiendo un script pequeño, este puede tener una larga vida por delante. Puede ser necesario que gente de otros países deba leerlo en algún momento.
+Técnicamente, no existe error aquí. Tales nombres están permitidos, pero internacionalmente existe la convención de utilizar el inglés en el nombramiento de variables. Incluso si estamos escribiendo un script pequeño, este puede tener una larga vida por delante. Gente de otros países pueden necesitar leerlo en algún momento.
 ````
 
 ````warn header="Nombres reservados"
@@ -260,7 +260,7 @@ const myBirthday = '18.04.1982';
 myBirthday = '01.01.2001'; // ¡error, no se puede reasignar la constante!
 ```
 
-Cuando un programador está seguro de que una variable nunca cambiará, puede declarar la variable con `const` para garantizar y comunicar claramente este hecho a todos.
+Cuando un programador está seguro de que una variable nunca cambiará, puede declararla con `const` para garantizar esto y comunicarlo claramente a los demás.
 
 ### Constantes mayúsculas
 
@@ -297,9 +297,9 @@ Por ejemplo:
 const pageLoadTime = /* el tiempo que tardó la página web para cargar */;
 ```
 
-El valor de `pageLoadTime` no se conoce antes de cargar la página, así que la nombramos normalmente. No obstante, es una constante porque no cambia después de su asignación inicial.
+El valor de `pageLoadTime` no está preestablecido. Como no se conoce antes de cargar la página, la nombramos normalmente. Pero podemos declararla como constante, porque después de su asignación inicial, no cambiará.
 
-En otras palabras, las constantes con nombres en mayúscula son utilizadas solamente como alias para valores invariables y preestablecidos ("hard-coded").
+En otras palabras, las constantes en mayúsculas son utilizadas solamente como alias para valores invariables y preestablecidos (o "hard-coded").
 
 ## Nombrar cosas correctamente
 
@@ -309,16 +309,16 @@ Una variable debe tener un nombre claro, de significado evidente, que describa e
 
 Nombrar variables es una de las habilidades más importantes y complejas en la programación. Un vistazo rápido a el nombre de las variables nos revela cuál código fue escrito por un principiante o por un desarrollador experimentado.
 
-En un proyecto real, la mayor parte de el tiempo se pasa modificando y extendiendo una base de código en vez de empezar a escribir algo desde cero. Cuando regresamos a algún código después de hacer algo distinto por un rato, es mucho más fácil encontrar información que está bien etiquetada. O, en otras palabras, cuando las variables tienen nombres adecuados.
+En un proyecto real, se pasa mucho más tiempo modificando y extendiendo una base de código existente que escribiendo algo nuevo desde cero. Cuando regresamos a nuestro código luego de un tiempo, es mucho más fácil encontrar información que está bien etiquetada. O en otras palabras, cuando las variables tienen los nombres adecuados.
 
-Por favor pasa tiempo pensando en el nombre adecuado para una variable antes de declararla. Hacer esto te da un retorno muy sustancial.
+Por favor, dedica tiempo para pensar un nombre correcto para una variable antes de declararla. Hacer esto te rendirá muy bien.
 
 Algunas reglas buenas para seguir:
 
-- Use términos legibles para humanos como `userName` p `shoppingCart`.
-- Evite abreviaciones o nombres cortos `a`, `b`, `c`, al menos que en serio sepa lo que está haciendo.
-- Cree nombres que describen al máximo lo que son y sean concisos. Ejemplos que no son adecuados son `data` y `value`. Estos nombres no nos dicen nada. Estos solo está bien usarlos en el contexto de un código que deje excepcionalmente obvio cuál valor o cuales datos está referenciando la variable.
-- Acuerda en tu propia mente y con tu equipo cuáles términos se utilizarán. Si a un visitante se le llamara "user", debemos llamar las variables relacionadas `currentUser` o `newUser` en vez de `currentVisitor` o `newManInTown`.
+- Usa términos legibles para humanos como `userName` p `shoppingCart`.
+- Evita abreviaciones o nombres cortos `a`, `b`, `c`, a menos que realmente sepas lo que estás haciendo.
+- Crea nombres que describan al máximo lo que son y sean concisos. Ejemplos de nombres malos son `data` y `value`. Estos nombres no nos dicen nada, solo son adecuados en el contexto de un código que deje excepcionalmente obvio cuál dato o valor está referenciando la variable.
+- Ponte de acuerdo con tu equipo, y con tu propia mente, cuáles términos se utilizarán. Si a un visitante se lo llamara "user", debemos llamar las variables relacionadas `currentUser` o `newUser` en vez de `currentVisitor` o `newManInTown`.
 
 ¿Suena simple? De hecho lo es, pero no es tan fácil crear nombres de variables descriptivos y concisos a la hora de practicar. Inténtelo.
 
@@ -329,9 +329,9 @@ El resultado de esto es que sus variables son como cajas en las cuales la gente
 
 Dichos programadores se ahorran un poco durante la declaración de la variable, pero pierden diez veces más a la hora de depuración.
 
-Una variable extra es algo bueno, no algo malvado.
+Una variable extra es algo bueno, no algo diabólico.
 
-Los minificadores de JavaScript moderno, y los navegadores optimizan el código suficientemente bien para no generar cuestiones de rendimiento. Utilizar diferentes variables para distintos valores incluso puede ayudar a optimizar su código
+Los navegadores modernos y los minificadores de JavaScript optimizan el código, así que esto no impacta en el rendimiento. Utilizar diferentes variables para distintos valores incluso puede ayudar a optimizar tu código.
 ```
 
 ## Resumen
@@ -340,6 +340,6 @@ Podemos declarar variables para almacenar datos al utilizar las palabra clave `v
 
 - `let` -- es la forma moderna de declaración de una variable.
 - `var` -- es la declaración de variable de vieja escuela. Normalmente no lo utilizamos en absoluto. Cubriremos sus sutiles diferencias con `let` en el capítulo <info:var>, por si lo necesitaras.
-- `const` -- es como `let`, pero el valor de la variable no puede ser alterado.
+- `const` -- es como `let`, pero una vez asignado, el valor de la variable no podrá alterarse.
 
 Las variables deben ser nombradas de tal manera que entendamos fácilmente lo que está en su interior.

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

@@ -7,7 +7,7 @@ Los equipos de desarrollo detrás de los intérpretes (engines) de JavaScript ti
 
 Por lo tanto, es bastante común para un intérprete implementar solo parte del estándar.
 
-Una buena página para ver el estado actual de soporte de características del lenguaje es <https://kangax.github.io/compat-table/es6/> (es grande, todavía tenemos mucho que aprender).
+Una buena página para ver el estado actual de soporte de características del lenguaje es <https://compat-table.github.io/compat-table/es6/> (es grande, todavía tenemos mucho que aprender).
 
 Como programadores, queremos las características más recientes. Cuanto más, ¡mejor!
 
@@ -72,7 +72,8 @@ if (!Math.trunc) { // no existe tal función
 JavaScript es un lenguaje muy dinámico, los scripts pueden agregar o modificar cualquier función, incluso las integradas. 
 
 Una librería interesante de polyfills es:
-- [core js](https://github.com/zloirock/core-js) - da muchísimo soporte, pero sin sobrecargar, ya que permite incluir solo las características necesarias.
+- [core js](https://github.com/zloirock/core-js) - brinda muchísimo soporte, pero permite incluir solo las características necesarias.
+
 
 ## Resumen
 
@@ -83,7 +84,7 @@ Pero no olvides usar transpiladores (si usas sintaxis u operadores modernos) y p
 Por ejemplo, cuando estés más familiarizado con JavaScript puedes configurar la construcción de código basado en [webpack](https://webpack.js.org/) con el plugin [babel-loader](https://github.com/babel/babel-loader).
 
 Buenos recursos que muestran el estado actual de soporte para varias característica:
-- <https://kangax.github.io/compat-table/es6/> - para JavaScript puro.
+- <https://compat-table.github.io/compat-table/es6/> - para JavaScript puro.
 - <https://caniuse.com/> - para funciones relacionadas al navegador.
 
 P.S. Google Chrome usualmente es el más actualizado con las características del lenguaje, pruébalo si algún demo del tutorial falla. Aunque la mayoría de los demos funciona con cualquier navegador moderno.

Diff for: 1-js/04-object-basics/04-object-methods/8-chain-calls/task.md

@@ -21,7 +21,7 @@ let ladder = {
 };
 ```
 
-Ahora, si necesitamos hacer varios llamados en secuencia podemos hacer algo como esto:
+Si ahora necesitamos hacer varios llamados en secuencia, podemos hacer algo como esto:
 
 ```js
 ladder.up();
@@ -32,10 +32,10 @@ ladder.down();
 ladder.showStep(); // 0
 ```
 
-Modifica el código de "arriba" `up`, "abajo" `down` y "mostrar peldaño" `showStep` para hacer los llamados encadenables como esto:
+Modifica el código de "arriba" `up`, "abajo" `down` y "mostrar peldaño" `showStep` para hacer los llamados encadenables. Así:
 
 ```js
-ladder.up().up().down().showStep().down().showStep(); // shows 1 then 0
+ladder.up().up().down().showStep().down().showStep(); // muestra 1 luego 0
 ```
 
-Tal enfoque es ampliamente usado entre las librerías JavaScript.
+Tal enfoque es ampliamente usado en librerías JavaScript.

Diff for: 1-js/05-data-types/02-number/article.md

@@ -4,7 +4,7 @@ En JavaScript moderno, hay dos tipos de números:
 
 1. Los números regulares en JavaScript son almacenados con el formato de 64-bit [IEEE-754](https://es.wikipedia.org/wiki/IEEE_754), conocido como "números de doble precisión de coma flotante". Estos números son los que estaremos usando la mayor parte del tiempo, y hablaremos de ellos en este capítulo.
 
-2. Los números BigInt representan enteros de longitud arbitraria. A veces son necesarios porque un número regular no puede exceder <code>2<sup>53</sup></code> ni ser menor a <code>-2<sup>53</sup></code> manteniendo la precisión, algo que mencionamos antes en el capítulo <info:types>. Como los bigints son usados en algunas áreas especiales, les dedicamos un capítulo especial <info:bigint>.
+2. Los números BigInt representan enteros de longitud arbitraria. A veces son necesarios porque un número entero regular no puede exceder <code>2<sup>53</sup></code> ni ser menor a <code>-2<sup>53</sup></code> manteniendo la precisión, algo que mencionamos antes en el capítulo <info:types>. Como los bigints son usados en áreas muy especiales, les dedicamos un capítulo especial <info:bigint>.
 
 Aquí hablaremos de números regulares. Ampliemos lo que ya sabemos de ellos.
 
@@ -107,9 +107,9 @@ La `base` puede variar entre `2` y `36`. La predeterminada es `10`.
 
 Casos de uso común son:
 
-- **base=16** usada para colores hex, codificación de caracteres, etc; los dígitos pueden ser `0..9` o `A..F`.
-- **base=2** mayormente usada para el debug de operaciones de bit, los dígitos pueden ser `0` o `1`.
-- **base=36** Es el máximo, los dígitos pueden ser `0..9` o `A..Z`.  Aquí el alfabeto inglés completo es usado para representar un número.  Un uso peculiar pero práctico para la base `36` es cuando necesitamos convertir un largo identificador numérico en algo más corto, por ejemplo para abreviar una url. Podemos simplemente representarlo en el sistema numeral de base `36`:
+- **base=16** usada para colores en hexa, codificación de caracteres, etc.; los dígitos pueden ser `0..9` o `A..F`.
+- **base=2** mayormente usada para la depuración de operaciones de bit, los dígitos pueden ser `0` o `1`.
+- **base=36** Es la base máxima, los dígitos pueden ser `0..9` o `A..Z`.  Aquí el alfabeto inglés completo es usado para representar un número. Un uso peculiar pero práctico para la base `36` es cuando necesitamos convertir un largo identificador numérico en algo más corto, por ejemplo para abreviar una url. Podemos simplemente representarlo en el sistema numeral de base `36`:
 
     ```js run
     alert( 123456..toString(36) ); // 2n9c
@@ -137,7 +137,7 @@ Hay varias funciones incorporadas para el redondeo:
 : Redondea hacia arriba: `3.1` torna en `4`, y `-1.1` torna en `-1`.
 
 `Math.round`
-: Redondea hacia el entero más cercano: `3.1` redondea a `3`, `3.6` redondea a `4`, el caso medio `3.5` redondea a `4` también.
+: Redondea hacia el entero más cercano: `3.1` redondea a `3`, `3.6` redondea a `4`; los casos medios `3.5` redondea a `4`, y `-3.5` redondea a `-3`.
 
 `Math.trunc` (no soportado en Internet Explorer)
 : Remueve lo que haya tras el punto decimal sin redondear: `3.1` torna en `3`, `-1.1` torna en `-1`.
@@ -147,8 +147,10 @@ Aquí, la tabla que resume las diferencias entre ellos:
 |   | `Math.floor` | `Math.ceil` | `Math.round` | `Math.trunc` |
 |---|---------|--------|---------|---------|
 |`3.1`|  `3`    |   `4`  |    `3`  |   `3`   |
+|`3.5`|  `3`    |   `4`  |    `4`  |   `3`   |
 |`3.6`|  `3`    |   `4`  |    `4`  |   `3`   |
 |`-1.1`|  `-2`    |   `-1`  |    `-1`  |   `-1`   |
+|`-1.5`|  `-2`    |   `-1`  |    `-1`  |   `-1`   |
 |`-1.6`|  `-2`    |   `-1`  |    `-2`  |   `-1`   |
 
 
@@ -188,7 +190,7 @@ Hay dos formas de hacerlo:
     alert( num.toFixed(5) ); // "12.34000", con ceros agregados para dar exactamente 5 dígitos
     ```
 
-    Podemos convertirlo a "number" usando el operador unario más o llamando a `Number()`; por ejemplo, escribir `+num.toFixed(5)`.
+    Podemos convertirlo a `number` usando el operador unario más `+` o llamando a `Number()`. Por ejemplo, `+num.toFixed(5)`.
 
 ## Cálculo impreciso
 
@@ -222,7 +224,13 @@ alert( 0.1 + 0.2 ); // 0.30000000000000004
 
 Un número es almacenado en memoria en su forma binaria, una secuencia de bits, unos y ceros. Pero decimales como `0.1`, `0.2` que se ven simples en el sistema decimal son realmente fracciones sin fin en su forma binaria.
 
-¿Qué es `0.1`? Es un uno dividido por 10 `1/10`, un décimo. En sistema decimal es fácilmente representable. Compáralo con un tercio: `1/3`, se vuelve una fracción sin fin `0.33333(3)`.
+```js run
+alert(0.1.toString(2)); // 0.0001100110011001100110011001100110011001100110011001101
+alert(0.2.toString(2)); // 0.001100110011001100110011001100110011001100110011001101
+alert((0.1 + 0.2).toString(2)); // 0.0100110011001100110011001100110011001100110011001101
+```
+
+¿Qué es `0.1`? Es un uno dividido por 10, `1/10`, un décimo. En sistema decimal es fácilmente representable. Compáralo con un tercio: `1/3`, que se vuelve una fracción sin fin `0.33333(3)`.
 
 Así, la división en potencias de diez garantizan un buen funcionamiento en el sistema decimal, pero divisiones por `3` no.  Por la misma razón, en el sistema binario la división en potencias de `2` garantizan su funcionamiento, pero `1/10` se vuelve una fracción binaria sin fin.
 
@@ -235,14 +243,14 @@ Podemos verlo en acción:
 alert( 0.1.toFixed(20) ); // 0.10000000000000000555
 ```
 
-Y cuando sumamos dos números, se apilan sus "pérdidas de precisión".
+Y cuando sumamos dos números, sus "pérdidas de precisión" se acumulan.
 
 Y es por ello que `0.1 + 0.2` no es exactamente `0.3`.
 
 ```smart header="No solo JavaScript"
 El mismo problema existe en muchos otros lenguajes de programación.
 
-PHP, Java, C, Perl, Ruby dan exactamente el mismo resultado, porque ellos están basados en el mismo formato numérico.
+PHP, Java, C, Perl, Ruby, dan exactamente el mismo resultado, porque ellos están basados en el mismo formato numérico.
 ```
 
 ¿Podemos resolver el problema? Seguro, la forma más confiable es redondear el resultado con la ayuda de un método. [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed):
@@ -348,7 +356,7 @@ Los métodos [Number.isNaN](https://developer.mozilla.org/es/docs/Web/JavaScript
     alert( isNaN("str") ); // true, porque isNaN convierte el string "str" a number y obtiene NaN como resultado de su conversión
     ```
 
-- `Number.isFinite(value)` devuelve `true` si el argumento pertenece al tipo de dato `number` y no es  `NaN/Infinity/-Infinity`. En cualquier otro caso devuelve `false`.
+- `Number.isFinite(value)` devuelve `true` si el argumento pertenece al tipo de dato `number` y no es `NaN/Infinity/-Infinity`. En cualquier otro caso devuelve `false`.
 
     ```js run
     alert( Number.isFinite(123) ); // true

Diff for: 1-js/05-data-types/04-array/article.md

@@ -426,7 +426,7 @@ let matrix = [
   [7, 8, 9]
 ];
 
-alert( matrix[1][1] ); // 5, el elemento central
+alert( matrix[0][1] ); // 2, el segundo valor del primer array interno
 ```
 
 ## toString