susy260303

Author: joaquinelio

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

@@ -72,8 +72,9 @@ Ejemplos de tales restricciones incluyen:
 
     Esta restricción es conocida como "política del mismo origen" ("Same Origin Policy"). Es posible la comunicación, pero ambas páginas deben acordar el intercambio de datos y también deben contener el código especial de JavaScript que permite controlarlo. Cubriremos esto en el tutorial.
 
-    De nuevo: esta limitación es para la seguridad del usuario. Una página de `http://algunsitio.com`, que el usuario haya abierto, no debe ser capaz de acceder a otra pestaña del navegador con la URL `http://gmail.com` y robar la 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 está 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.
+    Esta limitación, una vez más, existe para la seguridad del usuario. Una página `http://algunsitio.com` abierta en una pestaña no debe poder acceder a otra pestaña con la URL `http://gmail.com` y robar su información.
+
+- JavaScript puede comunicarse fácilmente a través de la red con el servidor del que proviene la página actual. Pero su capacidad para recibir información de otros sitios o dominios está restringida. Aunque es posible hacerlo, requiere un acuerdo explícito del sitio remoto mediante encabezados HTTP. Una vez más: esto es una limitación de seguridad.
 
 ![](limitations.svg)
 

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

@@ -172,7 +172,7 @@ let userName;
 let test123;
 ```
 
-Cuando el nombre contiene varias palabras, se suele usar el estilo [camelCase](https://es.wikipedia.org/wiki/Camel_case) (capitalización en camello), donde las palabras van pegadas una detrás de otra, con cada inicial en mayúscula: `miNombreMuyLargo`.
+Cuando el nombre contiene varias palabras, se suele usar el estilo [camelCase](https://es.wikipedia.org/wiki/Camel_case), donde las palabras van una detrás de otra y cada palabra, excepto la primera, empieza con mayúscula: `miNombreMuyLargo`.
 
 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.
 

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

@@ -266,7 +266,7 @@ 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.
 
-Una vez más, con el propósito de la legibilidad es mejor separa tal código en unas pocas líneas:
+Una vez más, por motivos de legibilidad, es mejor separar este código en varias líneas:
 
 ```js
 c = 2 + 2;

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

@@ -211,10 +211,11 @@ Obtenemos estos resultados porque:
 
 - No uses comparaciones `>= > < <=` con una variable que puede ser `null/undefined`, a menos que estés realmente seguro de lo que estás haciendo. Si una variable puede tener estos valores, verifícalos por separado.
 
+
 ## Resumen
 
-- Los operadores de comparación retornan un valor booleano.
-- Las cadenas se comparan letra por letra en orden de diccionario.
-- Cuando se comparan valores de diferentes tipos, se convierten en números (con la excepción de la igualdad estricta).
-- Los valores `null` y `undefined` son iguales `==` entre sí y también iguales a sí mismos, pero no son iguales a ningún otro valor.
-- Ten cuidado al usar comparaciones como `>` o `<` con variables que ocasionalmente pueden ser `null/undefined`. Comprobar `null/undefined` por separado suele ser una buena idea.
+- Los operadores de comparación devuelven un valor booleano.  
+- Las cadenas se comparan letra por letra, siguiendo el orden del diccionario.  
+- Cuando se comparan valores de distintos tipos, se convierten a números (excepto en la comprobación de igualdad estricta `===`).  
+- Los valores `null` y `undefined` son iguales `==` a sí mismos y entre sí, pero no equivalen a ningún otro valor.  
+- Ten cuidado al usar comparaciones como `>` o `<` con variables que ocasionalmente pueden ser `null` o `undefined`. Es recomendable revisar esos casos por separado.

1-js/03-code-quality/02-coding-style/1-style-errors/solution.md

@@ -6,16 +6,16 @@ function pow(x,n)  // <- sin espacio entre argumentos
 {  // <- llave en una línea separada
   let result=1;   // <- sin espacios antes o después de =
   for(let i=0;i<n;i++) {result*=x;}   // <- sin espacios
-  // el contenido de {...} debe estar en una nueva línea
+  // el contenido de { ... } debe estar en una nueva línea
   return result;
 }
 
 let x=prompt("x?",''), n=prompt("n?",'') // <-- técnicamente posible,
