Susy primavera super sync

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

@@ -81,10 +81,13 @@ 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éalo cuando necesite números tan grandes.
 
+
 ```smart header="Problemas de compatibilidad"
-En este momento, `BigInt` es compatible con Firefox / Chrome / Edge, pero no con Safari / IE.
+En este momento, `BigInt` es compatible con Firefox/Chrome/Edge/Safari pero no con IE.
 ```
 
+Puedes revissar la [tabla de compatibilidad BigInt de *MDN*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) para conocer las versiones de navegadores soportadas.
+
 ## Un string
 
 Un string (cadena de caracteres) en JavaScript debe estar encerrado entre comillas.
@@ -127,7 +130,7 @@ En el capítulo <info:string> trataremos más a fondo las cadenas.
 ```smart header="No existe el tipo *carácter*".
 En algunos lenguajes, 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`. Una cadena puede estar formada por un solo carácter o por varios de ellos.
+En JavaScript no existe tal tipo. Sólo hay un tipo: `string`. Una cadena puede estar formada por cero caracteres (estar vacía), un carácter o por varios de ellos.
 ```
 
 ## Un boolean (tipo lógico)
@@ -257,7 +260,7 @@ Hay 8 tipos básicos en JavaScript.
 
 - `number` para números de cualquier tipo: enteros o en punto flotante. Los enteros están limitados a ±2<sup>53</sup>.
 - `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.
+- `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`.

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`.

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

@@ -4,6 +4,6 @@ importance: 3
 
 # Comprueba el rango por fuera
 
-Escribe una condición `if` para comprobar que `age` NO está entre 14 y 90 inclusivemente.
+Escribe una condición `if` para comprobar que `age` NO está entre 14 y 90 inclusive.
 
-Crea dos variantes: la primera usando NOT `!`, y la segunda -- sin usarlo.
+Crea dos variantes: la primera usando NOT `!`, y la segunda sin usarlo.

1-js/02-first-steps/11-logical-operators/9-check-login/solution.md

@@ -7,15 +7,15 @@ if (userName == "Admin") {
 
     let pass = prompt("¿Contraseña?", "");
 
-    if (pass == "TheMaster") {
+    if (pass === "TheMaster") {
 	alert( "Bienvenido!" );
-    } else if (pass == "" || pass == null) {
+    } else if (pass === "" || pass === null) {
 	alert( "Cancelado." );
     } else {
 	alert( "Contraseña incorrecta" );
     }
 
-} else if (userName == "" || userName == null) {
+} else if (userName === "" || userName === null) {
     alert( "Canceledo" );
 } else {
     alert( "No te conozco" );