Cuando declaras una variable en JavaScript, le estás asignando un tipo de dato específico que define qué puede contener y cómo se comporta. Conocer los tipos de datos primitivos y complejos es la base para escribir código sólido, evitar errores silenciosos y entender por qué el lenguaje se comporta como lo hace en ciertos casos famosos, como el del null.
Esta guía es para ti si estás empezando con JavaScript y quieres dominar la diferencia entre un string, un number, un boolean y estructuras más robustas como objetos, arrays y funciones.
¿Cuáles son los 7 tipos de datos primitivos en JavaScript?
Los primitivos son representaciones de datos simples, valores únicos que puedes asignar directamente a una variable. JavaScript reconoce siete [01:00]:
- String: cadenas de texto, como
"Hola".
- Number: valores numéricos, como
42.
- Boolean: dos estados posibles,
true o false.
- Null: ausencia intencional de valor.
- Undefined: variable declarada sin valor asignado.
- Symbol: identificadores únicos.
- BigInt: números demasiado grandes para el tipo
number.
¿Cómo se declaran los primitivos en código?
La mejor práctica es empezar con const, salvo que necesites reasignar el valor más adelante; en ese caso usa let. Así se ve cada uno [02:30]:
javascript
// Tipo de datos primitivos
const texto = "Hola";
const numero = 42;
const booleano = true;
const nulo = null;
const indefinido = undefined;
const simbolo = Symbol("id");
const granNumero = 123n;
Fíjate en un detalle: si escribes "42" entre comillas, ya no es un número, es un string. Tu editor te ayuda con colores distintos para que reconozcas visualmente cada tipo.
¿Para qué sirve Symbol en JavaScript? Es un tipo de dato que crea identificadores únicos. Lo usarás cuando trabajes con aplicaciones más robustas y necesites asignar IDs irrepetibles a piezas de código.
¿Cómo verifico el tipo de dato de una variable?
Usas la palabra reservada typeof antes de la variable y lo imprimes con console.log [05:00]:
javascript
console.log(typeof texto); // string
console.log(typeof numero); // number
console.log(typeof booleano); // boolean
console.log(typeof nulo); // object ← ojo aquí
console.log(typeof indefinido); // undefined
console.log(typeof simbolo); // symbol
console.log(typeof granNumero); // bigint
¿Por qué typeof null devuelve object en JavaScript?
Aquí viene lo interesante. Cuando ejecutas typeof null, JavaScript responde object, y eso confunde a cualquiera que esté empezando.
Es un error histórico del lenguaje. En las primeras implementaciones de JavaScript, null se representaba como un puntero nulo y quedó clasificado junto con los objetos. La comunidad lo reconoce como un bug, pero no se ha corregido por compatibilidad: arreglarlo rompería incontables aplicaciones construidas desde el nacimiento del lenguaje.
Conceptualmente, null no es un objeto. Es la ausencia intencional de un valor, distinta de undefined, que indica que una variable nunca recibió valor.
¿Cuál es la diferencia entre null y undefined? null lo asignas tú a propósito para indicar vacío. undefined lo asigna JavaScript automáticamente cuando declaras una variable sin valor.
¿Qué son los tipos de datos complejos en JavaScript?
Los complejos agrupan múltiples valores o comportamientos en una sola estructura. Son tres [07:30]:
- Object: colecciones de pares clave-valor.
- Array: listas ordenadas de elementos.
- Function: bloques de código reutilizables.
Así los declaras:
javascript
// Tipos complejos
const persona = { nombre: "Juan", edad: 30 };
const numeros = [1, 2, 3, "texto"];
const miFuncion = function() {
// lógica aquí
};
Un objeto puede mezclar strings y numbers dentro de sus propiedades. Un array también puede contener distintos tipos de datos en la misma lista. Y una función encapsula instrucciones que ejecutas cuando la llamas.
¿Qué cuidados debo tener con los nombres de variables?
Dos reglas que te van a ahorrar dolores de cabeza:
- No uses palabras reservadas como nombre de variable. Si intentas llamar
function a una constante, JavaScript te lanzará un error.
- JavaScript distingue mayúsculas y minúsculas.
miVariable y MiVariable son dos cosas distintas.
Los comentarios también son tu aliado. Con // dejas notas que JavaScript ignora, pero que ayudan a cualquier compañero (o a ti mismo en seis meses) a entender qué hace el código.
¿Ya practicaste declarando tus propias variables con cada tipo? Cuéntame en los comentarios cuál fue el tipo de dato que más te costó identificar y cómo resolviste el reto.
