Tipos de Datos en JavaScript

Introducción a los Tipos de Datos en JavaScript

JavaScript es un lenguaje tipado dinámicamente: nunca se declara el tipo de una variable, y una variable puede contener un valor de cualquier tipo — incluso de un tipo distinto más adelante. Como es el motor, no tú, quien hace el seguimiento de los tipos en tiempo de ejecución, conocer exactamente cómo se comporta cada tipo es lo que distingue el código predecible de los errores desconcertantes.

let x = 42;        // x is now a number
x = "forty-two";   // the same variable now holds a string — perfectly legal

El lenguaje define ocho tipos de datos: siete primitivos y uno no primitivo (object). La página a continuación cubre cada uno, cómo comprobarlo con typeof, y las reglas de coerción que confunden a la mayoría de los principiantes.

Tipos de Datos Primitivos

Un primitivo es un valor que no es un object y no tiene métodos propios. Los primitivos son inmutables — nunca se puede cambiar un valor primitivo, solo reemplazar la variable que lo contiene.

• Number: Valores enteros o de punto flotante, más los valores especiales Infinity, -Infinity y NaN (Not a Number). Ver Numbers.
• String: Datos textuales, encerrados en comillas dobles, comillas simples o backticks. Ver Strings.
• Boolean: Uno de dos valores lógicos, true o false.
• Undefined: Una variable que ha sido declarada pero no tiene un valor asignado.
• Null: La ausencia intencional de cualquier valor de object.
• BigInt: Enteros que superan el límite seguro del tipo Number. Ver BigInt.
• Symbol: Un identificador garantizado único, usado principalmente como claves de object. Ver Symbol type.

Tipo de Dato No Primitivo

• Object: Una colección de propiedades clave/valor usada para modelar datos complejos. Los arrays, las funciones, las fechas y la mayoría de los elementos integrados son todos objects internamente. Ver Objects.

Verificar un Tipo con typeof

Para saber de qué tipo es un valor, JavaScript proporciona el operador typeof. Devuelve un string como "number", "string" o "boolean".

Dos resultados sorprenden a los recién llegados:

• typeof null devuelve "object". Esto es un error de la primera versión de JavaScript que nunca puede corregirse sin romper la web — simplemente memorízalo.
• typeof aplicado a una función devuelve "function". Las funciones son realmente objects, pero typeof las trata de forma especial para que puedas detectar los elementos invocables.

Trabajar con Tipos de Datos Primitivos

A continuación, cada primitivo se muestra con un ejemplo mínimo que puedes ejecutar.

Number: La Base de las Operaciones Matemáticas

let age = 25;       // Integer
let price = 99.99;  // Floating-point
console.log(typeof age);   // "number"
console.log(0.1 + 0.2);    // 0.30000000000000004  (floating-point rounding)

Un único tipo number cubre tanto los enteros como los decimales. Como los números usan punto flotante de 64 bits, las matemáticas con fracciones no siempre son exactas — 0.1 + 0.2 es el ejemplo clásico. Los números también incluyen Infinity y NaN; NaN es famoso por no ser igual a sí mismo, así que usa Number.isNaN(x) para comprobarlo.

String: Más que Solo Texto

let greeting = "Hello, world!";
let name = 'Ada';
let response = `Hi, ${name}!`; // template literal with interpolation
console.log(typeof greeting); // "string"
console.log(response);        // "Hi, Ada!"

Los strings son inmutables: métodos como toUpperCase() devuelven un nuevo string en lugar de modificar el original. Los strings con backtick (template literals) permiten insertar ${expressions} y abarcar varias líneas. Explora el conjunto completo de herramientas en Strings.

Boolean: El Decisor Binario

let isAvailable = true;
let age = 25;
let isAdult = age >= 18; // comparisons produce booleans
console.log(typeof isAvailable); // "boolean"
console.log(isAdult);            // true

Los boolean impulsan cada condicional y bucle. Cualquier valor también puede ser coercionado a boolean — consulta la tabla de verdadero/falso a continuación.

Undefined y Null: La Ausencia de Valor

let notAssigned;          // declared but never given a value
let emptyOnPurpose = null; // deliberately "nothing"
console.log(typeof notAssigned);  // "undefined"
console.log(typeof emptyOnPurpose); // "object" (the typeof null quirk)
console.log(null == undefined);   // true  (loose equality)
console.log(null === undefined);  // false (strict equality — different types)

Usa undefined para "aún sin valor" (es lo que JavaScript asigna automáticamente) y null para "intencionalmente vacío". Son iguales con igualdad débil (==) pero no con igualdad estricta (===).

BigInt: Manejo de Números Grandes

const big = 9007199254740991n; // note the trailing n
console.log(typeof big);     // "bigint"
console.log(big + 1n);       // 9007199254740992n

Number solo puede representar con seguridad enteros hasta Number.MAX_SAFE_INTEGER (aproximadamente 9 cuatrillones). Para cualquier valor mayor — criptografía, IDs de alta precisión — usa BigInt, escrito con una n al final. No se pueden mezclar BigInt y Number en la misma operación aritmética sin conversión explícita. Más información en BigInt.

Symbol: Garantizando la Unicidad

Cada llamada a Symbol() devuelve un valor nuevo y único aunque el texto descriptivo coincida. Los Symbols se usan como claves de object a prueba de colisiones, por ejemplo para adjuntar metadatos sin interferir con las claves de string normales. Ver Symbol type.

Objects: Los Pilares de las Estructuras Complejas

En JavaScript, los objects almacenan colecciones de datos relacionados como pares clave/valor y son la base de los arrays, las funciones y la mayoría de los elementos integrados.

let person = {
  name: "John",
  age: 30,
  isStudent: false
};
console.log(typeof person);     // "object"
console.log(typeof [1, 2, 3]);  // "object"  (arrays are objects)
console.log(Array.isArray([1])); // true — the reliable way to detect arrays

Los objects son mutables — a diferencia de los primitivos, puedes añadir, cambiar y eliminar sus propiedades. También se comparan por referencia, no por valor: dos objects con contenidos idénticos no son === iguales.

Coerción y Conversión de Tipos

Dado que JavaScript es tipado dinámicamente, a menudo coerciona un valor de un tipo a otro durante una operación. Esto es conveniente pero es una fuente común de sorpresas.

En caso de duda, convierte de forma explícita con Number(), String() o Boolean() en lugar de depender de la coerción automática.

Valores Truthy y Falsy

Cuando se usa un valor donde se espera un boolean (en un if, &&, ||), es coercionado. Exactamente seis valores son falsy; todo lo demás es truthy:

// falsy: false, 0, "", null, undefined, NaN
if ("") console.log("won't run");      // "" is falsy
if ("0") console.log("this runs");     // non-empty string is truthy
if ([]) console.log("this runs too");  // empty array is truthy!

Un error frecuente: un array vacío [] y un object vacío {} son truthy, aunque "" y 0 sean falsy.

Resumen

JavaScript tiene ocho tipos de datos — siete primitivos (number, string, boolean, undefined, null, bigint, symbol) y el object. typeof reporta el tipo, con las conocidas particularidades de que typeof null es "object" y las funciones reportan "function". Los primitivos son inmutables y se comparan por valor; los objects son mutables y se comparan por referencia. Domina la coerción y las reglas truthy/falsy y la mayoría del "JavaScript extraño" desaparece. A continuación, consulta cómo se almacenan los valores en Variables.

Práctica