Merge pull request #637 from joaquinelio/susy220627

Susy220627

Author: joaquinelio

Diff for: 1-js/01-getting-started/3-code-editors/article.md

@@ -17,7 +17,7 @@ Si aún no has seleccionado un IDE, considera las siguientes opciones:
 
 Para Windows, también está "Visual Studio", no lo confundamos con "Visual Studio Code". "Visual Studio" es un poderoso editor pagado sólo para Windows, idóneo para la plataforma .NET. Una versión gratuita es de este editor se llama [Visual Studio Community](https://www.visualstudio.com/vs/community/).
 
-Muchos IDEs son de paga pero tienen un periodo de prueba. Su costo usualmente es pequeño si lo comparamos al salario de un desarrollador calificado, así que sólo escoge el mejor para ti.
+Muchos IDEs son de paga, pero tienen un periodo de prueba. Su costo usualmente es pequeño si lo comparamos al salario de un desarrollador calificado, así que sólo escoge el mejor para ti.
 
 ## Editores livianos
 

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

@@ -180,7 +180,7 @@ El valor especial `undefined` también se distingue. Hace un tipo propio, igual
 
 El significado de `undefined` es "valor no asignado".
 
-Si una variable es declarada pero no asignada, entonces su valor es `undefined`:
+Si una variable es declarada, pero no asignada, entonces su valor es `undefined`:
 
 ```js run
 let age;
@@ -247,7 +247,7 @@ Las últimas tres líneas pueden necesitar una explicación adicional:
 
 1. `Math` es un objeto incorporado que proporciona operaciones matemáticas. Lo aprenderemos en el capítulo <info:number>. Aquí sólo sirve como ejemplo de un objeto.
 2. El resultado de `typeof null` es `"object"`. Esto está oficialmente reconocido como un error de comportamiento de `typeof` que proviene de los primeros días de JavaScript y se mantiene por compatibilidad. Definitivamente `null` no es un objeto. Es un valor especial con un tipo propio separado.
-3. El resultado de `typeof alert` es `"function"` porque `alert` es una función. Estudiaremos las funciones en los próximos capítulos donde veremos que no hay ningún tipo especial "function" en JavaScript. Las funciones pertenecen al tipo objeto. Pero `typeof` las trata de manera diferente, devolviendo `function`. Además proviene de los primeros días de JavaScript. Técnicamente dicho comportamiento es incorrecto pero puede ser conveniente en la práctica.
+3. El resultado de `typeof alert` es `"function"` porque `alert` es una función. Estudiaremos las funciones en los próximos capítulos donde veremos que no hay ningún tipo especial "function" en JavaScript. Las funciones pertenecen al tipo objeto. Pero `typeof` las trata de manera diferente, devolviendo `function`. Además proviene de los primeros días de JavaScript. Técnicamente dicho comportamiento es incorrecto, pero puede ser conveniente en la práctica.
 
 ```smart header="Sintaxis de `typeof(x)`"
 Se puede encontrar otra sintaxis en algún código: `typeof(x)`. Es lo mismo que `typeof x`.
@@ -263,14 +263,16 @@ Algunos prefieren `typeof(x)`, aunque la sintaxis `typeof x` es mucho más comú
 
 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 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.
+- Siete tipos de datos primitivos 
+    - `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 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`.
+    - `symbol` para identificadores únicos.
+- Y un tipo de dato no primitivo:
+    - `object` para estructuras de datos complejas.
 
 El operador `typeof` nos permite ver qué tipo está almacenado en una variable.
 

Diff for: 1-js/02-first-steps/07-type-conversions/article.md

@@ -98,7 +98,7 @@ Esto ocurre solo si al menos uno de los argumentos es un string, en caso contrar
 
 La conversión a boolean es la más simple.
 
-Ocurre en operaciones lógicas (más adelante veremos test condicionales y otras cosas similares) pero también puede realizarse de forma explícita llamando a la función `Boolean(value)`.
+Ocurre en operaciones lógicas (más adelante veremos test condicionales y otras cosas similares), pero también puede realizarse de forma explícita llamando a la función `Boolean(value)`.
 
 Las reglas de conversión:
 

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

@@ -366,7 +366,7 @@ let a = counter++; // (*) cambiado ++counter a counter++
 alert(a); // *!*1*/!*
 ```
 
-En la línea `(*)`, la forma *sufijo* `counter++` también incrementa `counter` pero devuelve el *antiguo* valor (antes de incrementar). Por lo tanto, el `alert` muestra `1`.
+En la línea `(*)`, la forma *sufijo* `counter++` también incrementa `counter`, pero devuelve el *antiguo* valor (antes de incrementar). Por lo tanto, el `alert` muestra `1`.
 
 Para resumir:
 
@@ -384,7 +384,7 @@ Para resumir:
     let counter = 0;
     alert( ++counter ); // 1
     ```
-- Si queremos incrementar un valor pero usamos su valor anterior, necesitamos la forma sufijo:
+- Si queremos incrementar un valor, pero usamos su valor anterior, necesitamos la forma sufijo:
 
     ```js run
     let counter = 0;
@@ -443,7 +443,7 @@ Estos operadores se usan muy raramente, cuando necesitamos manejar la representa
 
 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.
 
-El operador coma nos permite evaluar varias expresiones, dividiéndolas con una coma `,`. Cada una de ellas es evaluada pero sólo el resultado de la última es devuelto.
+El operador coma nos permite evaluar varias expresiones, dividiéndolas con una coma `,`. Cada una de ellas es evaluada, pero sólo el resultado de la última es devuelto.
 
 Por ejemplo:
 

Diff for: 1-js/02-first-steps/15-function-basics/article.md

@@ -186,7 +186,7 @@ En el ejemplo de arriba, se puede decir: "la función `showMessage` es declarada
 
 ## Valores predeterminados
 
-Si una función es llamada pero no se le proporciona un argumento, su valor correspondiente se convierte en `undefined`.
+Si una función es llamada, pero no se le proporciona un argumento, su valor correspondiente se convierte en `undefined`.
 
 Por ejemplo, la función mencionada anteriormente `showMessage(from, text)` se puede llamar con un solo argumento:
 

Diff for: 1-js/02-first-steps/16-function-expressions/article.md

@@ -48,7 +48,7 @@ alert( sayHi ); // muestra el código de la función
 */!*
 ```
 
-Tenga en cuenta que la última línea no ejecuta la función, porque no hay paréntesis después de `sayHi`. Existen lenguajes de programación en los que cualquier mención del nombre de una función causa su ejecución pero JavaScript no funciona así.
+Tenga en cuenta que la última línea no ejecuta la función, porque no hay paréntesis después de `sayHi`. Existen lenguajes de programación en los que cualquier mención del nombre de una función causa su ejecución, pero JavaScript no funciona así.
 
 En JavaScript, una función es un valor, por lo tanto podemos tratarlo como un valor. El código de arriba muestra su representación de cadena, que es el código fuente.
 

Diff for: 1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -48,7 +48,7 @@ Como puedes ver, `(a, b) => a + b` significa una función que acepta dos argumen
     alert( double(3) ); // 6
     ```
 
-- Si no hay parámetros, los paréntesis estarán vacíos pero deben estar presentes:
+- Si no hay parámetros, los paréntesis estarán vacíos; pero deben estar presentes:
 
     ```js run
     let sayHi = () => alert("¡Hola!");

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

@@ -135,7 +135,7 @@ Hay botones para esto en le panel superior derecho. Revisémoslos.
     Otro clic volverá a ejecutar otro comando, y así uno por uno, a través de todo el script.
 
 <span class="devtools" style="background-position:-62px -192px"></span> -- "saltar paso": corre al comando siguiente, pero *no te metas en la función*, hotkey `key:F10`.
-: Similar a "siguiente paso" pero se comporta diferente si la siguiente sentencia es un llamado a función. Esto es: no una nativa como alert, sino una función nuestra.
+: Similar a "siguiente paso", pero se comporta diferente si la siguiente sentencia es un llamado a función. Esto es: no una nativa como alert, sino una función nuestra.
 
     El comando "siguiente" entra y pausa en la primera línea, en cambio "saltar" ejecuta la función anidada de forma invisible, no mostrando el interior de la función.
 
@@ -144,7 +144,7 @@ Hay botones para esto en le panel superior derecho. Revisémoslos.
     Es útil si no estamos interesados en ver lo que pasa dentro de la función llamada.
 
 <span class="devtools" style="background-position:-4px -194px"></span> -- siguiente paso, hotkey `key:F11`.
-: Similar a "siguiente" pero se comporta diferente en las llamadas asincrónicas. Si apenas comienzas en javaScript, puedes ignorar esto por ahora pues no tenemos llamados asincrónicos aún.
+: Similar a "siguiente", pero se comporta diferente en las llamadas asincrónicas. Si apenas comienzas en javaScript, puedes ignorar esto por ahora pues no tenemos llamados asincrónicos aún.
 
     Para el futuro, simplemente recuerda que "Siguiente" ignora las acciones asincrónicas tales como `setTimeout` (llamada a función programada), que se ejecutan después. The "Siguiente dentro" va al interior de su código, esperando por él si es necesario. Puedes ver el [DevTools manual](https://developers.google.com/web/updates/2018/01/devtools#async) para más detalles.
 

Diff for: 1-js/03-code-quality/01-debugging-chrome/chrome-sources-console.svg

@@ -153,7 +153,7 @@ function pow(x, n) {
 	Sin dichos comentarios, las siguientes situaciones son posibles:
 	1. Tú (o tu compañero) abres el código escrito hace ya algún tiempo, y te das cuenta de que es "subóptimo".
 	2. Piensas: "Que estúpido que era antes, y que inteligente que soy ahora", y lo reescribes utilizando la variante "más obvia y correcta".
-	3. ...El impulso de reescribir era bueno. Pero en el proceso ves que la solución "más obvia" en realidad falla. Incluso recuerdas vagamente el porqué, porque ya lo intentaste hace mucho. Vuelves a la variante correcta pero has estado perdiendo el tiempo.
+	3. ...El impulso de reescribir era bueno. Pero en el proceso ves que la solución "más obvia" en realidad falla. Incluso recuerdas vagamente el porqué, porque ya lo intentaste hace mucho. Vuelves a la variante correcta, pero has estado perdiendo el tiempo.
 
 	Los comentarios que explican la solución correcta son muy importantes. Nos ayudan a continuar el desarrollo de forma correcta.
 

Diff for: 1-js/03-code-quality/01-debugging-chrome/chrome-tabs.svg

@@ -128,7 +128,7 @@ function pow(x, n) {
 
 ## Mejoramos el spec
 
-Lo que hemos hecho es una trampa. La función no funciona bien: ejecutar un cálculo diferente como   `pow(3,4)` nos devuelve un resultado incorrecto pero el test pasa.
+Lo que hemos hecho es una trampa. La función no funciona bien: ejecutar un cálculo diferente, como `pow(3,4)`, nos devuelve un resultado incorrecto, pero el test pasa.
 
 ... pero la situación es habitual, ocurre en la práctica. Los tests pasan, pero la función no funciona bien. Nuestra especificación está incompleta. Necesitamos añadir más casos de uso a la especificación.
 

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

@@ -248,7 +248,7 @@ Puede parecer que la linea `(*)` ocasionaría un error, pero no.  El valor de `u
 
 En otras palabras, `const user` solamente da error cuando intentamos asignar `user=...` como un todo.
 
-Si realmente queremos hacer constantes las propiedades del objeto, es también posible pero usando métodos totalmente diferentes, las veremos después en el capítulo <info:property-descriptors>.
+Si realmente queremos hacer constantes las propiedades del objeto, también es posible; pero usando métodos totalmente diferentes, los que veremos después en el capítulo <info:property-descriptors>.
 ````
 
 ## Resumen

Diff for: 1-js/03-code-quality/05-testing-mocha/article.md

@@ -46,7 +46,7 @@ alert(user.address ? user.address.street : undefined);
 
 Esto funciona, no hay error... Pero es bastante poco elegante. Como puedes ver, `"user.address"` aparece dos veces en el código. 
 
-Aquí, el mismo caso pero con la búsqueda de `document.querySelector`:
+El mismo caso, pero con la búsqueda de `document.querySelector`:
 
 ```js run
 let html = document.querySelector('.elem') ? document.querySelector('.elem').innerHTML : null;

Diff for: 1-js/04-object-basics/02-object-copy/article.md

@@ -31,7 +31,7 @@ let id = Symbol("id");
 
 Se garantiza que los símbolos son únicos. Aunque declaremos varios Symbols con la misma descripción, éstos tendrán valores distintos. La descripción es solamente una etiqueta que no afecta nada más.
 
-Por ejemplo, aquí hay dos Symbols con la misma descripción -- pero no son iguales:
+Por ejemplo, aquí hay dos Symbols con la misma descripción... pero no son iguales:
 
 ```js run
 let id1 = Symbol("id");

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

@@ -1,4 +1,4 @@
-# La solución simple pero equivocada
+# La solución simple, pero equivocada
 
 La solución más simple, pero equivocada, sería generar un valor entre `min` y `max` y redondearlo:
 

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

@@ -448,4 +448,4 @@ Para números con decimales:
 
 Más funciones matemáticas:
 
-- Revisa el documento del objeto [Math](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Math) cuando las necesites. La biblioteca es pequeña pero puede cubrir las necesidades básicas.
+- Revisa el documento del objeto [Math](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Math) cuando las necesites. La biblioteca es pequeña, pero puede cubrir las necesidades básicas.

Diff for: 1-js/05-data-types/02-number/9-random-int-min-max/solution.md

@@ -266,7 +266,7 @@ while (true) {
 }
 ```
 
-Podemos escribir el mismo algoritmo pero más corto:
+Podemos escribir el mismo algoritmo, pero más corto:
 
 ```js run
 let str = 'Astuto como un zorro, fuerte como un buey';
@@ -296,9 +296,9 @@ if (str.indexOf("Widget")) {
 }
 ```
 
-La `alerta` en el ejemplo anterior no se muestra ya que `str.indexOf("Widget")` retorna `0` (lo que significa que encontró el string en la posición inicial). Correcto pero `if` considera `0` como `falso`.
+La `alerta` en el ejemplo anterior no se muestra ya que `str.indexOf("Widget")` retorna `0` (lo que significa que encontró el string en la posición inicial). Eos correcto, pero `if` considera `0` como `falso`.
 
-Por lo que debemos buscar por `-1` como sigue:
+Por ello debemos buscar por `-1` como sigue:
 
 ```js run
 let str = "Widget con id";
@@ -353,7 +353,7 @@ Ahora podemos ver este truco solo en código viejo, porque JavaScript moderno pr
 
 El método más moderno [str.includes(substr, pos)](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/String/includes) retorna `true/false` dependiendo si `str` contiene `substr` dentro.
 
-Es la opción correcta si lo que necesitamos es encontrar el `substr` pero no necesitamos la posición.
+Es la opción correcta, si lo que necesitamos es encontrar el `substr` pero no necesitamos su posición.
 
 ```js run
 alert('Widget con id'.includes('Widget')); // true

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

@@ -22,7 +22,7 @@ let strings = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(strings) ); // Hare, Krishna, :-O
 ```
 
-El código funciona pero tiene un problema potencial de desempeño.
+El código funciona, pero tiene un problema potencial de desempeño.
 
 El método `result.includes(str)` internamente recorre el array `result` y compara cada elemento con `str` para encontrar una coincidencia.
 

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

@@ -58,19 +58,19 @@ Un resultado de ejemplo (depende del motor JS):
 
 Podemos ver una clara tendencia: `123` y `213` aparecen mucho más seguido que otros.
 
-El resultado del código puede variar entre distintos motores JavaScript pero ya podemos ver que esta forma de abordar el problema es poco confiable.
+El resultado del código puede variar entre distintos motores JavaScript, pero ya podemos ver que esta forma de abordar el problema es poco confiable.
 
 ¿Por qué no funciona? Generalmente hablando, `sort` es una "caja negra": tiramos dentro un array y una función de ordenamiento y esperamos que el array se ordene. Pero debido a la total aleatoriedad de la comparación, la caja negra se vuelve loca y exactamente en que sentido se vuelve loca depende de la implementación específica, que difiere de un motor a otro.
 
-Existen otra formas mejores de realizar la tarea. Por ejemplo, hay un excelente algorítmo llamado [Algoritmo de Fisher-Yates](https://es.wikipedia.org/wiki/Algoritmo_de_Fisher-Yates). La idea es recorrer el array en sentido inverso e intercambiar cada elemento con un elemento aleatorio anterior:
+Existen otra formas mejores de realizar la tarea. Por ejemplo, hay un excelente algoritmo llamado [Algoritmo de Fisher-Yates](https://es.wikipedia.org/wiki/Algoritmo_de_Fisher-Yates). La idea es recorrer el array en sentido inverso e intercambiar cada elemento con un elemento aleatorio anterior:
 
 ```js
 function shuffle(array) {
   for (let i = array.length - 1; i > 0; i--) {
     let j = Math.floor(Math.random() * (i + 1)); // índice aleatorio entre 0 e i
 
     // intercambia elementos array[i] y array[j]
-    // usamos la sintáxis "asignación de desestructuración" para lograr eso
+    // usamos la sintaxis "asignación de desestructuración" para lograr eso
     // encontrarás más información acerca de esa sintaxis en los capítulos siguientes
     // lo mismo puede ser escrito como:
     // let t = array[i]; array[i] = array[j]; array[j] = t