Merge pull request #391 from maksumi/types

Data types

Author: joaquinelio

1-js/02-first-steps/05-types/1-string-quotes/solution.md

@@ -1,5 +1,5 @@
 
-Los "backticks" incrustan la expresión dentro de `${...}` en la cadena.
+Los backticks incrustan la expresión dentro de `${...}` en la cadena.
 
 ```js run
 let name = "Ilya";
@@ -10,6 +10,6 @@ alert( `hola ${1}` ); // hola 1
 // la expresión es una cadena "nombre"
 alert( `hola ${"name"}` ); // hola name
 
-// la expresión es una variable, incrustarla
+// la expresión es una variable, incrustada
 alert( `hola ${name}` ); // hola Ilya
 ```

1-js/02-first-steps/05-types/1-string-quotes/task.md

@@ -4,14 +4,14 @@ importance: 5
 
 # Comillas
 
-Cuál es la salida del script?
+¿Cuál es la salida del script?
 
 ```js
 let name = "Ilya";
 
-alert( `hola ${1}` ); // ?
+alert( `Hola ${1}` ); // ?
 
-alert( `hola ${"name"}` ); // ?
+alert( `Hola ${"name"}` ); // ?
 
-alert( `hola ${name}` ); // ?
+alert( `Hola ${name}` ); // ?
 ```

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

@@ -1,31 +1,31 @@
 # Tipos de datos
 
-Un valor en JavaScript siempre es de cierto tipo. Por ejemplo, un string(cadena de caracteres) o un número.
+Un valor en JavaScript siempre pertenece a un tipo determinado. Por ejemplo, un string o un número.
 
-Hay ocho tipos de datos básicos en JavaScript. Aquí, los cubriremos en general y en los próximos capítulos hablaremos de cada uno de ellos en detalle.
+Hay ocho tipos básicos de datos en JavaScript. Aquí los cubriremos en general y en los próximos capítulos hablaremos de cada uno de ellos en detalle.
 
-Podemos poner cualquier tipo en una variable. Por ejemplo, una variable puede en un momento ser un string y luego almacenar un número:
+Podemos poner cualquier tipo dentro de una variable. Por ejemplo, una variable puede ser en un momento un string y luego almacenar un número:
 
 ```js
 // no hay error
 let message = "hola";
 message = 123456;
 ```
 
-Los lenguajes de programación que permiten estas cosas se denominan "dinámicamente tipeados", lo que significa que hay tipos de datos, pero las variables no están vinculadas a ninguno de ellos.
+Los lenguajes de programación que permiten estas cosas, como JavaScript, se denominan "dinámicamente tipados", lo que significa que allí hay tipos de datos, pero las variables no están vinculadas rígidamente a ninguno de ellos.
 
-## Un number
 
+## Número
 ```js
 let n = 123;
 n = 12.345;
 ```
 
-El tipo *number* (número) representa tanto números enteros como de punto flotante.
+El tipo *number* representa tanto números enteros como de punto flotante.
 
-Hay muchas operaciones para números, por ejemplo, multiplicación `*`, división `/`, suma `+`, resta `-`, y demás.
+Hay muchas operaciones para números. Por ejemplo, multiplicación `*`, división `/`, suma `+`, resta `-`, y demás.
 
