Tipos de Datos
En JavaScript, cada valor pertenece a un tipo de dato específico. Por ejemplo, puede ser un número o una cadena de texto.
Hay ocho tipos de datos fundamentales en JavaScript. En este capítulo, proporcionaremos una visión general de cada uno y los abordaremos en detalle en los siguientes capítulos.
Podemos asignar un valor de cualquier tipo a una variable. Por ejemplo, una variable puede contener una cadena en un momento y luego almacenar un número:
// esto no produce un error
let mensaje = "hola";
mensaje = 123456;
Los lenguajes de programación que permiten esta flexibilidad, como JavaScript, se denominan «tipados dinámicamente», lo que significa que hay tipos de datos, pero las variables no están rígidamente asociadas a un tipo específico.
let n = 123;
n = 12.345;
El tipo number representa tanto números enteros como de punto flotante.
Hay muchas operaciones que se pueden realizar con números. Por ejemplo, multiplicación (*), división (/), suma (+), resta (-), entre otras.
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 y NaN.
Infinity representa el infinito matemático ∞. Es un valor especial que es mayor que cualquier otro número.
Podemos obtener Infinity como resultado de dividir un número por cero:
alert( 1 / 0 ); // Infinity
O simplemente referirnos a él directamente:
alert( Infinity ); // Infinity
NaN representa un error de cálculo. Es el resultado de una operación matemática incorrecta o indefinida, por ejemplo:
alert( "no es un número" / 2 ); // NaN, esa división es incorrecta
NaN es “pegajoso”. Cualquier operación con NaN resulta en NaN:
alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "no es un número" / 2 - 1 ); // NaN
Por lo tanto, si NaN aparece en alguna parte de una expresión matemática, se propagará a todo el resultado (con una única excepción: NaN ** 0 es 1).
Operaciones Matemáticas Seguras
Hacer matemáticas en JavaScript es “seguro”. Podemos realizar cualquier operación: dividir por cero, tratar cadenas no numéricas como números, etc.
El script nunca se detendrá con un error fatal. En el peor de los casos, obtendremos NaN como resultado.
Los valores numéricos especiales pertenecen formalmente al tipo “number”. Por supuesto, no son números en el sentido estricto de la palabra.
BigInt
En JavaScript, el tipo number no puede representar de manera precisa valores enteros mayores que 253−12^{53}-1 (es decir, 9007199254740991), o menores que −253−1-2^{53}-1.
Para ser precisos, el tipo de dato number puede almacenar enteros muy grandes (hasta 1.7976931348623157×103081.7976931348623157 \times 10^{308}), pero fuera del rango de enteros seguros ±(253−1)\pm(2^{53}-1), habrá un error de precisión.
Por ejemplo, estos dos números (justo por encima del rango seguro) son iguales:
console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992
Para la mayoría de los propósitos, el rango ±(253−1)\pm(2^{53}-1) es suficiente, pero a veces necesitamos números realmente grandes, por ejemplo, para criptografía o marcas de tiempo de alta precisión.
BigInt se agregó recientemente al lenguaje para representar enteros de longitud arbitraria.
Un valor BigInt se crea agregando una n al final de un número entero:
// la "n" al final significa que es un BigInt
const bigInt = 1234567890123456789012345678901234567890n;
Como los números BigInt rara vez se necesitan, no los cubrimos aquí sino que les dedicamos un capítulo separado. Léelo cuando necesites trabajar con números tan grandes.
Problemas de Compatibilidad
En este momento, BigInt es soportado por Firefox, Chrome, Edge y Safari, pero no por IE.
Puedes revisar la tabla de compatibilidad de BigInt en MDN para saber qué versiones de navegador tienen soporte.
String
Un string en JavaScript es una cadena de caracteres y debe colocarse entre comillas.
let str = "Hola";
let str2 = 'Las comillas simples también están bien';
let phrase = `se puede incrustar otro ${str}`;
En JavaScript, hay 3 tipos de comillas.
- Comillas dobles:
"Hola". - Comillas simples:
'Hola'. - Backticks (comillas invertidas):
`Hola`.
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:
let name = "John";
// incrustar una variable
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.
Toma en cuenta que esto sólo se puede hacer con los backticks. ¡Las otras comillas no tienen esta capacidad de incrustación!
alert( "el resultado es ${1 + 2}" ); // el resultado es ${1 + 2} (las comillas dobles no hacen nada)
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. Un string puede estar formado por un solo carácter, por ninguno, o por varios de ellos.
Boolean (Tipo Lógico)
El tipo boolean tiene sólo dos valores posibles: true y false.
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:
let nameFieldChecked = true; // sí, el campo name está marcado
let ageFieldChecked = false; // no, el campo age no está marcado
Los valores booleanos también son el resultado de comparaciones:
let isGreater = 4 > 1;
alert( isGreater ); // true (el resultado de la comparación es "sí")
El Valor null (Nulo)
El valor especial null no pertenece a ninguno de los tipos descritos anteriormente.
Forma un tipo propio separado que contiene sólo el valor null:
let age = null;
En JavaScript, null no es una “referencia a un objeto inexistente” o un “puntero nulo” como en otros lenguajes.
Es sólo un valor especial que representa “nada”, “vacío” o “valor desconocido”.
El código anterior indica que el valor de age es desconocido o está vacío por alguna razón.
El Valor undefined (Indefinido)
El valor especial undefined también se distingue. Forma un tipo propio, igual que null.
El significado de undefined es “valor no asignado”.
Si una variable es declarada, pero no asignada, entonces su valor es undefined:
let age;
alert(age); // muestra "undefined"
Técnicamente, es posible asignar undefined a cualquier variable:
let age = 100;
// cambiando el valor a undefined
age = undefined;
alert(age); // "undefined"
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.
Object y Symbol
El tipo object 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.
Siendo así de importantes, los objetos merecen un trato especial. Nos ocuparemos de ellos más adelante en el capítulo sobre Objetos después de aprender más sobre los primitivos.
El tipo symbol se utiliza para crear identificadores únicos para los objetos. Tenemos que mencionarlo aquí para mayor integridad, pero es mejor estudiar este tipo después de los objetos.
El Operador typeof
El operador typeof devuelve el tipo de dato del operando. Es útil cuando queremos procesar valores de diferentes tipos de forma diferente o simplemente queremos hacer una comprobación rápida.
La llamada a typeof x devuelve una cadena con el nombre del tipo:
typeof undefined // "undefined"
typeof 0 // "number"
typeof 10n // "bigint"
typeof true // "boolean"
typeof "foo" // "string"
typeof Symbol("id") // "symbol"
typeof Math // "object" (1)
typeof null // "object" (2)
typeof alert // "function" (3)
Las últimas tres líneas pueden necesitar una explicación adicional:
Mathes un objeto incorporado que proporciona operaciones matemáticas. Lo aprenderemos en el capítulo sobre Números. Aquí sólo sirve como ejemplo de un objeto.- El resultado de
typeof nulles"object". Esto está oficialmente reconocido como un error de comportamiento detypeofque proviene de los primeros días de JavaScript y se mantiene por compatibilidad. Definitivamente,nullno es un objeto. Es un valor especial con un tipo propio separado. - El resultado de
typeof alertes"function"porquealertes 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 tipoobject. Perotypeoflas trata de manera diferente, devolviendo"function". Este comportamiento proviene de los primeros días de JavaScript. Técnicamente, es incorrecto, pero puede ser conveniente en la práctica.
Sintaxis de typeof(x)
Se puede encontrar otra sintaxis en algún código: typeof(x). Es lo mismo que typeof x.
Para aclarar: typeof es un operador, no una función. Los paréntesis aquí no son parte del operador typeof. Son del tipo usado en agrupamiento matemático.
Usualmente, tales paréntesis contienen expresiones matemáticas tales como (2 + 2), pero aquí solo tienen un argumento (x). Sintácticamente, permiten evitar el espacio entre el operador typeof y su argumento, y a algunas personas les gusta así.
Algunos prefieren typeof(x), aunque la sintaxis typeof x es mucho más común.
Resumen
Hay 8 tipos básicos en JavaScript:
Siete tipos de datos primitivos
- number para números de cualquier tipo: enteros o de punto flotante. Los enteros están limitados por ±(253−1)\pm(2^{53}-1).
- 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.
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.
- Dos formas:
typeof xotypeof(x). - Devuelve una cadena con el nombre del tipo. Por ejemplo
"string". - Para
nulldevuelve"object". Esto es un error en el lenguaje, en realidad no es un objeto.
