Merge branch 'master' into susy260303

Author: joaquinelio

1-js/02-first-steps/03-strict-mode/article.md

@@ -4,7 +4,7 @@ Durante mucho tiempo, JavaScript evolucionó sin problemas de compatibilidad. Se
 
 Esto tenía el beneficio de nunca romper código existente, pero lo malo era que cualquier error o decisión incorrecta tomada por los creadores de JavaScript se quedaba para siempre en el lenguaje.
 
-Esto fue así hasta 2009, cuando ECMAScript 5 (ES5) apareció. Esta versión añadió nuevas características al lenguaje y modificó algunas de las ya existentes. Para mantener el código antiguo funcionando, la mayor parte de las modificaciones están desactivadas por defecto. Tienes que activarlas explícitamente usando una directiva especial: `"use strict"`.
+Esto fue así hasta 2009, cuando ECMAScript 5 (ES5) apareció. Esta versión añadió nuevas características al lenguaje y modificó algunas de las ya existentes. Para mantener el código antiguo funcionando, la mayoría de estas nuevas características están desactivadas por defecto. Tienes que activarlas explícitamente usando una directiva especial: `"use strict"`.
 
 ## "use strict"
 

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

@@ -1,24 +1,24 @@
 # Conversiones de Tipos
 
-La mayoría de las veces, los operadores y funciones convierten automáticamente los valores que se les pasan al tipo correcto. Esto es llamado "conversión de tipo".
+La mayoría de las veces, los operadores y las funciones convierten automáticamente los valores que reciben al tipo de dato que necesitan.
 
-Por ejemplo, `alert` convierte automáticamente cualquier valor a string para mostrarlo. Las operaciones matemáticas convierten los valores a números.
+Por ejemplo: `alert` convierte automáticamente cualquier valor a string para mostrarlo, y las operaciones matemáticas convierten los valores a números.
 
 También hay casos donde necesitamos convertir de manera explícita un valor al tipo esperado.
 
-```smart header="Aún no hablamos de objetos"
-En este capítulo no hablamos de objetos. Por ahora, solamente veremos los valores primitivos.
+```smart header="No hablaremos de los objetos aún"
+En este capítulo no cubrimos objetos. Por ahora, solamente veremos valores primitivos.
 
-Más adelante, después de haberlos tratado, veremos en el capítulo <info:object-toprimitive> cómo funciona la conversión de objetos.
+Más adelante, después de haberlos tratado, veremos en el capítulo <info:object-toprimitive> cómo funciona la conversión.
 ```
 
-## ToString
+## Conversión a String
 
-La conversión a string ocurre cuando necesitamos la representación en forma de texto de un valor.
+La conversión a string ocurre cuando necesitamos la representación textual de un valor.
 
-Por ejemplo, `alert(value)` lo hace para mostrar el valor como texto.
+Por ejemplo, `alert(value)` lo hace para mostrar `value` como texto.
 
-También podemos llamar a la función `String(value)` para convertir un valor a string:
+También podemos llamar a la función `String(value)` para convertir `value` a string:
 
 ```js run
 let value = true;
@@ -30,18 +30,19 @@ alert(typeof value); // string
 */!*
 ```
 
-La conversión a string es bastante obvia. El boolean `false` se convierte en `"false"`, `null` en `"null"`, etc.
+La conversión a string es bastante evidente. El boolean `false` se convierte en `"false"`, `null` en `"null"`, etc.
 
-## ToNumber
+## Conversión numérica
 
 La conversión numérica ocurre automáticamente en funciones matemáticas y expresiones.
 
-Por ejemplo, cuando se dividen valores no numéricos usando `/`:
+Por ejemplo, cuando se aplica la división `/` a valores no numéricos:
 
 ```js run
 alert( "6" / "2" ); // 3, los strings son convertidos a números
 ```
-Podemos usar la función `Number(value)` para convertir de forma explícita un valor a un número:
+
+Podemos usar la función `Number(value)` para convertir `value` a un número de forma explícita:
 
 ```js run
 let str = "123";
@@ -51,7 +52,8 @@ let num = Number(str); // se convierte en 123
 
 alert(typeof num); // number
 ```
-La conversión explícita es requerida usualmente cuando leemos un valor desde una fuente basada en texto, como lo son los campos de texto en los formularios, pero que esperamos que contengan un valor numérico.
+
+Usualmente, se requiere conversión explícita cuando leemos un valor desde una fuente basada en texto, como un formulario, pero esperamos que sea un número.
 
 Si el string no es un número válido, el resultado de la conversión será `NaN`. Por ejemplo:
 
@@ -68,33 +70,22 @@ Reglas de conversión numérica:
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;and&nbsp;false</code> | `1` y `0` |
-| `string` | Se eliminan los espacios (incluye espacios, tabs `\t`, saltos de línea `\n`, etc.) al inicio y final del texto. Si el string resultante es vacío, el resultado es `0`, en caso contrario el número es "leído" del string. Un error devuelve `NaN`. |
+| `string` | Se eliminan los espacios en blanco (incluyendo espacios, tabs `\t`, saltos de línea `\n`, etc.) del inicio y final del texto. Si el string resultante es vacío, el resultado es `0`, en caso contrario el número es "leído" del string. Un error devuelve `NaN`. |
 
 Ejemplos:
 
 ```js run
 alert( Number("   123   ") ); // 123