-Además de los números comunes, existen los llamados "valores numéricos especiales" que también pertenecen a este tipo de dato: `Infinity`, `-Infinity` and `NaN`.
+Además de los números comunes, existen los llamados "valores numéricos especiales" que también pertenecen a este tipo de datos: `Infinity`, `-Infinity` y `NaN`.
 
 - `Infinity` representa el [Infinito](https://es.wikipedia.org/wiki/Infinito) matemático ∞. Es un valor especial que es mayor que cualquier número.
 
@@ -35,7 +35,7 @@ Además de los números comunes, existen los llamados "valores numéricos especi
     alert( 1 / 0 ); // Infinito
     ```
 
-    O simplemente hacer referencia a ello directamente:
+    O simplemente hacer referencia a él directamente:
 
     ```js run
     alert( Infinity ); // Infinito
@@ -66,9 +66,9 @@ Veremos más sobre el trabajo con números en el capítulo <info:number>.
 
 ## BigInt
 
-En JavaScript, el tipo "número" no puede representar valores enteros mayores que <code>(2<sup>53</sup>-1)</code> (eso es `9007199254740991`), o menor que <code>-(2<sup>53</sup>-1)</code> para negativos. Es una limitación técnica causada por su representación interna.
+En JavaScript, el tipo "number" no puede representar valores enteros mayores que <code>(2<sup>53</sup>-1)</code> (eso es `9007199254740991`), o menor que <code>-(2<sup>53</sup>-1)</code> para negativos. Es una limitación técnica causada por su representación interna.
 
-Para la mayoría de los propósitos es suficiente pero a veces necesitamos números realmente grandes, por ejemplo para criptografía o marcas de tiempo de precisión de microsegundos.
+Para la mayoría de los propósitos es suficiente, pero a veces necesitamos números realmente grandes. Por ejemplo, para criptografía o marcas de tiempo de precisión de microsegundos.
 
 `BigInt` se agregó recientemente al lenguaje para representar enteros de longitud arbitraria.
 
@@ -79,48 +79,48 @@ Un valor `BigInt` se crea agregando `n` al final de un entero:
 const bigInt = 1234567890123456789012345678901234567890n;
 ```
 
-Como los números `BigInt` rara vez se necesitan, no los cubrimos aquí, sino que les dedicamos un capítulo separado <info: bigint>. Léalo cuando necesite números tan grandes.
+Como los números `BigInt` rara vez se necesitan, no los cubrimos aquí sino que les dedicamos un capítulo separado <info: bigint>. Léelo cuando necesites números tan grandes.
+
 
 
 ```smart header="Problemas de compatibilidad"
-En este momento, `BigInt` es compatible con Firefox/Chrome/Edge/Safari pero no con IE.
+En este momento, `BigInt` es compatible con Firefox / Chrome / Edge / Safari, pero no con IE.
 ```
 
-Puedes revissar la [tabla de compatibilidad BigInt de *MDN*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) para conocer las versiones de navegadores soportadas.
-
-## Un string
+Puedes revisar la [tabla de compatibilidad de BigInt en *MDN*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) para saber qué versiones de navegador tienen soporte.
 
-Un string (cadena de caracteres) en JavaScript debe estar encerrado entre comillas.
+## String
+Un string (cadena de caracteres) en JavaScript debe colocarse entre comillas.
 
 ```js
 let str = "Hola";
 let str2 = 'Las comillas simples también están bien';
-let phrase = `puede incrustar ${str}`;
+let phrase = `se puede incrustar otro ${str}`;
 ```
 
 En JavaScript, hay 3 tipos de comillas.
 
 1. Comillas dobles: `"Hola"`.
 2. Comillas simples: `'Hola'`.
-3. Backticks (acento grave): <code>&#96;Hola&#96;</code>.
+3. Backticks (comillas invertidas): <code>&#96;Hola&#96;</code>.
 
-Las comillas dobles y simples son comillas "simples". No hay diferencia entre ellas en JavaScript.
+Las comillas dobles y simples son comillas "sencillas" (es decir, funcionan igual). No hay diferencia entre ellas en JavaScript.
 
-Los Backticks son comillas de "funcionalidad extendida". Nos permiten incrustar variables y expresiones en una cadena de caracteres encerrándolas en `${...}`, por ejemplo:
+Los backticks son comillas de "funcionalidad extendida". Nos permiten incrustar variables y expresiones en una cadena de caracteres encerrándolas en `${...}`, por ejemplo:
 
 ```js run
-let name = "Juan";
+let name = "John";
 
 // incrustar una variable
-alert( `Hola, *!*${name}*/!*!` ); // Hola, Juan!
+alert( `Hola, *!*${name}*/!*!` ); // Hola, John!
 
 // incrustar una expresión
 alert( `el resultado es *!*${1 + 2}*/!*` ); //el resultado es 3
 ```
 
 La expresión dentro de `${...}` se evalúa y el resultado pasa a formar parte de la cadena. Podemos poner cualquier cosa ahí dentro: una variable como `name`, una expresión aritmética como `1 + 2`, o algo más complejo.
 
-Tenga en cuenta que esto sólo se puede hacer en los "backticks". ¡Otras comillas no tienen esta capacidad de incrustación!
+Toma en cuenta que esto sólo se puede hacer con los backticks. ¡Las otras comillas no tienen esta capacidad de incrustación!
 ```js run
 alert( "el resultado es ${1 + 2}" ); // el resultado es ${1 + 2} (las comillas dobles no hacen nada)
 ```
@@ -129,15 +129,14 @@ En el capítulo <info:string> trataremos más a fondo las cadenas.
 
 ```smart header="No existe el tipo *carácter*".
 En algunos lenguajes, hay un tipo especial "carácter" para un solo carácter. Por ejemplo, en el lenguaje C y en Java es `char`.
-
-En JavaScript no existe tal tipo. Sólo hay un tipo: `string`. Una cadena puede estar formada por cero caracteres (estar vacía), un carácter o por varios de ellos.
+En JavaScript no existe tal tipo. Sólo hay un tipo: `string`. Un string puede estar formado por un solo carácter o por varios de ellos.
 ```
 
-## Un boolean (tipo lógico)
+## Booleano (tipo lógico)
 
-El tipo boolean (booleano) tiene sólo dos valores: verdadero `true` y falso `false`.
+El tipo booleano tiene sólo dos valores: `true` y `false`.
 
-Este tipo se utiliza comúnmente para almacenar valores de sí/no: `true` significa "sí, correcto", y `false` significa "no, incorrecto".
+Este tipo se utiliza comúnmente para almacenar valores de sí/no: `true` significa "sí, correcto, verdadero", y `false` significa "no, incorrecto, falso".
 
 Por ejemplo:
 
@@ -170,7 +169,7 @@ En JavaScript, `null` no es una "referencia a un objeto inexistente" o un "punte
 
 Es sólo un valor especial que representa "nada", "vacío" o "valor desconocido".
 
-El código anterior indica que la "edad" es desconocida o está vacía por alguna razón.
+El código anterior indica que el valor de `age` es desconocido o está vacío por alguna razón.
 
 ## El valor "undefined" (indefinido)
 
@@ -181,33 +180,33 @@ El significado de `undefined` es "valor no asignado".
 Si una variable es declarada pero no asignada, entonces su valor es `undefined`:
 
 ```js run
-let x;
+let age;
 
-alert(x); // muestra "undefined"
+alert(age); // muestra "undefined"
 ```
 
 Técnicamente, es posible asignar `undefined` a cualquier variable:
 
 ```js run
-let edad = 100;
+let age = 100;
 
-// cambia el valor a undefined
-edad = undefined;
+// cambiando el valor a undefined
+age = undefined;
 
-alert(x); // "undefined"
+alert(age); // "undefined"
 ```
 
-...Pero no recomendamos hacer eso. Normalmente, usamos `null` para asignar un valor "vacío" o "desconocido" a una variable, y usamos `undefined` para chequeos como ver si una variable ha sido asignada.
+...Pero no recomendamos hacer eso. Normalmente, usamos `null` para asignar un valor "vacío" o "desconocido" a una variable, mientras `undefined` es un valor inicial reservado para cosas que no han sido asignadas.
 
-## Objects y symbols
+## Objetos y símbolos
 
 El tipo `object` (objeto) es especial.
 
-Todos los demás tipos se llaman "primitivos" porque sus valores pueden contener una sola cosa (ya sea una cadena,  un número o lo que sea). Por el contrario, los objetos se utilizan para almacenar colecciones de datos y entidades más complejas.
+Todos los demás tipos se llaman "primitivos" porque sus valores pueden contener una sola cosa (ya sea una cadena,  un número o lo que sea). Por el contrario, los objetos se utilizan para almacenar colecciones de datos y entidades más complejas. 
 
-Siendo tan importantes, los objetos merecen un tratamiento especial. Nos ocuparemos de ellos más adelante en el capítulo <info:object> después de aprender más sobre los primitivos.
+Siendo así de importantes, los objetos merecen un trato especial. Nos ocuparemos de ellos más adelante en el capítulo <info:object> después de aprender más sobre los primitivos.
 
-El tipo `symbol` (símbolo) se utiliza para crear identificadores únicos para los objetos. Tenemos que mencionarlo aquí para una mayor completitud, pero es mejor estudiar este tipo después de los objetos.
+El tipo `symbol` (símbolo) se utiliza para crear identificadores únicos para los objetos. Tenemos que mencionarlo aquí para una mayor integridad, pero es mejor estudiar este tipo después de los objetos.
 
 ## El operador typeof [#type-typeof]
 
@@ -223,17 +222,17 @@ En otras palabras, funciona con paréntesis o sin ellos. El resultado es el mism
 La llamada a `typeof x` devuelve una cadena con el nombre del tipo:
 
 ```js
-typeof undefined // "undefined" (indefinido)
+typeof undefined // "undefined"
 
-typeof 0 // "number" (número)
+typeof 0 // "number"
 
 typeof 10n // "bigint"
 
-typeof true // "boolean" (booleano)
+typeof true // "boolean"
 
-typeof "foo" // "string" (cadena)
+typeof "foo" // "string"
 
-typeof Symbol("id") // "symbol" (símbolo)
+typeof Symbol("id") // "symbol"
 
 *!*
 typeof Math // "object"  (1)
@@ -250,15 +249,15 @@ typeof alert // "function"  (3)
 
 Las últimas tres líneas pueden necesitar una explicación adicional:
 
-1. `Math` es un objeto incorporado (built-in) 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 es un error oficialmente reconocido de `typeof` que viene de viejos tiempos y se mantiene por cuestiones de compatibilidad. Definitivamente `null` no es un objeto. Es un valor especial con su tipo propio.
-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 también 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"`. Técnicamente esto no es correcto, pero puede ser conveniente en la práctica.
+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.
 
 ## Resumen
 
 Hay 8 tipos básicos en JavaScript.
 
-- `number` para números de cualquier tipo: enteros o en punto flotante. Los enteros están limitados a ±2<sup>53</sup>.
+- `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`.
@@ -270,7 +269,5 @@ Hay 8 tipos básicos en JavaScript.
 El operador `typeof` nos permite ver qué tipo está almacenado en una variable.
 
 - Dos formas: `typeof x` o `typeof(x)`.
-- Devuelve una cadena con el nombre del tipo, por ejemplo `"string"`.
-- Para `null` devuelve `"object"` -- esto es un error en el lenguaje, en realidad no es un objeto.
-
-En los siguientes capítulos, nos concentraremos en los valores primitivos y una vez que nos familiaricemos con ellos, pasaremos a los objetos.
+- Devuelve una cadena con el nombre del tipo. Por ejemplo `"string"`.
+- Para `null` devuelve `"object"`: esto es un error en el lenguaje, en realidad no es un objeto.