-// pero mejor que sea 2 líneas, también no hay espacios y falta ;
-if (n<0)  // <- sin espacios dentro (n < 0), y debe haber una línea extra por encima
+// pero mejor que sean 2 líneas. También faltan espacios y el ";"
+if (n<0)  // <- sin espacios dentro (n <= 0), y debe haber una línea extra por encima
 {   // <- llave en una línea separada
   // debajo - las líneas largas se pueden dividir en varias líneas para mejorar la legibilidad
-  alert(`Power ${n} is not supported, please enter an integer number greater than zero`);
+  alert(`Potencia ${n} no está soportada, por favor ingrese un número entero mayor que cero`);
 }
 else // <- podría escribirlo en una sola línea como "} else {"
 {
@@ -40,8 +40,8 @@ let x = prompt("x?", "");
 let n = prompt("n?", "");
 
 if (n <= 0) {
-  alert(`Power ${n} is not supported,
-    please enter an integer number greater than zero`);
+  alert(`Potencia ${n} no está soportada,
+ por favor ingrese un número entero mayor que cero`);
 } else {
   alert( pow(x, n) );
 }

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

@@ -5,7 +5,7 @@ Como aprendimos en el capítulo <info:types>, hay ocho tipos de datos en JavaScr
 
 En contraste, los objetos son usados para almacenar colecciones de varios datos y entidades más complejas asociados con un nombre clave. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. 
 
-Podemos crear un objeto usando las llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key:value", donde `key` es un string (también llamado "nombre clave"), y `value` puede ser cualquier cosa. P.D. Para fines prácticos de la lección, nos referiremos a este par de conceptos como "clave:valor".
+Un objeto se puede crear con llaves `{ … }` y una lista opcional de *propiedades*. Cada propiedad es un par `"key: value"` ("clave: valor"), donde `key` es un string (también llamado "nombre de propiedad") y `value` puede ser cualquier cosa.
 
 Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de datos es almacenada en su archivo por la clave. Es fácil encontrar un archivo por su nombre o agregar/eliminar un archivo.
 

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

@@ -100,7 +100,7 @@ Digamos que queremos el último elemento de un array.
 
 Algunos lenguajes de programación permiten el uso de índices negativos para este propósito, como `fruits[-1]`.
 
-Sin embargo, en JavaScript esto no funcionará. El resultado será `undefined`, porque el índice de los corchetes es tratado literalmente.
+Sin embargo, en JavaScript esto no funcionará. El resultado será `undefined`, porque el índice entre corchetes se interpreta literalmente.
 
 Podemos calcular explícitamente el último índice y luego acceder al elemento: `fruits[fruits.length - 1]`.
 

1-js/06-advanced-functions/08-settimeout-setinterval/article.md

@@ -218,7 +218,7 @@ Y aquí está la imagen para el `setTimeout` anidado:
 
 ![](settimeout-interval.svg)
 
-**El `setTimeout` anidado garantiza el retraso fijo (aquí 100ms).**
+**El `setTimeout` anidado garantiza un retraso mínimo (100 ms aquí) entre el final de una ejecución y el comienzo de la siguiente.**
 
 Esto se debe a que se planea una nueva llamada al final de la anterior.
 

1-js/09-classes/06-instanceof/article.md

@@ -54,9 +54,8 @@ El algoritmo de `obj instanceof Class` funciona más o menos de la siguiente man
     Por ejemplo:
 
     ```js run
-
-    // verificacion con instanceof que determina que 
-    // cualquier cosa que tenga la propiedad canEat es un animal
+    // Configurar la verificación con `instanceof`, que asume que
+    // cualquier objeto que tenga la propiedad `canEat` es un `Animal`
 
     class Animal {
       static [Symbol.hasInstance](obj) {
@@ -69,9 +68,9 @@ El algoritmo de `obj instanceof Class` funciona más o menos de la siguiente man
     alert(obj instanceof Animal); // true: Animal[Symbol.hasInstance](obj) es llamada
     ```
 
-2. La mayoría de las clases no tienen `Symbol.hasInstance`. En ese caso, se utiliza la lógica estándar: `obj instanceof Class` comprueba si `Class.prototype` es igual a uno de los prototipos en la cadena de prototipos `obj`.
+2. La mayoría de las clases no tienen `Symbol.hasInstance`. En ese caso, se utiliza la lógica estándar: `obj instanceof Class` comprueba si `Class.prototype` es igual a alguno de los prototipos en la cadena de prototipos de `obj`.
 
-    En otras palabras, compara uno tras otro:
+   En otras palabras, compara uno tras otro:
 
     ```js
     obj.__proto__ === Class.prototype?