-alert( Number("123z") );      // NaN (error al leer un número en "z")
+alert( Number("123z") );      // NaN (error al leer el número cuando encuentra "z")
 alert( Number(true) );        // 1
 alert( Number(false) );       // 0
 ```
 
-Ten en cuenta que `null` y `undefined` se comportan de distinta manera aquí: `null` se convierte en `0` mientras que `undefined` se convierte en `NaN`.
-
-````smart header="Adición '+' concatena strings"
-Casi todas las operaciones matemáticas convierten valores a números. Una excepción notable es la suma `+`. Si uno de los valores sumados es un string, el otro valor es convertido a string.
+Es importante notar que `null` y `undefined` se comportan de distinta manera aquí: `null` se convierte en `0` mientras que `undefined` se convierte en `NaN`.
 
-Luego, los concatena (une):
+La mayoría de los operadores matemáticos también ejecutan dicha conversión, esto lo veremos en el siguiente capítulo.
 
-```js run
-alert( 1 + '2' ); // '12' (string a la derecha)
-alert( '1' + 2 ); // '12' (string a la izquierda)
-```
-
-Esto ocurre solo si al menos uno de los argumentos es un string, en caso contrario los valores son convertidos a número.
-````
-
-## ToBoolean
+## Conversión booleana
 
 La conversión a boolean es la más simple.
 
@@ -124,14 +115,13 @@ alert( Boolean(" ") ); // sólo espacios, también true (cualquier string no vac
 ```
 ````
 
-
 ## Resumen
 
 Las tres conversiones de tipo más usadas son a string, a número y a boolean.
 
-**`ToString`** -- Ocurre cuando se muestra algo. Se puede realizar con `String(value)`. La conversión a string es usualmente obvia para los valores primitivos.
+**`Conversión a String`** -- Ocurre cuando mostramos un valor. Se puede realizar con `String(value)`. La conversión a string es usualmente evidente para los valores primitivos.
 
-**`ToNumber`** -- Ocurre en operaciones matemáticas. Se puede realizar con `Number(value)`.
+**`Conversión numérica`** -- Ocurre en operaciones matemáticas. Se puede realizar con `Number(value)`.
 
 La conversión sigue las reglas:
 
@@ -142,7 +132,7 @@ La conversión sigue las reglas:
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
 | `string` | El string es leído "como es", los espacios en blanco (incluye espacios, tabs `\t`, saltos de línea `\n`, etc.) tanto al inicio como al final son ignorados. Un string vacío se convierte en `0`. Un error entrega `NaN`. |
 
-**`ToBoolean`** -- Ocurren en operaciones lógicas. Se puede realizar con `Boolean(value)`.
+**`Conversión booleana`** -- Ocurren en operaciones lógicas. Se puede realizar con `Boolean(value)`.
 
 Sigue las reglas:
 
@@ -152,7 +142,7 @@ Sigue las reglas:
 |cualquier otro valor| `true` |
 
 
-La mayoría de estas reglas son fáciles de entender y recordar. Las excepciones más notables donde la gente suele cometer errores son:
+La mayoría de estas reglas son fáciles de entender y recordar. Las excepciones más notables donde se suele cometer errores son:
 
 - `undefined` es `NaN` como número, no `0`.
 - `"0"` y textos que solo contienen espacios como `"   "` son `true` como boolean.

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md

@@ -22,4 +22,4 @@ undefined + 1 = NaN // (6)
 4. La resta siempre convierte a números, por lo tanto hace de `"  -9  "` un número `-9` (ignorando los espacios que lo rodean).
 5. `null` se convierte en `0` después de la conversión numérica.
 6. `undefined` se convierte en `NaN` después de la conversión numérica.
-7. Los caracteres de espacio se recortan al inicio y al final de la cadena cuando una cadena se convierte en un número. Aquí toda la cadena consiste en caracteres de espacio, tales como `\t`, `\n` y un espacio "común" entre ellos. Por lo tanto, pasa lo mismo que a una cadena vacía, se convierte en `0`.
+7. Al convertir una cadena en número, se ignoran los espacios en blanco al principio y al final (espacio común " ", tabulador \t, salto de línea \n, etc.). Si la cadena contiene solo ellos, queda vacía y se convierte en 0.

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

@@ -215,7 +215,7 @@ Obtenemos estos resultados porque:
 ## Resumen
 
 - Los operadores de comparación devuelven un valor booleano.  
-- Las cadenas se comparan letra por letra, siguiendo el orden del "diccionario".  
+- 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/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Reescriba el `if..else` utilizando operadores ternarios múltiples`'?'`.
 
