Los tipos de datos son la base fundamental para almacenar y manipular información en cualquier lenguaje de programación. En JavaScript, existen varios tipos de datos básicos que se utilizan para representar diferentes tipos de valores. A continuación veremos los tipos de datos básicos en JavaScript, junto con ejemplos para cada uno de ellos.
Números
Los números representan valores numéricos y pueden ser enteros o decimales:
let edad = 25; let temperatura = -10; let precio = 99.99; let distancia = 1000.75;
Valores booleanos
Los valores booleanos representan solo dos posibles estados: true (verdadero) o false (falso).
let esMayor = true; let esMenor = false; let validado = true; let habilitado = false;
Como veremos en otra unidad, los valores booleanos son útiles para realizar comparaciones y tomar decisiones en el flujo de un programa.
Cadenas de texto
Cadenas de texto simples
Las cadenas de texto representan una secuencia de caracteres y se utilizan para almacenar información textual. En su forma más básica pueden crearse utilizando comillas dobles (") o comillas simples ('):
let nombre = "Juan"; let mensaje = 'Hola, ¿cómo estás?'; let direccion = "Calle 123, Ciudad";
Plantillas de cadenas
La interpolación en JavaScript es una técnica que permite combinar valores y cadenas de texto de una manera más clara y legible. Es una forma conveniente de construir cadenas de texto que incluyan variables y expresiones dentro de ellas. La interpolación se realiza utilizando plantillas de cadenas, también conocidas como «template literals».
Para crear una plantilla de cadena, se utilizan las comillas invertidas (backticks `) en lugar de las comillas simples o dobles que se utilizan para crear cadenas de texto regulares. Dentro de una plantilla de cadena, se pueden incluir expresiones dentro de llaves `${...}`. Cuando la plantilla se evalúa, las expresiones dentro de las llaves se resuelven y se insertan en la cadena final.
En el siguiente ejemplo utilizamos una plantilla de cadena con interpolación para crear la variable mensaje, que incluye las variables nombre y edad dentro de la cadena. Las expresiones ${nombre} y ${edad} se evalúan y se reemplazan con los valores de las variables correspondientes al momento de la creación de la cadena:
// Variables
let nombre = "Juan";
let edad = 25;
// Plantilla de cadena con interpolación
let mensaje = `Hola, mi nombre es ${nombre} y tengo ${edad} años.`;
console.log(mensaje);
// Salida: "Hola, mi nombre es Juan y tengo 25 años."
La interpolación también es útil para realizar cálculos dentro de las plantillas de cadenas:
let a = 5;
let b = 3;
// Plantilla de cadena con interpolación y cálculo
let resultado = `La suma de ${a} y ${b} es igual a ${a + b}.`;
console.log(resultado);
// Salida: "La suma de 5 y 3 es igual a 8."
Además de las variables y expresiones, también podemos incluir cualquier contenido de cadena dentro de las plantillas, e incluso podemos definir la plantilla en varias líneas:
let producto = "manzana";
let cantidad = 3;
let precio = 2.5;
// Plantilla de cadena con contenido adicional
let factura = `
Producto: ${producto}
Cantidad: ${cantidad}
Precio unitario: €${precio}
Total: €${cantidad * precio}
`;
console.log(factura);
/* Salida:
Producto: manzana
Cantidad: 3
Precio unitario: €2.5
Total: €7.5
*/
La interpolación a través de plantillas de cadenas hace que el código sea más legible, más mantenible y menos propenso a errores de concatenación de cadenas. Además, facilita la inclusión de valores dinámicos en las cadenas, lo que es especialmente útil cuando se construyen mensajes personalizados o se generan resultados basados en datos variables.
Es importante destacar que las plantillas de cadenas solo están disponibles a partir de ECMAScript 6 (ES6) y versiones posteriores de JavaScript. Si estás utilizando una versión anterior, es posible que necesites utilizar concatenación de cadenas o métodos como String.prototype.concat() para lograr resultados similares.
Valores "null" y "undefined"
Las palabras clave null y undefined son valores especiales que representan la ausencia de valor:
nullse utiliza cuando una variable está intencionalmente vacía o cuando queremos establecer un valor nulo.undefinedse utiliza cuando una variable ha sido declarada pero no se le ha asignado ningún valor.
let valor1 = null; let valor2 = undefined; let edad; // esta variable es undefined ya que no se le ha asignado ningún valor
Conversión de tipos de datos
Las conversiones de tipos de datos son procesos en los que JavaScript cambia temporalmente el tipo de un valor para que pueda ser utilizado en una operación específica. JavaScript realiza conversiones implícitas (o automáticas) y explícitas de tipos de datos para facilitar la manipulación de valores en diferentes situaciones.
Conversiones implícitas o automáticas
JavaScript utiliza conversiones automáticas cuando intentamos realizar operaciones entre diferentes tipos de datos. Esto sucede de forma transparente, sin que el programador tenga que hacer nada explícitamente.
Conversión automática de números a cadenas de texto
En los siguientes ejemplos, la conversión automática de números a cadenas de texto ocurre cuando utilizamos el operador de concatenación (+) para combinar valores numéricos con cadenas de texto. Cuando se realiza una operación aritmética que involucra una cadena de texto y un número, JavaScript convierte automáticamente el número en una cadena de texto para que pueda concatenarse con la otra cadena:
// Conversión automática de números a cadenas de texto en concatenaciones let num1 = 10; let num2 = 3.14; let concatenacion1 = "El número es: " + num1; // "El número es: 10" let concatenacion2 = "El valor de PI es: " + num2; // "El valor de PI es: 3.14" // Conversión automática de números a cadenas de texto en operaciones aritméticas let a = 5; let b = 2; let resultado1 = "La suma es: " + (a + b); // "La suma es: 7" let resultado2 = "El producto es: " + (a * b); // "El producto es: 10"
Es importante tener en cuenta que la conversión automática de números a cadenas de texto solo ocurre cuando se utilizan operadores de concatenación. Si utilizamos operadores aritméticos entre números y cadenas de texto, JavaScript tratará de realizar la operación matemática en lugar de convertir los números en cadenas de texto:
let num = 42; let texto = "El número es: " + num; // "El número es: 42" let suma = num + 5; // 47, porque es una operación aritmética let resultado = "El resultado es: " + (num + 5); // "El resultado es: 47"
Recuerda que, aunque JavaScript realiza la conversión automática de números a cadenas de texto, es recomendable utilizar la interpolación de cadenas con plantillas (${...}) cuando sea posible, ya que hace que el código sea más legible y evita confusiones con el uso de operadores de concatenación. La interpolación de cadenas es una característica introducida en ECMAScript 6 y ofrece una forma más clara y sencilla de incluir valores dentro de cadenas de texto.
Conversión automática de cadenas de texto a números
En el siguiente ejemplo, JavaScript convierte automáticamente las cadenas "5" y "2" en valores numéricos antes de realizar la resta. Como resultado, obtenemos el número 3:
let a = "5"; let b = "2"; let resultado = a - b; console.log(resultado); // Salida: 3
Conversión automática de valores booleanos a valores numéricos
En el siguiente ejemplo, JavaScript convierte automáticamente los valores booleanos true y false a valores numéricos (1 y 0, respectivamente) antes de realizar la suma. Esta conversión automática ocurre porque en una operación aritmética, JavaScript espera valores numéricos, y los valores booleanos se convierten implícitamente a números para que la operación sea válida:
let verdadero = true; // 1 let falso = false; // 0 let sumaBooleanos = verdadero + falso; console.log(sumaBooleanos); // Salida:
Conversión automática de booleanos a cadenas de texto
Cuando utiliza el operador de concatenación + para combinar un valor booleano con una cadena de texto, JavaScript realiza una conversión automática del valor booleano a su representación en forma de cadena de texto. Los valores booleanos true y false se convierten en las cadenas de texto "true" y "false", respectivamente. En el siguiente ejemplo, las variables esVerdadero y esFalso son valores booleanos. Cuando los concatenamos con cadenas de texto utilizando el operador +, JavaScript realiza la conversión automática de estos valores booleanos a sus representaciones de cadena de texto correspondientes:
let esVerdadero = true; let esFalso = false; let cadena1 = "El valor es: " + esVerdadero; let cadena2 = "El resultado es: " + esFalso; console.log(cadena1); // Salida: "El valor es: true" console.log(cadena2); // Salida: "El resultado es: false"
Podemos utilizar también la conversión automática de booleanos a cadenas de texto para construir mensajes que contengan condicionales. En el siguiente ejemplo creamos mensajes que informan sobre si una persona es mayor de edad o si puede ingresar a algún lugar.
let edad = 17; let mensaje1 = "¿Puede trabajar? " + (edad >= 16); let mensaje2 = "¿Es mayor de edad? " + (edad >= 18); console.log(mensaje1); // Salida: "¿Puede trabajar? true" console.log(mensaje2); // Salida: "¿Es mayor de edad? false"
Ten en cuenta que, aunque la conversión automática de booleanos a cadenas de texto es útil en ciertas situaciones, es recomendable ser explícito cuando sea necesario para mejorar la legibilidad del código. Si deseas asegurarte de que la representación en forma de cadena de texto sea más específica, puedes utilizar funciones como toString() o plantillas de cadenas para lograr un resultado más claro:
let esVerdadero = true;
let cadena1 = "Es verdadero: " + esVerdadero.toString();
let cadena2 = `Es falso: ${false}`;
console.log(cadena1); // Salida: "Es verdadero: true"
console.log(cadena2); // Salida: "Es falso: false"
Conversiones explícitas
La conversión explícita de tipos de datos ocurre cuando el programador decide cambiar manualmente el tipo de un valor a otro tipo específico. JavaScript proporciona varias funciones y métodos que permiten realizar estas conversiones explícitas.
Conversión explícita de números a cadenas de texto
En el siguiente ejemplo convertimos números en cadenas de texto utilizando la función String() y también mediante la concatenación con una cadena vacía. Ambos enfoques producen el mismo resultado:
let numero1 = 42; let numero2 = 3.14; // Utilizando la función String() let textoNumero1 = String(numero1); // "42" let textoNumero2 = String(numero2); // "3.14" // Utilizando concatenación con una cadena vacía let textoNumero3 = numero1 + ""; // "42" let textoNumero4 = "" + numero2; // "3.14"
Conversión explícita de cadenas de texto a números
En el siguiente ejemplo realizamos conversiones explícitas de cadenas de texto a números utilizando la función Number() y el operador unario +. También vemos que al intentar convertir una cadena de texto no numérica, obtenemos NaN:
let textoNumero1 = "123"; let textoNumero2 = "3.14"; let textoNoNumerico = "hola"; // Utilizando la función Number() let numero1 = Number(textoNumero1); // 123 (número entero) let numero2 = Number(textoNumero2); // 3.14 (número decimal) let noEsNumero = Number(textoNoNumerico); // NaN (no es un número) // Utilizando el operador unario + let numero3 = +textoNumero1; // 123 (número entero) let numero4 = +textoNumero2; // 3.14 (número decimal) let numero5 = +textoNoNumerico; // NaN (no es un número)
Debemos destacar que la función Number() es muy flexible y puede manejar una amplia variedad de tipos de datos, y sólo devolverá NaN si no puede realizar la conversión:
Number("42"); // 42
Number("3.14"); // 3.14
Number("123abc"); // NaN (caracteres no numéricos)
Number("hello"); // NaN (cadena no numérica)
Number(true); // 1
Number(false); // 0
Number(null); // 0
Number(undefined); // NaN
Podemos utilizar además las funciones parseInt() y parseFloat() para convertir una cadena de texto en un número entero o decimal respectivamente:
let cadena1 = "123"; let cadena2 = "3.14"; let cadena3 = "Hola123"; let cadena4 = "123Hola"; let numero1 = parseInt(cadena1); // 123 (número entero) let numero2 = parseInt(cadena2); // 3 (solo se toma la parte entera) let numero3 = parseInt(cadena3); // 123 (comienza con un número) let numero4 = parseInt(cadena4); // NaN (no comienza con un número) let cadena5 = "3.14"; let cadena6 = "0.12345"; let cadena7 = "3.14Hola"; let cadena8 = "Hola3.14"; let numero5 = parseFloat(cadena5); // 3.14 (número decimal) let numero6 = parseFloat(cadena6); // 0.12345 let numero7 = parseFloat(cadena7); // 3.14 (comienza con un número) let numero8 = parseFloat(cadena8); // NaN (no comienza con un número)
Consideraciones adicionales sobre la función Number():
- No se limita únicamente a conversiones de enteros o decimales, ya que también permite convertir booleanos, nulos o valores no definidos.
- Genera
NaNsi encuentra cualquier carácter no numérico en una cadena de texto, aunque esté al final (por ejemplo, «123abc»).
Consideraciones adicionales sobre las funciones parseInt() y parseFloat():
- Intentarán convertir la parte numérica inicial de la cadena y detendrán la conversión cuando encuentren un carácter no numérico.
- Si la cadena comienza con un espacio en blanco, también lo ignorarán y comenzarán la conversión desde el primer dígito numérico.
- Solo convierten la parte inicial numérica de la cadena. Si hay caracteres numéricos después de caracteres no numéricos (por ejemplo, «123abc»), solo se tomará la parte inicial numérica («123» en este caso).
- Si la cadena no contiene ningún dígito numérico, devolverán
NaN.
Conversión explícita de cadenas de texto a booleanos
En el siguiente ejemplo convertimos cadenas de texto en valores booleanos utilizando la función Boolean() y también mediante comparaciones estrictas (===). Es importante destacar que cualquier cadena no vacía se evalúa como true al utilizar la función Boolean():
let cadenaVerdadera = "true"; let cadenaFalsa = "false"; let cadenaNoValida = "hola"; // Utilizando la función Boolean() let booleano1 = Boolean(cadenaVerdadera); // true let booleano2 = Boolean(cadenaFalsa); // false let booleano3 = Boolean(cadenaNoValida); // true (cualquier cadena no vacía se evalúa como true) // Utilizando comparación estricta (===) let booleano4 = (cadenaVerdadera === "true"); // true let booleano5 = (cadenaFalsa === "true"); // false
Conversión explícita de booleanos a cadenas de texto
En el siguiente ejemplo utilizamos las funciones String() y toString() para convertir los valores booleanos true y false en sus representaciones en forma de cadena de texto. Ambos enfoques producen el mismo resultado:
let esVerdadero = true; let esFalso = false; // Utilizando la función String() let cadena1 = String(esVerdadero); // "true" let cadena2 = String(esFalso); // "false" // Utilizando el método toString() let cadena3 = esVerdadero.toString(); // "true" let cadena4 = esFalso.toString(); // "false"
Conversión explícita de valores no booleanos a valores booleanos
En este caso, utilizamos la función Boolean() y además el doble operador de negación (!!) para obtener los valores booleanos de cada una de las variables:
let valor1 = ""; // valor falso let valor2 = 0; // valor falso let valor3 = null; // valor falso let valor4; // valor undefined, también falso let valor5 = NaN; // valor falso let valor6 = 25; // valor verdadero let valor7 = "Hola"; // valor verdadero let booleano1 = Boolean(valor1); // false let booleano2 = Boolean(valor2); // false let booleano3 = Boolean(valor3); // false let booleano4 = Boolean(valor4); // false let booleano5 = Boolean(valor5); // false let booleano6 = Boolean(valor6); // true let booleano7 = Boolean(valor7); // true let booleano8 = !!valor1; // false let booleano9 = !!valor2; // false let booleano10 = !!valor3; // false let booleano11 = !!valor4; // false let booleano12 = !!valor5; // false let booleano13 = !!valor6; // true let booleano14 = !!valor7; // true
Al utilizar !!, el primer operador de negación convierte el valor a su inverso booleano, y el segundo operador de negación invierte nuevamente el resultado, restaurando el valor original como valor booleano. Es decir, la doble negación convierte los valores "", 0, null, undefined y NaN en false, y por otro lado convierte 25 y "Hola" en true:
Consideraciones
Es fundamental comprender las conversiones de tipos de datos en JavaScript para escribir código robusto y evitar resultados inesperados en nuestros programas. No debemos olvidar que JavaScript es un lenguaje de tipado dinámico, lo que significa que las variables pueden cambiar su tipo de dato durante la ejecución del programa.
En general, se recomienda ser explícito en las conversiones y utilizar con mucha precaución funciones y métodos específicos para cada tipo. No olvidemos que si intentamos convertir valores que no son compatibles, como una cadena de texto no numérica a un número, obtendremos NaN como resultado. Por ejemplo, si intentamos convertir la cadena de texto "hola" en un número utilizando la función Number() o el operador unario +, no podremos obtener un valor numérico válido, y ambas conversiones devolverán NaN:
let textoNoNumerico = "hola"; // Utilizando la función Number() let numero1 = Number(textoNoNumerico); // Utilizando el operador unario + let numero2 = +textoNoNumerico; console.log(numero1); // Salida: NaN console.log(numero2); // Salida: NaN
O por ejemplo, también podemos obtener resultados inesperados si intentamos convertir una cadena de texto en un valor booleano. En este caso, como cualquier cadena no vacía se evalúa como true, si utilizamos la función Boolean() para convertir "hola" en booleano, el resultado de la conversión es true en lugar de NaN:
let textoNoNumerico = "hola"; // Utilizando la función Boolean() let booleano = Boolean(textoNoNumerico); console.log(booleano); // Salida: true (cualquier cadena no vacía se evalúa como true)
Recuerda que NaN (Not-a-Number) es un valor especial en JavaScript que representa el resultado de una operación matemática inválida o indeterminada. Se obtiene cuando intentamos realizar una operación aritmética con valores no numéricos o cuando una operación matemática no tiene un resultado definido, como por ejemplo, la división por cero. Es importante tener en cuenta estas situaciones al trabajar con conversiones explícitas para evitar obtener resultados inesperados.
Debemos considerar además que al trabajar con variables que puedan contener valores tales como una cadena vacía o null, podemos obtener resultados inesperados si intentamos realizar conversiones para obtener un valor numérico o booleano, ya que en vez de obtener NaN, dichas conversiones se realizarán sin generar ningún error:
let cadenaVacia = ""; let nulo = null; let numero1 = Number(cadenaVacia); // 0 (conversión válida) let numero2 = Number(nulo); // 0 (conversión válida) let booleano1 = Boolean(cadenaVacia); // false (cadena vacía se evalúa como false) let booleano2 = Boolean(nulo); // false (null se evalúa como false)
Test
Comprueba tus conocimientos con este test sobre tipos de datos y otros conceptos relacionados con esta unidad.