Susy210116

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

@@ -111,6 +111,7 @@ Ejemplos de tales lenguajes:
 -[FLow](https://flow.org/) también agrega la escritura de datos, pero de una manera diferente. Desarrollado por Facebook.
 - [Dart](https://www.dartlang.org/) es un lenguaje independiente que tiene su propio motor que se ejecuta en entornos que no son de navegador (como aplicaciones móviles), pero que también se puede convertir/transpilar a JavaScript. Desarrollado por Google.
 - [Brython](https://brython.info/) es un transpilador de Python a JavaScript que permite escribir aplicaciones en Python puro sin JavaScript.
+- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) es un lenguaje moderno, seguro y conciso que puede apuntar al navegador o a Node.
 
 Hay más. Por supuesto, incluso si nosotros usamos alguno de estos lenguajes, deberíamos conocer también JavaScript para realmente entender qué estamos haciendo.
 

1-js/01-getting-started/2-manuals-specifications/article.md

@@ -17,16 +17,11 @@ Si estás desarrollando para navegadores web, se mencionan otras especificacione
 
 ## Manuales
 
-- **MDN (Mozilla) JavaScript Reference** es un manual con ejemplos y otras informaciones. Es fantástico para obtener información exhaustiva sobre funciones individuales del lenguaje, métodos, etc.
+- **MDN (Mozilla) JavaScript Reference** es el manual principal, con ejemplos y otras informaciones. Es fantástico para obtener información exhaustiva sobre funciones individuales del lenguaje, métodos, etc.
 
     Se puede acceder en <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
 
-    Aunque a menudo es mejor hace una búsqueda en internet, adicionando "MDN [término]" como parte de la *query* en el motor de búsqueda, e.g. <https://google.com/search?q=MDN+parseInt> para buscar la función `parseInt`.
-
-
-- **MSDN** – Manual de Microsoft con mucha información, incluyendo JavaScript (a menudo denominado JScript). Si se necesita información específica de Internet Explorer, es el mejor lugar a consultar: <http://msdn.microsoft.com/>.
-
-    También podemos hacer una búsqueda con frases tales como "RegExp MSDN" o "RegExp MSDN jscript".
+Aunque a menudo es preferible una búsqueda en internet. Simplemente añade "MDN [término]" en la consulta, por ejemplo <https://google.com/search?q=MDN+parseInt> para buscar la función `parseInt`.
 
 ## Tablas de compatibilidad
 

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

@@ -219,7 +219,7 @@ alert( x ); // 5
 
 El hecho de que `=` sea un operador, no un construcción "mágica" del lenguaje, tiene un implicanción interesante.
 
-La mayoría de los operadores en JavaScript devuelven un valor. Esto es obvio para `+` y `-`, pero también es cierto para `=`.
+Todos 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*.
 

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -114,7 +114,7 @@ Por favor abre el desplegable de informacion de la derecha (etiquetado con flech
 
     Tambien tenemos la palabra `this` la cual no estudiaremos ahora, pero pronto lo haremos.
 
-## Tazado de la ejecución
+## Trazado de la ejecución
 
 Ahora es tiempo de *trazar* el script.
 

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

@@ -14,8 +14,8 @@ Simple, los valores "alcanzables" son aquellos que son accesibles o se pueden ut
 
     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.
+    - La función ejecutándose actualmente, sus variables locales y parámetros.
+    - Otras funciones en la cadena actual de llamadas anidadas, sus variables y parámetros.
     - Variables Globales
     - (Hay algunos otros internos también)
 

1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js

@@ -15,6 +15,11 @@ describe("calculator", function() {
     afterEach(function() {
       prompt.restore();
     });
+
+    it('the read get two values and saves them as object properties', function () {
+      assert.equal(calculator.a, 2);
+      assert.equal(calculator.b, 3);
+    });
 
     it("the sum is 5", function() {
       assert.equal(calculator.sum(), 5);

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js

@@ -10,6 +10,11 @@ describe("calculator", function() {
     calculator = new Calculator();
     calculator.read();
   });
+
+  it("the read method asks for two values using prompt and remembers them in object properties", function() {
+    assert.equal(calculator.a, 2);
+    assert.equal(calculator.b, 3);
+  });
 
   it("cuando se ingresa 2 y 3, la suma es 5", function() {
     assert.equal(calculator.sum(), 5);

1-js/04-object-basics/06-constructor-new/article.md

@@ -91,7 +91,7 @@ La sintaxis a partir de esta sección es raramente utilizada, puedes omitirla a
 
 Dentro de una función, podemos verificar si ha sido llamada con o sin el `new`, utilizando una propiedad especial `new.target`.
 
-Está vacía para llamadas normales y es equivalente a la función si es llamada con `new`:
+Es "undefined" para llamadas normales y es equivalente a la función si es llamada con `new`:
 
 ```js run
 function User() {

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

@@ -74,7 +74,7 @@ Es por ello que el encadenamiento opcional `?.` fue agregado al lenguaje. ¡Para
 
 ## Encadenamiento opcional
 
-El encadenamiento opcional `?.` detiene la evaluación si la parte anterior a `?.` es ` undefined` o `null` y devuelve esa parte. 
+El encadenamiento opcional `?.` detiene la evaluación si la parte anterior a `?.` es ` undefined` o `null` y devuelve `undefined`. 
 
 **De aquí en adelante en este artículo, por brevedad, diremos que algo "existe" si no es `null` o `undefined`.**
 
@@ -103,7 +103,7 @@ alert( user?.address.street ); // undefined
 
 Tenga en cuenta: la sintaxis `?.` hace opcional el valor delante de él, pero no más allá.
 
-Por ejemplo en `user?.address.street.name` el `?.` permite a `user` ser `null/undefined`, pero es todo lo que hace. El resto de las propiedades son accedidas de la manera normal.  Si queremos que algunas de ellas sean opcionales, necesitamos reemplazar más `.` con `?.`.
+Por ejemplo en `user?.address.street.name` el `?.` permite a `user` ser `null/undefined` (y devuelve `undefined` en tal caso), pero solo para `user`. El resto de las propiedades son accedidas de la manera normal.  Si queremos que algunas de ellas sean opcionales, necesitamos reemplazar más `.` con `?.`.
 
 ```warn header="No abuses del encadenamiento opcional"
 Deberíamos usar `?.` solo donde está bien que algo no exista.
@@ -173,18 +173,16 @@ Entonces `?.()` Comprueba la parte izquierda: si la función admin existe, enton
 La sintaxis `?.[]` también funciona si quisiéramos usar corchetes `[]` para acceder a las propiedades en lugar de punto `.`. Al igual que en casos anteriores, permite leer de forma segura una propiedad de un objeto que puede no existir.
 
 ```js run
+let key = "firstName";
+
 let user1 = {
   firstName: "John"
 };
 
-let user2 = null; // Imagine, no podríamos autorizar al usuario
-
-let key = "firstName";
+let user2 = null; 
 
 alert( user1?.[key] ); // John
 alert( user2?.[key] ); // undefined
-
-alert( user1?.[key]?.something?.not?.existing); // undefined
 ```
 
 También podemos usar `?.` con `delete`:

1-js/04-object-basics/08-symbol/article.md

@@ -107,7 +107,7 @@ No habrá conflicto porque los Symbols siempre son diferentes, incluso si tienen
 
 Ahora ten en cuenta que si utilizamos un string `"id"` en lugar de un Symbol para el mismo propósito, entonces SÍ *habría* un conflicto:
 
-```js run
+```js
 let user = { name: "John" };
 
 // Nuestro script usa la clave "id" 

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

@@ -16,21 +16,29 @@ Imagina que necesitamos escribir mil millones (En inglés "1 billion"). La forma
 let billion = 1000000000;
 ```
 
+También podemos usar guion bajo `_` como separador:
+
+```js
+let billion = 1_000_000_000;
+```
+
+Aquí `_` es "azúcar sintáctica", hace el número más legible. El motor JavaScript simplemente ignora `_` entre dígitos asi que es exactamente e igual al billion de más arriba.
+
 Pero en la vida real tratamos de evitar esribir una larga cadena de ceros porque es fácil tipear mal. 
 
 En JavaScript, acortamos un número agregando la letra `"e"` y especificando la cantidad de ceros:
 
 ```js run
 let billion = 1e9;  // 1 billion, literalmente: 1 y 9 ceros
 
-alert( 7.3e9 );  // 7.3 billions (7,300,000,000)
+alert( 7.3e9 );  // 7.3 billions (tanto 7300000000 como 7_300_000_000)
 ```
 
 En otras palabras, `"e"` multiplica el número por el `1` seguido de la cantidad de ceros dada.
 
 ```js
-1e3 = 1 * 1000
-1.23e6 = 1.23 * 1000000
+1e3 = 1 * 1000 // e3 significa *1000
+1.23e6 = 1.23 * 1000000 // e6 significa *1000000
 ```
 
 Ahora escribamos algo muy pequeño. Digamos 1 microsegundo (un millonésimo de segundo):
@@ -125,7 +133,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` torna en `3`, `3.6` torna en `4` y `-1.1` torna en `-1`.
+: 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.
 
 `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`.

1-js/05-data-types/06-iterable/article.md

@@ -115,6 +115,7 @@ No hay limitaciones en `next`, puede devolver más y más valores, eso es normal
 Por supuesto, el bucle `for..of` sobre un iterable de este tipo sería interminable. Pero siempre podemos detenerlo usando `break`.
 ```
 
+
 ## *String* es iterable
 
 Las matrices y cadenas son los iterables integrados más utilizados.
@@ -164,7 +165,7 @@ Rara vez se necesita esto, pero nos da más control sobre el proceso que `for..o
 
 ## Iterables y array-likes [#array-like]
 
-Hay dos términos oficiales que se parecen, pero son muy diferentes. Asegúrese de comprenderlos bien para evitar confusiones.
+Los dos son términos oficiales que se parecen, pero son muy diferentes. Asegúrese de comprenderlos bien para evitar confusiones.
 
 - *Iterables* son objetos que implementan el método `Symbol.iterator`, como se describió anteriormente.
 - *Array-likes* son objetos que tienen índices y `longitud` o *length*, por lo que se ven como matrices.
@@ -173,11 +174,9 @@ Cuando usamos JavaScript para tareas prácticas en el navegador u otros entornos
 
 Por ejemplo, las cadenas son iterables (`for..of` funciona en ellas) y array-like (tienen índices numéricos y `length`).
 
-Pero un iterable puede no ser array-like. Y viceversa, un array-like puede no ser iterable.
-
-
-Por ejemplo, `range` en el ejemplo anterior es iterable, pero no array-like, porque no tiene propiedades indexadas ni `longitud` o *length*.
+Pero un iterable puede que no sea array-like. Y viceversa, un array-like puede no ser iterable.
 
+Por ejemplo, `range` en el ejemplo anterior es iterable, pero no es array-like, porque no tiene propiedades indexadas ni `longitud` o *length*.
 
 Y aquí está el objeto que tiene forma de matriz, pero no es iterable: