Tipos de datos en JavaScript
JavaScript es un lenguaje de programación ampliamente utilizado en el desarrollo de aplicaciones web, y comprender los tipos de datos es fundamental para escribir código eficiente y fácil de mantener.
En este artículo, exploraremos los tipos de datos disponibles en JavaScript y cómo podemos utilizarlos en nuestros proyectos de desarrollo web. Analizaremos tanto los tipos de datos primitivos como los compuestos, así como las operaciones y conversiones que se pueden realizar con ellos.
Comencemos por definir qué son los tipos de datos y por qué son importantes en la programación.
¿Qué son los tipos de datos en JavaScript?
Los tipos de datos en JavaScript son las diferentes categorías de valores que pueden ser utilizados y manipulados en un programa. En general, los lenguajes de programación utilizan diferentes tipos de datos para representar información de distintas formas, como números, texto, valores lógicos, entre otros.
JavaScript es un lenguaje de programación de tipado dinámico, lo que significa que no es necesario declarar explícitamente el tipo de dato de una variable, ya que el lenguaje lo determina automáticamente según el valor asignado.
En el desarrollo de aplicaciones con JavaScript, es fundamental entender y utilizar correctamente los tipos de datos para garantizar que nuestros programas funcionen de manera eficiente y sin errores. Además, el conocimiento de los tipos de datos nos permite mejorar la legibilidad del código y facilitar su mantenimiento.
A continuación, exploraremos los tipos de datos primitivos y compuestos en JavaScript, así como sus características y usos comunes en la programación.
Tipos de datos primitivos en JavaScript
Los tipos de datos primitivos son aquellos que no tienen propiedades ni métodos, y son inmutables. En JavaScript, existen seis tipos de datos primitivos: Number, String, Boolean, Null, Undefined y BigInt. Veamos cada uno de ellos con ejemplos.
Number
El tipo de dato Number representa tanto números enteros como decimales. También puede representar números en notación científica, Infinity (infinito) y NaN (Not a Number).
Ejemplos:
let entero = 42;
let decimal = 3.14;
let notacionCientifica = 1.23e4; // 12300
let infinito = Infinity;
let noEsNumero = NaN;
Lenguaje del código: JavaScript (javascript)String
El tipo de dato String representa cadenas de texto, que pueden ser escritas utilizando comillas simples, dobles o acentos graves (backticks). Los acentos graves permiten crear plantillas literales (template literals) que incluyen interpolación de variables y expresiones.
Ejemplos:
let comillasSimples = 'Hola, mundo!';
let comillasDobles = "Hola, mundo!";
let plantillaLiteral = `Mi número favorito es ${entero}`;
let caracteresEscape = 'Texto con \"comillas\" y salto de línea\n';
Lenguaje del código: JavaScript (javascript)Boolean
El tipo de dato Boolean representa valores lógicos, que pueden ser verdadero (true) o falso (false). Estos valores son comúnmente utilizados en operaciones lógicas y de comparación.
Ejemplos:
let esVerdadero = true;
let esFalso = false;
let mayorDeEdad = (18 >= 21); // false
Lenguaje del código: JavaScript (javascript)Null
El tipo de dato Null representa un valor nulo o vacío. Se utiliza para indicar que una variable no tiene ningún valor asignado.
Ejemplo:
let valorNulo = null;
Lenguaje del código: JavaScript (javascript)Undefined
El tipo de dato Undefined indica que una variable no ha sido asignada a ningún valor. Este es el valor por defecto de las variables que no han sido inicializadas.
Ejemplo:
let valorIndefinido;
console.log(valorIndefinido); // undefined
Lenguaje del código: JavaScript (javascript)BigInt
Es útil para representar números muy grandes que no caben en un tipo de dato “Number” y es compatible con la mayoría de las operaciones aritméticas básicas.
Sin embargo, aún no es compatible con algunas funciones como Math.floor o parseInt, por lo que es importante tener en cuenta sus limitaciones.
Se agregó en la versión ECMAScript 2020 y se puede crear añadiendo “n” al final de un número. Por ejemplo:
- Creación de un BigInt:
const bigIntValue = 123456789012345678901234567890n;
console.log(bigIntValue); // 123456789012345678901234567890n
Lenguaje del código: JavaScript (javascript)- Operaciones aritméticas con BigInt:
const firstBigInt = 123456789012345678901234567890n;
const secondBigInt = 9876543210n;
const sum = firstBigInt + secondBigInt;
console.log(sum); // 123456789012345678901244444420n
Lenguaje del código: JavaScript (javascript)- Conversiones de BigInt a Number:
const bigInt = 123456789012345678901234567890n;
const number = Number(bigInt);
console.log(number); // 12345678901234567886083863530
Lenguaje del código: JavaScript (javascript)- Conversiones de Number a BigInt:
const number = 1234567890123456000;
const bigInt = BigInt(number);
console.log(bigInt); // 1234567890123456000n
Lenguaje del código: JavaScript (javascript)Symbol
El tipo de dato Symbol representa valores únicos e inmutables que pueden ser utilizados como identificadores de propiedades en objetos.
Los símbolos se crean utilizando la función Symbol(), que opcionalmente puede recibir un argumento de tipo String para describir el símbolo.
Ejemplos:
let simbolo1 = Symbol();
let simbolo2 = Symbol('descripcion');
let simbolo3 = Symbol('descripcion');
console.log(simbolo1); // Symbol()
console.log(simbolo2); // Symbol(descripcion)
console.log(simbolo3); // Symbol(descripcion)
console.log(simbolo2 === simbolo3); // false
// Uso de símbolos como identificadores de propiedades en objetos
const objeto = {
[simbolo1]: 'valor del simbolo1'
};
console.log(objeto[simbolo1]); // valor del simbolo1
Lenguaje del código: JavaScript (javascript)Aunque simbolo2 y simbolo3 tienen la misma descripción, estos símbolos son distintos y no iguales. Los símbolos se utilizan principalmente para crear propiedades únicas en objetos y evitar colisiones de nombres, así como para definir propiedades y métodos que no deben ser accedidos de forma accidental.
Con esto, hemos cubierto todos los tipos de datos primitivos en JavaScript. A continuación, analicemos los tipos de datos compuestos y sus características.
Tipos de datos compuestos en JavaScript
Los tipos de datos compuestos, también conocidos como tipos de datos estructurados o de referencia, son aquellos que pueden contener múltiples valores y tienen propiedades y métodos. En JavaScript, los principales tipos de datos compuestos son Object, Array, Function y Date.
Object
El tipo de dato Object representa una colección de propiedades, donde cada propiedad consiste en un par clave-valor. Los objetos se crean utilizando llaves {} o el constructor new Object().
Ejemplos:
// Creación de un objeto utilizando llaves
let objeto1 = {
nombre: 'Juan',
edad: 30,
saludar: function() {
console.log(`Hola, mi nombre es ${this.nombre}`);
}
};
// Creación de un objeto utilizando el constructor
let objeto2 = new Object();
objeto2.nombre = 'Maria';
objeto2.edad = 28;
objeto2.saludar = function() {
console.log(`Hola, mi nombre es ${this.nombre}`);
};
// Acceso y modificación de propiedades de un objeto
console.log(objeto1.nombre); // Juan
objeto1.edad = 31;
console.log(objeto1.edad); // 31
// Invocar un método de un objeto
objeto1.saludar(); // Hola, mi nombre es Juan
Lenguaje del código: JavaScript (javascript)Array (arreglos)
El tipo de dato Array representa una colección ordenada de elementos, que pueden ser de cualquier tipo. Los arreglos se crean utilizando corchetes [] o el constructor new Array().
Ejemplos:
// Creación de un arreglo utilizando corchetes
let arreglo1 = [1, 2, 3, 4, 5];
// Creación de un arreglo utilizando el constructor
let arreglo2 = new Array(6, 7, 8, 9, 10);
// Acceso y modificación de elementos de un arreglo
console.log(arreglo1[0]); // 1
arreglo1[4] = 42;
console.log(arreglo1[4]); // 42
// Propiedad length y métodos comunes de arreglos
console.log(arreglo1.length); // 5
arreglo1.push(6); // Añade el elemento 6 al final del arreglo
arreglo1.pop(); // Elimina el último elemento del arreglo
Lenguaje del código: JavaScript (javascript)Function (funciones)
El tipo de dato Function es un tipo de objeto especial que representa una función, que puede ser invocada para ejecutar un bloque de código. Las funciones se crean utilizando la palabra clave function, una expresión de función o una función de flecha.
Ejemplos:
// Declaración de función
function suma(a, b) {
return a + b;
}
// Expresión de función
const resta = function(a, b) {
return a - b;
};
// Función de flecha
const multiplicacion = (a, b) => a * b;
// Invocar funciones
console.log(suma(1, 2)); // 3
console.log(resta(5, 3)); // 2
console.log(multiplicacion(2, 4)); // 8
Lenguaje del código: JavaScript (javascript)Date
El tipo de dato Date representa fechas y horas, y se crea utilizando el constructor new Date(). Este tipo de objeto tiene varios métodos para manipular y obtener información sobre fechas y horas.
Ejemplos:
// Crear un objeto Date con la fecha y hora actual
let fechaActual = new Date();
console.log(fechaActual); // Ejemplo: 2023-03-31T15:00:00.000Z
// Crear un objeto Date con una fecha y hora específica
let fechaEspecifica = new Date('2023-12-31T23:59:59.999Z');
console.log(fechaEspecifica); // 2023-12-31T23:59:59.999Z
// Obtener información sobre la fecha
console.log(fechaActual.getFullYear()); // 2023
console.log(fechaActual.getMonth()); // 2 (Enero es 0, Febrero es 1, etc.)
console.log(fechaActual.getDate()); // 31
// Obtener información sobre la hora
console.log(fechaActual.getHours()); // 15 (hora en formato 24h)
console.log(fechaActual.getMinutes()); // 0
console.log(fechaActual.getSeconds()); // 0
// Manipular la fecha y la hora
fechaActual.setFullYear(2024);
fechaActual.setMonth(11); // Diciembre (Enero es 0, Febrero es 1, etc.)
fechaActual.setDate(25);
// Calcular la diferencia entre dos fechas
let diferencia = fechaEspecifica - fechaActual; // Diferencia en milisegundos
let diasDiferencia = diferencia / (1000 * 60 * 60 * 24);
console.log(diasDiferencia); // Ejemplo: 274.3743055555556
Lenguaje del código: JavaScript (javascript)Con estos ejemplos, hemos cubierto los principales tipos de datos compuestos en JavaScript y sus características. A continuación, abordaremos las conversiones y operaciones entre diferentes tipos de datos en JavaScript.
Conversión de tipos de datos en JavaScript
En JavaScript, es común que se necesite convertir un valor de un tipo de dato a otro. Las conversiones pueden ser implícitas (realizadas automáticamente por el lenguaje) o explícitas (realizadas por el programador utilizando funciones específicas). Veamos ejemplos de ambas situaciones.
Conversiones implícitas
JavaScript realiza conversiones implícitas cuando se realizan operaciones entre diferentes tipos de datos, como en la concatenación de cadenas y números o en comparaciones.
Ejemplos:
// Conversión implícita en la concatenación de cadena y número
let numero = 42;
let texto = 'Mi número favorito es ';
let resultado = texto + numero; // 'Mi número favorito es 42'
console.log(resultado);
// Conversión implícita en comparaciones
console.log('5' == 5); // true (comparación de igualdad con conversión de tipo)
console.log('5' === 5); // false (comparación de igualdad estricta sin conversión de tipo)
Lenguaje del código: JavaScript (javascript)Conversiones explícitas
Para realizar conversiones explícitas entre tipos de datos, JavaScript ofrece diversas funciones y métodos que permiten convertir valores a números, cadenas, booleanos, entre otros.
Conversión a Number
Se pueden utilizar las funciones Number(), parseInt() y parseFloat() para convertir valores a números.
Ejemplos:
let cadenaNumero = '42';
let numero1 = Number(cadenaNumero);
console.log(numero1); // 42
let cadenaDecimal = '3.14';
let numero2 = parseFloat(cadenaDecimal);
console.log(numero2); // 3.14
let cadenaEntero = '42px';
let numero3 = parseInt(cadenaEntero);
console.log(numero3); // 42
Lenguaje del código: JavaScript (javascript)Conversión a String
Se puede utilizar la función String() o el método .toString() para convertir valores a cadenas de texto.
Ejemplos:
let numero = 42;
let cadena1 = String(numero);
console.log(cadena1); // '42'
let booleano = true;
let cadena2 = booleano.toString();
console.log(cadena2); // 'true'
Lenguaje del código: JavaScript (javascript)Conversión a Boolean
Se puede utilizar la función Boolean() para convertir valores a booleanos. Los valores falsy (0, -0, NaN, null, undefined y ») se convertirán a false, mientras que todos los demás valores se convertirán a true.
Ejemplos:
let cadenaVacia = '';
let booleano1 = Boolean(cadenaVacia);
console.log(booleano1); // false
let numero = 42;
let booleano2 = Boolean(numero);
console.log(booleano2); // true
Lenguaje del código: JavaScript (javascript)Estos ejemplos ilustran cómo realizar conversiones implícitas y explícitas entre diferentes tipos de datos en JavaScript. Conocer y aplicar correctamente estas conversiones es esencial para escribir código eficiente y evitar errores inesperados.
Cómo conocer el tipo de dato en JavaScript
Puedes usar la función typeof en JavaScript para determinar el tipo de dato de una variable o valor. La función typeof devuelve una cadena que indica el tipo de dato de su argumento.
Aquí hay algunos ejemplos de uso de typeof con diferentes tipos de datos:
let name = "John Doe";
console.log(typeof name); // "string"
let age = 30;
console.log(typeof age); // "number"
let isMarried = true;
console.log(typeof isMarried); // "boolean"
let children = ["Jane", "John"];
console.log(typeof children); // "object"
let person = {
name: "John Doe",
age: 30,
isMarried: true
};
console.log(typeof person); // "object"
let car = null;
console.log(typeof car); // "object"
let job;
console.log(typeof job); // "undefined"
Lenguaje del código: JavaScript (javascript)Cabe señalar que, aunque null es un valor especial que representa la ausencia de valor, la función typeof devuelve “object” para null.
Esto es un error en la implementación de JavaScript y es conocido como un bug histórico.
También es importante mencionar que el tipo de dato “symbol” fue agregado en ECMAScript 6 y también puede ser identificado usando typeof.
let symbol = Symbol("unique identifier");
console.log(typeof symbol); // "symbol"
Lenguaje del código: JavaScript (javascript)Referencias
Aquí tienes algunas referencias útiles sobre Tipos de datos en JavaScript. Estas fuentes pueden proporcionarte información más detallada y ejemplos adicionales para mejorar tu comprensión del tema:
- MDN Web Docs (Mozilla Developer Network): Aquí tienes algunos enlaces relevantes sobre tipos de datos en JavaScript:
Estas referencias te proporcionarán una base sólida para comprender los tipos de datos en JavaScript y cómo trabajar con ellos en tus proyectos de desarrollo web.
