Tipos de datos

Todo valor en JavaScript pertenece a una categoría, llamada tipo de dato. El tipo le dice al lenguaje qué se puede hacer con ese valor: a un número se le puede sumar, a un texto se le puede concatenar, y a un booleano se le puede preguntar si es verdadero.

Conocer los tipos evita muchos errores. La mayoría de los sustos al empezar vienen de sumar un texto con un número sin querer.

Objetivos

Al terminar esta lección deberías ser capaz de:

• Nombrar los tipos primitivos básicos y reconocerlos en ejemplos.
• Usar typeof para averiguar el tipo de un valor.
• Crear textos, números y booleanos correctamente.
• Entender que el tipo depende del valor, no de una etiqueta fija.
• Convertir valores entre tipos de forma explícita.

¿Por qué existen los tipos?

Imagina una caja de herramientas. Un destornillador y un martillo sirven para cosas distintas. Si intentas clavar un tornillo con el martillo, el resultado no será el esperado. Con los datos pasa lo mismo: JavaScript necesita saber si tiene entre manos un "5" (texto) o un 5 (número) para decidir qué hacer al usar +.

texto-vs-numero.js

console.log(5 + 2); // 7 → suma números
console.log("5" + 2); // "52" → une texto y número

En el segundo caso, el + junta en lugar de sumar porque uno de los dos valores es texto.

Los tipos primitivos

En esta primera clase trabajaremos con los cinco tipos primitivos (valores simples) que aparecen en casi cualquier programa:

Tipos primitivos básicos
├── string      → texto: "hola"
├── number      → números: 42, 3.14
├── boolean     → verdadero o falso: true, false
├── undefined   → todavía no hay valor
└── null        → hay un vacío a propósito

Nota

Con estos cinco tipos tienes de sobra para empezar. null y undefined tienen una lección propia porque merecen más atención.

La tabla de tipos

Tipo	Qué guarda	Ejemplo	typeof devuelve
string	Texto	"Hola", 'JS', `Hola`	"string"
number	Números (enteros y decimales)	42, -7, 3.14, NaN	"number"
boolean	Verdadero o falso	true, false	"boolean"
undefined	Valor todavía no asignado	undefined	"undefined"
null	Vacío decidido por quien programa	null	"object" ⚠️

La excepción de null

typeof null devuelve "object", aunque null es un primitivo. Es un error histórico de JavaScript que se mantiene por compatibilidad. Para comprobar si algo es null, compara directamente con === null.

Cómo consultar el tipo: typeof

typeof es un operador que devuelve el nombre del tipo como texto:

typeof.js

console.log(typeof "Hola"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (el caso especial)

Solo hay una sorpresa: la de null, que ya comentamos.

Strings (texto)

Puedes escribir texto con tres tipos de comillas:

cadenas.js

console.log("Hola" === "Hola"); // true → comillas dobles
console.log("JS" === "JS"); // true → comillas simples dan el mismo resultado
console.log(`Hola` === "Hola"); // true → comillas invertidas también

Las plantillas (comillas invertidas o backticks) permiten insertar un valor con ${} sin ir sumando trozos:

plantillas.js

console.log(`El resultado de 2 + 2 es ${2 + 2}`);
// "El resultado de 2 + 2 es 4"

Es más legible que ir uniendo trozos con +:

console.log("El resultado de 2 + 2 es " + (2 + 2));

Consejo

Más adelante, cuando aprendas a guardar valores, podrás poner un nombre dentro de ${} en lugar de la operación. La idea es la misma.

Number (números)

A diferencia de otros lenguajes, JavaScript no distingue entre enteros y decimales: todo es number.

numeros.js

console.log(10); // 10
console.log(10.5); // 10.5
console.log(0.1 + 0.2); // 0.30000000000000004 (redondeo binario)
console.log(1 / 0); // Infinity
console.log(0 / 0); // NaN ("Not a Number")

Hay dos valores numéricos especiales:

• NaN (Not a Number): resultado de una operación numérica inválida. Curiosamente, NaN === NaN es false. Para detectarlo usa Number.isNaN(), por ejemplo Number.isNaN(0 / 0) devuelve true.
• Infinity: resultado de dividir entre cero o de un número demasiado grande.

Consejo

Para comparar decimales con precisión (por ejemplo, precios), redondea antes: Math.round((0.1 + 0.2) * 100) / 100 devuelve 0.3.

Boolean (verdadero o falso)

Solo tiene dos valores: true y false. Es el resultado de toda comparación y la base de las estructuras if.

booleanos.js

console.log(10 > 5); // true
console.log("hola" === "adiós"); // false
console.log(typeof true); // "boolean"

El tipo depende del valor

JavaScript es de tipado dinámico: no decide el tipo por una etiqueta fija, sino por el valor que tiene delante en cada momento.

tipado-dinamico.js

console.log(typeof "Soy texto"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"

Esto es cómodo, pero exige cuidado: si esperas un número y recibes un texto, las operaciones pueden comportarse de forma inesperada. Cuando aprendas a guardar valores, verás que el tipo sigue siendo el del valor guardado.

Conversiones de tipo

A veces necesitas cambiar un valor de tipo a propósito. A eso se le llama conversión explícita:

Conversión	Convierte a	Ejemplo	Resultado
Number()	número	Number("42")	42
String()	texto	String(42)	"42"
Boolean()	booleano	Boolean("hola")	true

conversiones.js

console.log(Number("42")); // 42
console.log(Number("hola")); // NaN
console.log(String(42)); // "42"
console.log(Boolean(0)); // false
console.log(Boolean("hola")); // true

También existe la conversión implícita, que hace JavaScript por su cuenta:

conversion-implicita.js

console.log("5" - 2); // 3 → convierte "5" a número para restar
console.log("5" + 2); // "52" → convierte 2 a texto para unir
console.log(5 == "5"); // true → compara convirtiendo tipos

La regla de oro

La conversión implícita es la fuente de muchos bugs. Convierte siempre de forma explícita (por ejemplo, Number("5")) y usa comparaciones estrictas (===), que verás en Operadores de comparación.

Errores frecuentes

• Confundir NaN con un tipo: typeof NaN es "number", no "object" ni "undefined".
• Sumar sin querer: "Precio: " + 10 + 5 da "Precio: 105" porque el texto “contagia” al resto.
• Comparar decimales con ===: 0.1 + 0.2 === 0.3 es false.
• Confiar en typeof null: devuelve "object"; comprueba con === null.

Ejercicio

1. En la consola, averigua el tipo de "JavaScript", 3.14, false, undefined y null con typeof.
2. Escribe una plantilla que diga El doble de 5 es 10 usando ${}.
3. Predice el resultado antes de ejecutarlo: "10" + 5, "10" - 5, Number("10") + 5.
4. Comprueba si tus predicciones eran correctas y anota cuál te sorprendió.

Resumen

• Todo valor tiene un tipo, que define qué operaciones puede hacer.
• Los tipos primitivos básicos son cinco: string, number, boolean, null y undefined.
• typeof devuelve el tipo como texto, con una excepción: null da "object".
• JavaScript decide el tipo según el valor, no según una etiqueta fija.
• Convierte explícitamente con Number(), String() y Boolean() para evitar sorpresas.

Siguiente paso: Operadores de comparación.