Tipos de Datos en JavaScript
Los tipos de datos en JavaScript son las categorías o clasificaciones de los valores que puedes usar en un programa. Sirven para definir qué tipo de información se va a almacenar en una variable o constante y cómo el lenguaje debe tratar esos valores. Por ejemplo, puedes trabajar con números, texto, valores lógicos, objetos, listas, entre otros.
script.js
// Tipo número (Number)
let numero = 42; // Puede ser entero o decimal
let decimal = 3.14; // Número decimal
// Tipo texto (String)
let texto = "Hola, mundo"; // Cadena de texto con comillas dobles
let textoConComillasSimples = 'Hola, JavaScript'; // Cadena con comillas simples
// Tipo booleano (Boolean)
let esVerdadero = true; // Valor lógico verdadero
let esFalso = false; // Valor lógico falso
// Tipo objeto (Object)
let objeto = {
nombre: "Juan",
edad: 30,
esEstudiante: true
};
// Tipo lista (Array)
let lista = [1, 2, 3, 4, 5]; // Una lista de números
let listaMixta = ["texto", 42, true, { clave: "valor" }]; // Una lista con diferentes tipos
// Tipo indefinido (Undefined)
let indefinido; // Variable declarada sin valor asignado, automáticamente es undefined
// Tipo nulo (Null)
let nulo = null; // Una variable que explícitamente no tiene valor
// Tipo símbolo (Symbol)
let simbolo = Symbol("descripcion"); // Crea un valor único para identificar algo
// Tipo BigInt (para números muy grandes)
let numeroGrande = 123456789012345678901234567890n; // Números enteros grandes con 'n' al final
¿Por qué son importantes los tipos de datos?
🔸Organización: Ayudan a estructurar mejor tu código. 🔸Operaciones adecuadas: JavaScript necesita saber qué operaciones son válidas para un tipo de dato. Por ejemplo, puedes sumar números, pero no cadenas de texto (al menos no como números). 🔸Control de errores: Ayudan a evitar errores al combinar o manipular datos.Clasificación de los tipos de datos en JavaScript
JavaScript tiene dos categorías principales de tipos de datos:1. Tipos de datos primitivos
Son los tipos de datos más básicos. Representan un solo valor simple, no son modificables (inmutables) y se almacenan por valor. 🔸String: Representa texto. 🔸Number: Representa números, tanto enteros como decimales. 🔸Boolean: Representa valores lógicos (verdadero o falso). 🔸Undefined: Indica que una variable fue declarada, pero no tiene un valor asignado. 🔸Null: Representa la ausencia intencional de un valor. 🔸Symbol: Representa un valor único e inmutable, útil para identificadores únicos. 🔸BigInt: Representa números enteros extremadamente grandes.2. Tipos de datos no primitivos
También conocidos como referenciados, incluyen estructuras más complejas que pueden contener múltiples valores o comportamientos. Se almacenan por referencia. 🔸Objetos: Colecciones de pares clave-valor. 🔸Arrays: Listas ordenadas de valores. 🔸Funciones: Bloques de código reutilizable que pueden ser ejecutados. 🔸Otros tipos: Map, Set, etc.Cómo determinar el tipo de dato
En JavaScript, puedes usar el operador typeof para averiguar el tipo de dato de un valor o variable. Ejemplos:
console.log(typeof "Hola"); // Muestra: string
console.log(typeof 42); // Muestra: number
console.log(typeof true); // Muestra: boolean
console.log(typeof undefined); // Muestra: undefined
console.log(typeof null); // Muestra: object (esto es un comportamiento histórico en JavaScript)
console.log(typeof Symbol("id")); // Muestra: symbol
console.log(typeof 9007199254740991n); // Muestra: bigint
Diferencias clave entre tipos primitivos y no primitivos
| Características | Tipos primitivos | Tipos no primitivos |
|---|---|---|
| Mutabilidad | Inmutables | Mutables |
| Almacenamiento | Por valor | Por referencia |
| Ejemplos | string, number, boolean, null… | objetos, arrays, funciones… |
String (Cadena de texto)
Los strings se usan para representar texto. Se escriben entre comillas simples ('), dobles (") o backticks (`).
let nombre = "Juan"; // Comillas dobles
let saludo = 'Hola'; // Comillas simples
let mensaje = `Hola, ${nombre}`; // Template string con interpolación
Las comillas simples y dobles permiten incluir la otra dentro de la cadena, por ejemplo:
miCadena1 = "Mejor tiempo: 7.";
miCadena2 = 'Lanzado "Engine", el nuevo motor eléctrico.';
Además, se puede utilizar el operador de concatenación (+) para unir fragmentos de cadenas o incluir el contenido de variables dentro de ellas. Por ejemplo:
subcadena1 = "Primera parte, ";
subcadena2 = "parte concatenada";
subcadena3 = 'Última parte añadida';
cadenaFinal = "Cadena: " + subcadena1 + subcadena2 + subcadena3;
Alternativamente, se pueden utilizar los «backticks» para simplificar la concatenación de cadenas:
cadenaFinal = `Cadena: ${subcadena1}${subcadena2}${subcadena3}`;
Number (Números)
Se utilizan para representar números, tanto enteros como decimales.
let edad = 25; // Número entero
let precio = 19.99; // Número decimal
let resultado = edad * precio; // Operaciones matemáticas
Además, se pueden utilizar diferentes sistemas de representación numérica, como binario, octal y hexadecimal, utilizando un prefijo especial.
numeroBinario = 0b100110;
numeroOctal = 0o46;
numeroHexadecimal = 0x26;
Sin embargo, es importante destacar que JavaScript puede tener problemas con la precisión cuando se manejan números extremadamente grandes o pequeños. En tales casos, se recomienda el uso de Bigint.
Boolean (Booleanos)
Los booleanos solo tienen dos valores posibles: true o false. Son útiles para tomar decisiones en el programa.
let esMayorDeEdad = true;
let tieneLicencia = false;
Undefined
Representa una variable que ha sido declarada, pero no tiene un valor asignado.
let variableNoDefinida;
console.log(variableNoDefinida); // Muestra: undefined
Null
Es un valor especial que representa la ausencia intencional de un valor. Es diferente de undefined.
let valorNulo = null;
console.log(valorNulo); // Muestra: null
Es importante destacar la diferencia entre undefined y null en JavaScript. Undefined significa que no se ha definido ningún valor para una variable, mientras que null indica que el programador ha establecido explícitamente que la variable no tiene ningún valor.
Symbol
Un Symbol es un valor único e inmutable. Se utiliza para crear identificadores únicos e inmutables. Cada valor Symbol creado es distinto de cualquier otro Symbol. Estos símbolos se utilizan comúnmente como claves en objetos para asegurarse de que no haya colisiones en nombres de propiedades, lo que los hace especialmente útiles en situaciones donde se desea evitar la sobrescritura accidental de propiedades de objetos.
let id = Symbol("id");
let otroId = Symbol("id");
console.log(id === otroId); // Muestra: false (son únicos)
Los símbolos se crean utilizando la función constructora «Symbol()» o utilizando una descripción opcional entre paréntesis. La descripción es útil para proporcionar información descriptiva sobre el símbolo, pero no afecta a su unicidad. Por ejemplo:
// Crear símbolos
const symbol1 = Symbol();
const symbol2 = Symbol('Descripción del símbolo');
console.log(typeof symbol1); // "symbol"
console.log(symbol2.toString()); // "Symbol(Descripción del símbolo)"
Cada símbolo es único, incluso si tienen la misma descripción:
const symbol1 = Symbol('foo');
const symbol2 = Symbol('foo');
console.log(symbol1 === symbol2); // false
Los símbolos también se utilizan en la creación de propiedades privadas en objetos y en otros casos donde se necesita una identificación única y no colisionante.
BigInt
BigInt se usa para representar números enteros muy grandes que no pueden manejarse con el tipo number.
let numeroGrande = 1234567890123456789012345678901234567890n;
console.log(numeroGrande); // Muestra: 1234567890123456789012345678901234567890n
A continuación pasaremos a ver los tipos no primitivos, que son objetos y se almacenan por referencia. Estos datos pueden ser complejos y cambiar dinámicamente.
Objetos
Un objeto es una colección de pares clave-valor. Es útil para agrupar datos relacionados.
let persona = {
nombre: "Ana",
edad: 30,
esEstudiante: true
};
console.log(persona.nombre); // Muestra: Ana
Arrays
Un array es una lista ordenada de valores, que pueden ser de cualquier tipo.
let numeros = [1, 2, 3, 4, 5];
let mezclado = [1, "texto", true, null];
console.log(numeros[0]); // Muestra: 1 (el primer elemento)
numeros.push(6); // Agrega un elemento al final
console.log(numeros); // Muestra: [1, 2, 3, 4, 5, 6]
Funciones
En JavaScript, las funciones son objetos especiales que representan bloques de código reutilizable.
function saludar(nombre) {
return `Hola, ${nombre}!`;
}
console.log(saludar("Carlos")); // Muestra: Hola, Carlos!
Secuencias de Uso
Además, para representar caracteres especiales o símbolos, se pueden utilizar secuencias de escape como se muestra en la Tabla.
Se puede insertar una comilla dentro de una cadena precediéndola por una contrabarra [backslash]. Esto se conoce como escapar la comilla. Por ejemplo:
var texto = "El lee \"La Incineración de Sam McGee\" de R.W. Service."
document.write(texto)
El resultado de ello sería:
El lee "La Incineración de Sam McGee" de R.W. Service.)
Para incluir en una cadena la contrabarra [backslash], deberá escapar el carácter de contrabarra [backslash]. Por ejemplo, para asignar la ruta de un archivo c:\temp a una cadena, use lo siguiente:
var home = "c:\\temp"