Merge branch 'master' into types

Author: vplentinax

1-js/01-getting-started/1-intro/article.md

@@ -65,16 +65,14 @@ Ejemplos de tales restricciones incluyen:
 
 - JavaScript en el navegador no puede leer y escribir arbitrariamente archivos en el disco duro, copiarlos o ejecutar programas. No tiene acceso directo a funciones del Sistema operativo (OS).
 
-  Los navegadores mas modernos le permiten trabajar con archivos, pero el acceso es limitado y solo permitido si el usuario realiza ciertas acciones, como "arrastrar" un archivo a la ventana del navegador o seleccionarlo por medio de una etiqueta `<input`>.
+  Los navegadores más modernos le permiten trabajar con archivos, pero el acceso es limitado y solo permitido si el usuario realiza ciertas acciones, como "arrastrar" un archivo a la ventana del navegador o seleccionarlo por medio de una etiqueta `<input`>.
 
-  Existen maneras de interactuar con la cámara, micrófono y otros dispositivos, pero eso requiere el permiso explicito del usuario. Por lo tanto, una página habilitada para JavaScript no puede habilitar una cámara web para observar el entorno y enviar la información a la [NSA](https://es.wikipedia.org/wiki/Agencia_de_Seguridad_Nacional).
-
-- Diferentes pestañas y ventanas generalmente no se conocen entre sí. A veces si lo hacen, por ejemplo, cuando una ventana usa JavaScript para abrir otra. Pero incluso en este caso, JavaScript no puede acceder a la otra si provienen de diferentes sitios. (De diferente dominio, protocolo o puerto).
+    Existen maneras de interactuar con la cámara, micrófono y otros dispositivos, pero eso requiere el permiso explícito del usuario. Por lo tanto, una página habilitada para JavaScript no puede habilitar una cámara web para observar el entorno y enviar la información a la [NSA](https://es.wikipedia.org/wiki/Agencia_de_Seguridad_Nacional).
+- Diferentes pestañas y ventanas generalmente no se conocen entre sí. A veces si lo hacen, por ejemplo, cuando una ventana usa JavaScript para abrir otra. Pero incluso en este caso, JavaScript no puede acceder a la otra si provienen de diferentes sitios (de diferente dominio, protocolo o puerto).
 
   Esto es conocido como "política del mismo origen" ("Same Origin Policy"). Para evitar eso, ambas páginas deben contener código especial de JavaScript que permita manejar el intercambio de datos. Cubriremos esto en el tutorial.
 
-  Esta limitación es, de nuevo, para la seguridad del usuario. Una página de `http://anysite.com` la cual el usuario ha abierto no debe ser capaz de acceder a otra pestaña del navegador con la URL `http://gmail.com` y robar información de esta otra página.
-
+    Esta limitación es, de nuevo, para la seguridad del usuario. Una página de `http://anysite.com` la cual el usuario ha abierto no debe ser capaz de acceder a otra pestaña del navegador con la URL `http://gmail.com` y robar información de esta otra página.
 - JavaScript puede fácilmente comunicarse a través de la red con el servidor de donde la página actual proviene. Pero su capacidad para recibir información de otros sitios y dominios esta bloqueada. Aunque sea posible, esto requiere un acuerdo explícito (expresado en los encabezados HTTP) desde el sitio remoto. Una vez más, esto es una limitación de seguridad.
 
 ![](limitations.svg)
@@ -90,7 +88,6 @@ Existen al menos _tres_ cosas geniales sobre JavaScript:
 + Las cosas simples se hacen de manera simple.
 + Soportado por la mayoría de los navegadores y habilitado de forma predeterminada.
 ```
-
 JavaScript es la única tecnología de los navegadores que combina estas tres cosas.
 
 Eso es lo que hace a JavaScript único. Por esto es la herramienta mas extendida para crear interfaces de navegador.

1-js/02-first-steps/05-types/article.md

@@ -82,14 +82,14 @@ const bigInt = 1234567890123456789012345678901234567890n;
 Como los números `BigInt` rara vez se necesitan, no los cubrimos aquí sino que les dedicamos un capítulo separado <info: bigint>. Léelo cuando necesites números tan grandes.
 
 
+
 ```smart header="Problemas de compatibilidad"
 En este momento, `BigInt` es compatible con Firefox / Chrome / Edge / Safari, pero no con IE.
 ```
 
 Puedes revisar la [tabla de compatibilidad de BigInt en *MDN*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) para saber qué versiones de navegador tienen soporte.
 
 ## String
-
 Un string (cadena de caracteres) en JavaScript debe colocarse entre comillas.
 
 ```js
@@ -129,7 +129,6 @@ En el capítulo <info:string> trataremos más a fondo las cadenas.
 
 ```smart header="No existe el tipo *carácter*".
 En algunos idiomas, hay un tipo especial "carácter" para un solo carácter. Por ejemplo, en el lenguaje C y en Java es `char`.
-
 En JavaScript no existe tal tipo. Sólo hay un tipo: `string`. Un string puede estar formado por un solo carácter o por varios de ellos.
 ```
 
@@ -260,11 +259,11 @@ Hay 8 tipos básicos en JavaScript.
 
 - `number` para números de cualquier tipo: enteros o de punto flotante, los enteros están limitados por <code>±(2<sup>53</sup>-1)</code>.
 - `bigint` para números enteros de longitud arbitraria.
-- `string` para cadenas. Una cadena puede tener uno o más caracteres, no hay un tipo especial para un único carácter.
-- `boolean` para `tru`/`false`.
-- `null` para valores desconocidos: un tipo independiente que tiene un único valor `nulo`.
-- `undefined` para valores no asignados: un tipo independiente que tiene un único valor `indefinido`.
-- `object` para estructuras de datos más complejas.
+- `string` para cadenas. Una cadena puede tener cero o más caracteres, no hay un tipo especial para un único carácter.
+- `boolean` para verdadero y falso: `true`/`false`.
+- `null` para valores desconocidos -- un tipo independiente que tiene un solo valor nulo: `null`.
+- `undefined` para valores no asignados -- un tipo independiente que tiene un único valor "indefinido": `undefined`.
+- `object` para estructuras de datos complejas.
 - `symbol` para identificadores únicos.
 
 El operador `typeof` nos permite ver qué tipo está almacenado en una variable.

1-js/02-first-steps/06-alert-prompt-confirm/article.md

@@ -30,7 +30,11 @@ Muestra una ventana modal con un mensaje de texto, un campo de entrada para el v
 `default`
 : Un segundo parámetro opcional, el valor inicial del campo de entrada.
 
-El usuario puede escribir algo en el campo de entrada de solicitud y presionar OK. Luego obtenemos ese texto en el `resultado`. O pueden cancelar la entrada presionando Cancelar o presionando la tecla `: Esc`, luego obtenemos `null` como el `result`.
+```smart header="Corchetes en la sintaxis `[...]`"
+Los corchetes alrededor de `default` en la sintaxis de arriba denotan que el parámetro es opcional, no requerido.
+```
+
+El usuario puede escribir algo en el campo de entrada de solicitud y presionar OK. Luego obtenemos ese texto en el `resultado`. O pueden cancelar la entrada presionando Cancelar o presionando la tecla `: Esc` obteniendo `null` como `result`.
 
 La llamada a `prompt` retorna el texto del campo de entrada o `null` si la entrada fue cancelada.
 

1-js/02-first-steps/08-operators/4-fix-prompt/solution.md

@@ -9,7 +9,7 @@ let b = "2"; // prompt("¿Segundo número?", 2);
 alert(a + b); // 12
 ```
 
-Lo que debemos hacer es convertir las cadenas de texto a números antes `+`. Por ejemplo, utilizando `Number()` o anteponiendo `+`.
+Lo que debemos hacer es convertir las cadenas de texto a números antes de `+`. Por ejemplo, utilizando `Number()` o anteponiendo `+`.
 
 Por ejemplo, justo antes de `prompt`:
 

1-js/02-first-steps/08-operators/article.md

@@ -1,6 +1,6 @@
-# Operadores
+# Operadores básicos, matemáticas
 
-Conocemos varios operadores de la escuela. Son cosas como la suma `+`, multiplicación `*`, resta `-`, etcétera.
+Conocemos varios operadores matemáticos porque nos los enseñaron en la escuela. Son cosas como la suma `+`, multiplicación `*`, resta `-`, etcétera.
 
 En este capítulo, nos vamos a concentrar en los aspectos de los operadores que no están cubiertos en la aritmética escolar.
 
@@ -26,9 +26,55 @@ Antes de continuar, comprendamos la terminología común.
     alert( y - x ); // 2, binario negativo resta valores
     ```
 
-    Formalmente, estamos hablando de dos operadores distintos: la negación unaria (un operando: revierte el sómbolo) and la resta binaria (dos operandos: resta).
+    Formalmente, estamos hablando de dos operadores distintos: la negación unaria (un operando: revierte el símbolo) y la resta binaria (dos operandos: resta).
 
-## Concatenación de cadenas, binario +
+## Matemáticas
+
+Están soportadas las siguientes operaciones:
+
+- Suma `+`,
+- Resta `-`,
+- Multiplicación `*`,
+- División `/`,
+- Resto `%`,
+- Exponenciación `**`.
+
+Los primeros cuatro son conocidos mientras que `%` y `**` deben ser explicados más ampliamente.
+
+## Resto %
+
+El operador resto `%`, a pesar de su apariencia, no está relacionado con porcentajes.
+
+El resultado de `a % b` es el [resto](https://es.wikipedia.org/wiki/Resto) de la división entera de `a` por `b`.
+
+Por ejemplo:
+
+```js run
+alert( 5 % 2 ); // 1 es un resto de 5 dividido por 2
+alert( 8 % 3 ); // 2 es un resto de 8 dividido por 3
+```
+
+## Exponenciación **
+
+El operador de exponenciación `**` es una inclusión reciente al lenguaje.
+
+Por ejemplo:
+
+```js run
+alert( 2 ** 2 ); // 4  (2 * 2)
+alert( 2 ** 3 ); // 8  (2 * 2 * 2)
+alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)
+```
+
+Matemáticamente, la exponenciación es definida para números no enteros también, Por ejemplo la raíz cuadrada es el exponente `1/2`:
+
+```js run
+alert( 4 ** (1/2) ); // 2 (potencia de 1/2 es lo mismo que raíz cuadrada, eso es matemáticas)
+alert( 8 ** (1/3) ); // 2 (potencia de 1/3 es lo mismo que raíz cúbica)
+```
+
+
+## Concatenación de cadenas con el binario +
 
 Ahora veamos características especiales de JavaScript que van más allá de las aritméticas escolares.
 
@@ -50,16 +96,17 @@ alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
-Vieron, no importa si el primer operando es una cadena o el segundo. La regla es simple: si cualquiera de los operandos es una cadena, el otro también se convierte en una cadena.
-
-Sin embargo, tenga en cuenta que las operaciones se ejecutan de izquierda a derecha. Si hay dos números seguidos de una cadena, los números se agregarán antes de convertirlos en una cadena:
+Vieron, no importa si el primer operando es una cadena o el segundo.
 
+Aquí hay un ejemplo algo más complejo:
 
 ```js run
 alert(2 + 2 + '1' ); // "41" y no "221"
 ```
 
-Concatenación de cadena y conversión es una característica especial del operador binario suma `+`. Otros operadores aritméticos sólo funcionan con números y siempre convierten sus operandos a números.
+Aquí, los operandores trabajan uno después de otro. El primer `+` suma dos números entonces devuelve `4`, luego el siguiente `+` le agrega la cadena `1`, así que se evalúa como `4 + '1' = 41`.
+
+El binario `+` es el único operador que soporta cadenas en esa forma. Otros operadores matemáticos trabajan solamente con números y siempre convierten sus operandos a números.
 
 Por ejemplo, resta y división:
 
@@ -95,8 +142,6 @@ Realmente hace lo mismo que `Number(...)`, pero es más corto.
 
 La necesidad de convertir cadenas en números surge con mucha frecuencia. Por ejemplo, si estamos obteniendo valores de campos de formulario HTML, generalmente son cadenas. 
 
-¿Qué pasa si queremos sumarlos?
-
 El operador binario suma los agregaría como cadenas:
 
 ```js run
@@ -135,13 +180,14 @@ Los paréntesis anulan cualquier precedencia, por lo que si no estamos satisfech
 
 Hay muchos operadores en JavaScript. Cada operador tiene un número de precedencia correspondiente. El que tiene el número más grande se ejecuta primero. Si la precedencia es la misma, el orden de ejecución es de izquierda a derecha.
 
-Aquí hay un extracto de la [tabla de precedencia] (https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Operator_Precedence) (no necesita recordar esto, pero tenga en cuenta que los operadores unarios son más altos que el operador binario correspondiente):
+Aquí hay un extracto de la [tabla de precedencia](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Operator_Precedence) (no necesita recordar esto, pero tenga en cuenta que los operadores unarios son más altos que el operador binario correspondiente):
 
 | Precedencia| Nombre | Signo |
 |------------|------|------|
 | ... | ... | ... |
 | 16 | suma unaria | `+` |
 | 16 | negación unaria | `-` |
+| 16 | exponenciación | `**` |
 | 14 | multiplicación | `*` |
 | 14 | division | `/` |
 | 13 | suma | `+` |
@@ -164,24 +210,11 @@ let x = 2 * 2 + 1;
 alert( x ); // 5
 ```
 
-Es posible encadenar asignaciones:
+### Asignación = devuelve un valor
 
-```js run
-let a, b, c;
-
-*!*
-a = b = c = 2 + 2;
-*/!*
-
-alert( a ); // 4
-alert( b ); // 4
-alert( c ); // 4
-```
-
-Las asignaciones encadenadas evalúan de derecha a izquierda. Primero, se evalúa la expresión más a la derecha `2 + 2` y luego se asigna a las variables de la izquierda: `c`, `b` y `a`. Al final, todas las variables comparten un solo valor.
+El hecho de que `=` sea un operador, no un construcción "mágica" del lenguaje, tiene un implicanción interesante.
 
-````smart header="El operador asignación `\"=\"` devuelve un valor"
-Un operador siempre devuelve un valor. Eso es obvio para la mayoría de ellos, como la suma `+` o la multiplicación `*`. Pero el operador de asignación también sigue esta regla.
+La mayoría de los operadores en JavaScript devuelven un valor. Esto es obvio para `+` y `-`, pero también es cierto para `=`.
 
 La llamada `x = value` escribe el `value` en `x` *y luego lo devuelve*.
 
@@ -201,44 +234,69 @@ alert( c ); // 0
 
 En el ejemplo anterior, el resultado de la expresión `(a = b + 1)` es el valor asignado a `a` (es decir, `3`). Luego se usa para evaluaciones adicionales.
 
-Código gracioso, ¿no? Deberíamos entender cómo funciona, porque a veces lo vemos en las bibliotecas de JavaScript, pero no deberíamos escribir algo así. Tales trucos definitivamente no hacen que el código sea más claro o legible.
-````
+Código gracioso, ¿no? Deberíamos entender cómo funciona, porque a veces lo vemos en las bibliotecas de JavaScript.
 
-## Resto %
+Pero no deberíamos escribir algo así. Tales trucos definitivamente no hacen que el código sea más claro o legible.
 
-El operador resto `%`, a pesar de su apariencia, no está relacionado con porcentajes.
+### Asignaciones encadenadas
 
-El resultado de `a % b` es el resto de la división entera de `a` por `b`.
-
-Por ejemplo:
+Otra característica interesante es la habilidad para encadenar asignaciones:
 
 ```js run
-alert( 5 % 2 ); // 1 es un resto de 5 dividido por 2
-alert( 8 % 3 ); // 2 es un resto de 8 dividido por 3
-alert( 6 % 3 ); // 0 es un resto de 6 dividido por 3
+let a, b, c;
+
+*!*
+a = b = c = 2 + 2;
+*/!*
+
+alert( a ); // 4
+alert( b ); // 4
+alert( c ); // 4
 ```
 
-## Exponenciación **
+Las asignaciones encadenadas evalúan de derecha a izquierda. Primero, se evalúa la expresión más a la derecha `2 + 2` y luego se asigna a las variables de la izquierda: `c`, `b` y `a`. Al final, todas las variables comparten un solo valor.
 
-El operador de exponenciación `**` es una inclusión reciente al lenguaje.
+Una vez más, con el propósito de la legibilidad es mejor separa tal código en unas pocas líneas:
 
-Para un número natural `b`, el resultado de `a ** b` es `a` multiplicado por sí mismos `b` veces.
+```js
+c = 2 + 2;
+b = c;
+a = c;
+```
+Es más fácil de leer, especialmente cuando se hace de un vistazo.
+
+## Modificar en el lugar
+
+A menudo necesitamos aplicar un operador a una variable y guardar el nuevo resultado en esa misma variable.
 
 Por ejemplo:
 
+```js
+let n = 2;
+n = n + 5;
+n = n * 2;
+```
+
+Esta notación puede ser acortada utilizando los operadores `+=` y `*=`:
+
 ```js run
-alert( 2 ** 2 ); // 4  (2 * 2)
-alert( 2 ** 3 ); // 8  (2 * 2 * 2)
-alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)
+let n = 2;
+n += 5; // ahora n = 7 (lo mismo que n = n + 5)
+n *= 2; // ahora n = 14 (lo mismo que n = n * 2)
+
+alert( n ); // 14
 ```
 
-El operador también funciona para números no enteros.
+Los operadores cortos "modifica y asigna" existen para todos los operadores aritméticos y de nivel bit: `/=`, `-=`, etcétera.
 
-Por ejemplo:
+Tales operadores tienen la misma precedencia que la asignación normal, por lo tanto se ejecutan después de otros cálculos:
 
 ```js run
-alert( 4 ** (1/2) ); // 2 (potencia de 1/2 es lo mismo que raíz cuadrada, eso es matemáticas)
-alert( 8 ** (1/3) ); // 2 (potencia de 1/3 es lo mismo que raíz cúbica)
+let n = 2;
+
+n *= 3 + 5;
+
+alert( n ); // 16  (lado derecho evaluado primero, lo mismo que n *= 8)
 ```
 
 ## Incremento/decremento
@@ -372,40 +430,6 @@ La lista de operadores:
 
 Estos operadores se usan muy raramente. Para comprenderlos, necesitamos profundizar en la representación de números de bajo nivel y no sería óptimo hacerlo en este momento, especialmente porque no los necesitaremos pronto. Si tienes curiosidad, puedes leer el artículo [Operadores a nivel de bit](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Bitwise_Operators#Bitwise_AND) en MDN. Sería más práctico hacerlo cuando surja una necesidad real.
 
-## Modificar en el lugar
-
-A menudo necesitamos aplicar un operador a una variable y guardar el nuevo resultado en esa misma variable.
-
-Por ejemplo:
-
-```js
-let n = 2;
-n = n + 5;
-n = n * 2;
-```
-
-Esta notación puede ser acortada utilizando los operadores `+=` y `*=`:
-
-```js run
-let n = 2;
-n += 5; // ahora n = 7 (lo mismo que n = n + 5)
-n *= 2; // ahora n = 14 (lo mismo que n = n * 2)
-
-alert( n ); // 14
-```
-
-Los operadores cortos "modifica y asigna" existen para todos los operadores aritméticos y de nivel bit: `/=`, `-=`, etcétera.
-
-Tales operadores tienen la misma precedencia que la asignación normal, por lo tanto se ejecutan después de otros cálculos:
-
-```js run
-let n = 2;
-
-n *= 3 + 5;
-
-alert( n ); // 16  (lado derecho evaluado primero, lo mismo que n *= 8)
-```
-
 ## Coma
 
 El operador coma `,` es uno de los operadores más raros e inusuales. A veces, es utilizado para escribir código más corto, entonces tenemos que saberlo para poder entender qué está pasando.

1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md

@@ -17,5 +17,5 @@ Algunas de las razones:
 3. Una vez más, la comparación lexicográfica, el primer carácter de `"2"` es mayor que el primer carácter de `"1"`.
 4. Los valores `null` y `undefined` son iguales entre sí solamente.
 5. La igualdad estricta es estricta. Diferentes tipos de ambos lados conducen a false.
-6. Similar a (4).
+6. Similar a (4), `null` solamente es igual a `undefined`.
 7. Igualdad estricta de diferentes tipos.

1-js/02-first-steps/09-comparison/article.md

@@ -57,7 +57,9 @@ El algoritmo para comparar dos cadenas es simple:
 4. Repita hasta el final de cada cadena.
 5. Si ambas cadenas tienen la misma longitud, entonces son iguales. De lo contrario, la cadena más larga es mayor.
 
-En los ejemplos anteriores, la comparación `'Z' > 'A'` llega a un resultado en el primer paso, mientras que las cadenas `"Glow"` y `"Glee"` se comparan carácter por carácter:
+En los ejemplos anteriores, la comparación `'Z' > 'A'` llega a un resultado en el primer paso.
+
+La segunda comparación `"Glow"` y `"Glee"` necesitan más pasos, se comparan carácter por carácter:
 
 1. `G` es igual que `G`.
 2. `l` es igual que `l`.

1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md

@@ -4,6 +4,6 @@ importance: 3
 
 # Comprueba el rango por dentro
 
-Escribe una condición "if" para comprobar que `age`(edad) está entre `14` y `90` inclusivamente.
+Escribe una condición "if" para comprobar que `age`(edad) está entre `14` y `90` inclusive.
 
-"Inclusivamente" significa que `age` puede llegar a ser uno de los extremos, `14` o `90`.
+"Inclusive" significa que `age` puede llegar a ser uno de los extremos, `14` o `90`.