-Para legibilidad, es recomendad dividirlo en múltiples lineas de código.
+Para mejor legibilidad, se recomienda dividirlo en múltiples lineas de código.
 
 ```js
 let message;

1-js/02-first-steps/10-ifelse/article.md

@@ -37,29 +37,29 @@ La sentencia `if (…)` evalúa la expresión dentro de sus paréntesis y convie
 
 Recordemos las reglas de conversión del capítulo <info:type-conversions>:
 
-- El número `0`, un string vacío `""`, `null`, `undefined`, y `NaN`, se convierten en `false`. Por esto son llamados valores "falsos".
-- El resto de los valores se convierten en `true`, entonces los llamaremos valores "verdaderos".
+- Los valores: número `0`, string vacío `""`, `null`, `undefined`, y `NaN`, en un contexto booleano se convierten en `false`. Por ello, sin ser booleanos, se los conoce como valores "falsy".
+- El resto de los valores se convierten en `true`, y son valores que llamamos "truthy".
 
 Entonces, el código bajo esta condición nunca se ejecutaría:
 
 ```js
-if (0) { // 0 es falso
+if (0) { // 0 es falsy
   ...
 }
 ```
 
 ...y dentro de esta condición siempre se ejecutará:
 
 ```js
-if (1) { // 1 es verdadero
+if (1) { // 1 es truthy
   ...
 }
 ```
 
 También podemos pasar un valor booleano pre-evaluado al `if`, así:
 
 ```js
-let cond = (year == 2015); // la igualdad evalúa y devuelve un true o false
+let cond = (year == 2015); // la igualdad se evalúa y devuelve un true o false
 
 if (cond) {
   ...
@@ -68,7 +68,7 @@ if (cond) {
 
 ## La cláusula "else"
 
-La sentencia `if` puede contener un bloque `else` ("si no", "en caso contrario") opcional. Este bloque se ejecutará cuando la condición sea falsa.
+La sentencia `if` puede contener un bloque `else` ("si no", "en caso contrario") opcional. Este bloque se ejecuta cuando la condición resulta falsa.
 
 Por ejemplo:
 ```js run
@@ -133,7 +133,7 @@ La Sintaxis es:
 let result = condition ? value1 : value2;
 ```
 
-Se evalúa `condition`: si es verdadera entonces devuelve `value1` , de lo contrario `value2`.
+Se evalúa `condition`: si resulta verdadera entonces devuelve `value1` , de lo contrario `value2`.
 
 Por ejemplo:
 

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

@@ -1,4 +1,4 @@
-La respuesta es `2`, ese es el primer valor verdadero.
+La respuesta es `2`, ese es el primer valor truthy.
 
 ```js run
 alert( null || 2 || undefined );

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

@@ -4,10 +4,10 @@ La repuesta: primero `1`, después `2`.
 alert( alert(1) || 2 || alert(3) );
 ```
 
-La llamada a `alert` no retorna un valor. O, en otras palabras, retorna `undefined`.
+Una llamada a `alert` no retorna un valor relevante. Siempre retorna `undefined`.
 
-1. El primer OR `||` evalúa el operando de la izquierda `alert(1)`. Eso muestra el primer mensaje con `1`.
-2. El `alert` retorna `undefined`, por lo que OR se dirige al segundo operando buscando un valor verdadero.
-3. El segundo operando `2` es un valor verdadero, por lo que se detiene la ejecución, se retorna `2` y es mostrado por el alert exterior.
+1. El primer OR `||` comienza evaluando el operando de la izquierda `alert(1)`. Este alert muestra el primer mensaje con `1`.
+2. Ese mismo `alert` retorna `undefined`, por lo que OR se dirige al segundo operando buscando un valor truthy.
+3. El segundo operando `2` es un valor truthy, por lo que el OR detiene su ejecución y retorna el 2. Este 2 es luego mostrado por el alert exterior.
 
-No habrá `3` debido a que la evaluación no alcanza a `alert(3)`.
+No habrá `3` debido a que la evaluación nunca alcanza a `alert(3)`.

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

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

1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md

@@ -4,6 +4,6 @@ La respuesta: `1` y después `undefined`.
 alert( alert(1) && alert(2) );
 ```
 
-La llamada a `alert` retorna `undefined` (solo muestra un mensaje, así que no hay un valor que retornar relevante)
+Una llamada a `alert` siempre retorna `undefined` (solo muestra un mensaje, no tiene un valor relevante que retornar)
 
-Debido a ello, `&&` evalúa el operando de la izquierda (imprime `1`) e inmediatamente se detiene porque `undefined` es un valor falso. Como `&&` busca un valor falso y lo retorna, terminamos.
+Debido a ello, `&&` evalúa el operando de la izquierda (el cual imprime `1`) e inmediatamente se detiene porque `undefined` es falsy. Como `&&` busca un valor falsy, lo retorna y termina.