Merge pull request #635 from joaquinelio/susy220621

Susy220621

Author: joaquinelio

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

@@ -106,17 +106,17 @@ Las herramientas modernas hacen la conversión (Transpilación) muy rápida y tr
 
 Ejemplos de tales lenguajes:
 
-- [CoffeeScript](http://coffeescript.org/) Es una "sintaxis azucarada" para JavaScript. Introduce una sintaxis corta, permitiéndonos escribir un código mas claro y preciso. Usualmente desarrolladores de Ruby prefieren este lenguaje.
-- [TypeScript](http://www.typescriptlang.org/) se concentra en agregar "tipado estricto" ("strict data typing") para simplificar el desarrollo y soporte de sistemas complejos. Es desarrollado por Microsoft.
+- [CoffeeScript](https://coffeescript.org/) Es una "sintaxis azucarada" para JavaScript. Introduce una sintaxis corta, permitiéndonos escribir un código mas claro y preciso. Usualmente desarrolladores de Ruby prefieren este lenguaje.
+- [TypeScript](https://www.typescriptlang.org/) se concentra en agregar "tipado estricto" ("strict data typing") para simplificar el desarrollo y soporte de sistemas complejos. Es desarrollado por Microsoft.
 - [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.
+- [Dart](https://www.dartlang.org/) es un lenguaje independiente, 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.
 
 ## Resumen
 
-- JavaScript fue inicialmente creado como un lenguaje solo para el navegador, pero ahora es usado también en muchos otros entornos.
+- JavaScript fue inicialmente creado como un lenguaje solamente para el navegador, pero ahora es usado también en muchos otros entornos.
 - Hoy en día, JavaScript tiene una posición única como el lenguaje más extendido y adoptado de navegador, con una integración completa con HTML y CSS.
 - Existen muchos lenguajes que se convierten o transpilan a JavaScript y aportan ciertas características. Es recomendable echarles un vistazo, al menos brevemente, después de dominar JavaScript.

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

@@ -29,7 +29,7 @@ JavaScript es un lenguaje en evolución, nuevas características son adicionadas
 
 Para ver la compatibilidad por navegador y otros motores, consultar:
 
-- <http://caniuse.com> - tablas de compatibilidad por característica, e.g. para comprobar qué motores soportan funciones modernas de criptografía: <http://caniuse.com/#feat=cryptography>.
+- <https://caniuse.com> - tablas de compatibilidad por característica, p.ej. para comprobar qué motores soportan funciones modernas de criptografía: <https://caniuse.com/#feat=cryptography>.
 - <https://kangax.github.io/compat-table> - tabla que muestra la compatibilidad o no de las prestaciones del lenguaje por motor.
 
 Todos estos recursos son de utilidad para el desarrollo con JavaScript, ya que incluyen información valiosa sobre los detalles del lenguaje, su compatibilidad, etc.

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

@@ -64,6 +64,7 @@ let message = 'Hola';
 ```
 
 Algunas personas también definen variables múltiples en estilo multilínea:
+
 ```js no-beautify
 let user = 'John',
   age = 25,
@@ -103,6 +104,7 @@ Por ejemplo, podemos imaginar la variable `message` como una caja etiquetada `"m
 Podemos introducir cualquier valor a la caja.
 
 También la podemos cambiar cuantas veces queramos:
+
 ```js run
 let message;
 
@@ -172,7 +174,7 @@ let test123;
 
 Cuando el nombre contiene varias palabras, comúnmente se utiliza [camelCase](https://es.wikipedia.org/wiki/Camel_case). Es decir: palabras van una detrás de otra, con cada palabra iniciando con letra mayúscula: `miNombreMuyLargo`.
 
-Es interesante notar -- el símbolo del dólar `'$'` y el guión bajo `'_'` también se utilizan en nombres. Son símbolos comunes, tal como las letras, sin ningún significado especial.
+Es interesante notar que el símbolo del dólar `'$'` y el guion bajo `'_'` también se utilizan en nombres. Son símbolos comunes, tal como las letras, sin ningún significado especial.
 
 Los siguientes nombres son válidos:
 
@@ -260,7 +262,6 @@ 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.
 
-
 ### Constantes mayúsculas
 
 Existe una práctica utilizada ampliamente de utilizar constantes como aliases de valores difíciles-de-recordar y que se conocen previo a la ejecución.
@@ -291,6 +292,7 @@ Ventajas:
 Ser una "constante" solo significa que el valor de la variable nunca cambia. Pero hay constantes que son conocidas previo a la ejecución (como el valor hexadecimal del color rojo) y hay constantes que son *calculadas* en el tiempo de ejecución, pero no cambian después de su asignación inicial.
 
 Por ejemplo:
+
 ```js
 const pageLoadTime = /* el tiempo que tardó la página web para cargar */;
 ```

1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md

@@ -1,6 +1,6 @@
 La respuesta: `null`, porque es el primer valor falso de la lista.
 
 ```js run
-alert( 1 && null && 2 );
+alert(1 && null && 2);
 ```
 

1-js/02-first-steps/13-while-for/article.md

@@ -6,6 +6,19 @@ Por ejemplo, mostrar los elementos de una lista uno tras otro o simplemente ejec
 
 Los *Bucles* son una forma de repetir el mismo código varias veces.
 
+```smart header="Los bucles for..of y for..in"
+Un pequeño anuncio para lectores avanzados.
+
+Este artículo cubre solamente los bucles básicos: `while`, `do..while` y `for(..;..;..)`.
+
+Si llegó a este artículo buscando otro tipo de bucles, aquí están los enlaces:
+
+- Vea [for..in](info:object#forin) para bucles sobre propiedades de objetos.
+- Vea [for..of](info:array#loops) e [iterables](info:iterable) para bucles sobre arrays y objetos iterables.
+
+De otra manera, por favor continúe leyendo.
+```
+
 ## El bucle "while"
 
 El bucle `while` (mientras) tiene la siguiente sintaxis:
@@ -159,10 +172,8 @@ for (i = 0; i < 3; i++) { // usa una variable existente
 
 alert(i); // 3, visible, porque fue declarada fuera del bucle
 ```
-
 ````
 
-
 ### Omitiendo partes
 
 Cualquier parte de `for` puede ser omitida.
@@ -283,7 +294,6 @@ if (i > 5) {
 
 ...y lo reescribimos usando un signo de interrogación:
 
-
 ```js no-beautify
 (i > 5) ? alert(i) : *!*continue*/!*; // continue no está permitida aquí
 ```
@@ -319,7 +329,8 @@ Necesitamos una manera de detener el proceso si el usuario cancela la entrada.
 
 El `break` ordinario después de `input` solo nos sacaría del bucle interno. Eso no es suficiente. ¡Etiquetas, vengan al rescate!
 
-Una *etiqueta* es un identificador con un ":" antes de un bucle:
+Una *etiqueta* es un identificador con un signo de dos puntos ":" antes de un bucle:
+
 ```js
 labelName: for (...) {
   ...
@@ -341,6 +352,7 @@ La declaración `break <labelName>` en el bucle debajo nos saca hacia la etiquet
     // hacer algo con el valor...
   }
 }
+
 alert('Listo!');
 ```
 
@@ -361,13 +373,15 @@ La directiva `continue` también puede usar usada con una etiqueta. En este caso
 Las etiquetas no nos permiten saltar a un lugar arbitrario en el código.
 
 Por ejemplo, es imposible hacer esto:
+
 ```js
 break label;  // ¿saltar a label? No funciona.
 
 label: for (...)
 ```
 
-Una directiva `break` debe estar en el interior del bucle. Técnicamente, cualquier bloque de código etiquetado:
+Una directiva `break` debe estar en el interior del bucle. Aunque, técnicamente, puede estar en cualquier bloque de código etiquetado:
+
 ```js
 label: {
   // ...

1-js/03-code-quality/03-comments/article.md

@@ -125,21 +125,21 @@ Describe la arquitectura
 Documenta la utilización de una función
 : Hay una sintaxis especial [JSDoc](https://en.wikipedia.org/wiki/JSDoc) para documentar una función: utilización, parámetros, valor devuelto.
 
-	Por ejemplo:
-	```js
-    /**
-     * Devuelve x elevado a la potencia de n.
-     *
-     * @param {number} x El número a elevar.
-     * @param {number} n La potencia, debe ser un número natural.
-     * @return {number} x elevado a la potencia de n.
-     */
-    function pow(x, n) {
-      ...
-    }
-    ```
+Por ejemplo:
+```js
+/**
+  * Devuelve x elevado a la potencia de n.
+  *
+  * @param {number} x El número a elevar.
+  * @param {number} n La potencia, debe ser un número natural.
+  * @return {number} x elevado a la potencia de n.
+  */
+function pow(x, n) {
+  ...
+}
+```
 
-	Estos tipos de comentarios nos permiten entender el propósito de la función y cómo usarla de la manera correcta sin mirar su código.
+	Este tipo de comentarios nos permite entender el propósito de la función y cómo usarla de la manera correcta sin tener que examinar su código.
 
 	Por cierto, muchos editores como [WebStorm](https://www.jetbrains.com/webstorm/) también pueden entenderlos y usarlos para proveer auto completado y algún tipo de verificación automática para el código.
 

1-js/04-object-basics/01-object/article.md

@@ -355,7 +355,7 @@ En el código anterior, la propiedad  `obj.test` técnicamente existe. Entonces
 Situaciones como esta suceden raramente ya que `undefined` no debe ser explícitamente asignado. Comúnmente usamos `null` para valores "desconocidos" o "vacíos". Por lo que el operador `in` es un invitado exótico en nuestro código.
 
 
-## El bucle "for..in" 
+## El bucle "for..in" [#forin]
 
 Para recorrer todas las claves de un objeto existe una forma especial de bucle: `for..in`. Esto es algo completamente diferente a la construcción `for(;;)` que estudiaremos más adelante.
 

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

@@ -197,7 +197,7 @@ Hay otras optimizaciones y tipos de algoritmos de recolección de basura. Por mu
 
 Los principales puntos a saber:
 
-- La reecolección de basura se ejecuta automáticamente. No la podemos forzar o evitar.
+- La recolección de basura se ejecuta automáticamente. No la podemos forzar o evitar.
 - Los objetos se retienen en la memoria mientras son accesibles.
 - Ser referenciado no es lo mismo que ser accesible (desde una raíz): un conjunto de objetos interconectados pueden volverse inalcanzables como un todo, como vimos en el ejemplo de arriba.
 

1-js/04-object-basics/04-object-methods/article.md

@@ -90,7 +90,7 @@ user = {
 
 Como se demostró, podemos omitir `"function"` y simplemente escribir `sayHi()`.
 
-A decir verdad, las notaciones no son completamente idénticas. Hay diferencias sutiles relacionadas a la herencia de objetos (por cubrir más adelante) que no importan ahora. En casi todos los casos la sintaxis abreviada es la preferida.
+A decir verdad, las notaciones no son completamente idénticas. Hay diferencias sutiles relacionadas a la herencia de objetos (por cubrir más adelante) que por ahora no son relevantes. En casi todos los casos la sintaxis abreviada es la preferida.
 
 ## "this" en métodos
 

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_coma_flotante), 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. Números BigInt , para representar 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. Como los bigints son usados en unas pocas á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 regular no puede exceder <code>2<sup>53</sup></code> ni ser menor a <code>-2<sup>53</sup></code> manteniendo la precisión. Como los bigints son usados en algunas áreas especiales, les dedicamos un capítulo especial <info:bigint>.
 
 Aquí hablaremos de números regulares. Ampliemos lo que ya sabemos de ellos.
 
@@ -50,10 +50,10 @@ let mсs = 0.000001;
 Igual que antes, el uso de `"e"` puede ayudar. Si queremos evitar la escritura de ceros explícitamente, podríamos expresar lo mismo como:
 
 ```js
-let mcs = 1e-6; // seis ceros a la izquierda de 1
+let mcs = 1e-6; // cinco ceros a la izquierda de 1
 ```
 
-Si contamos los ceros en `0.000001`, hay 6 de ellos. Entonces naturalmente es `1e-6`.  
+Si contamos los ceros en `0.000001`, hay 6 de ellos en total. Entonces naturalmente es `1e-6`.  
 
 En otras palabras, un número negativo detrás de `"e"` significa una división por el 1 seguido de la cantidad dada de ceros:
 
@@ -63,6 +63,9 @@ En otras palabras, un número negativo detrás de `"e"` significa una división
 
 // -6 divide por 1 con 6 ceros
 1.23e-6 === 1.23 / 1000000; // 0.00000123
+
+// un ejemplo con un número mayor
+1234e-2 === 1234 / 100; // 12.34, el punto decimal se mueve 2 veces
 ```
 
 ### Números hexadecimales, binarios y octales
@@ -305,7 +308,7 @@ Ambos pertenecen al tipo `number`, pero no son números "normales", así que hay
     alert( isNaN("str") ); // true
     ```
 
-    Pero ¿necesitamos esta función? ¿No podemos simplemente usar la comparación `=== NaN`? Lo lamento pero la respuesta es no. El valor `NaN` es único en que no es igual a nada, incluyendo a sí mismo:
+    Pero ¿necesitamos esta función? ¿No podemos simplemente usar la comparación `=== NaN`? Desafortunadamente no. El valor `NaN` es único en que no es igual a nada, incluyendo a sí mismo:
 
     ```js run
     alert( NaN === NaN ); // false
@@ -399,8 +402,8 @@ Unos ejemplos:
     alert( Math.random() ); // ... (cualquier número aleatorio)
     ```
 
-`Math.max(a, b, c...)` / `Math.min(a, b, c...)`
-: Devuelve el mayor/menor de entre una cantidad arbitraria de argumentos.
+`Math.max(a, b, c...)` y `Math.min(a, b, c...)`
+: Devuelven el mayor y el menor de entre una cantidad arbitraria de argumentos.
 
     ```js run
     alert( Math.max(3, 5, -10, 0, 1) ); // 5
@@ -429,6 +432,11 @@ Para sistemas numéricos diferentes:
 - `parseInt(str, base)` convierte un string a un entero en el sistema numérico de la `base` dada `base`, `2 ≤ base ≤ 36`.
 - `num.toString(base)` convierte un número a string en el sistema de la `base` dada.
 
+Para tests de números regulares:
+
+- `isNaN(value)` convierte su argumento a number y luego verifica si es `NaN`
+- `isFinite(value)` convierte su argumento a number y devuelve `true` si es un número regular, no `NaN/Infinity/-Infinity`
+
 Para convertir valores como `12pt` y `100px` a un número:
 
 - Usa `parseInt/parseFloat` para una conversión "suave", que lee un número desde un string y devuelve el valor del número que pudiera leer antes de encontrar error.

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

@@ -155,7 +155,7 @@ Para las pilas, la última introducida es la primera en ser recibida, en inglés
 
 Los arrays en JavaScript pueden trabajar como colas o pilas. Ellos permiten agregar/quitar elementos al/del principio o al/del final.
 
-En ciencias de la computación la estructura de datos que permite esto se denomina cola de doble extremo o [bicola](https://es.wikipedia.org/wiki/Bicola).
+En ciencias de la computación, la estructura de datos que permite esto se denomina cola de doble extremo o [bicola](https://es.wikipedia.org/wiki/Bicola).
 
 **Métodos que trabajan sobre el final del array:**
 
@@ -530,7 +530,7 @@ El llamado a `new Array(number)` crea un array con la longitud dada, pero sin el
 Obtener los elementos:
 
 - Podemos obtener un elemento por su índice, como `arr[0]`
-- También podemos usar el método `at(i)`, que permite índices negativos. Para valores negativos de `i`, cuenta hacia atrás desde el final del array. Funciona igual que  `arr[i]`, si `i >= 0`.
+- También podemos usar el método `at(i)`, que permite índices negativos. Para valores negativos de `i`, cuenta hacia atrás desde el final del array. Cuando `i >= 0`, funciona igual que `arr[i]`.
 
 Podemos usar un array como una pila "deque" o "bicola" con las siguientes operaciones: