Variables en JavaScript: let, const y tipos de datos
Actualizado el 29 de septiembre de 2026
Una variable es un nombre que le das a un valor para usarlo después. En JavaScript se declaran con let o const, y el tipo del valor no se declara: el lenguaje lo deduce, y además convierte tipos por su cuenta en algunas operaciones, lo que produce resultados que sorprenden.
En esta guía vas a ver cuándo usar let y cuándo const, qué tipos de datos existen, cómo armar textos con valores dentro y cómo convertir entre tipos sin caer en las trampas más comunes.
let y const
let edad = 21;
edad = 22; // let permite reasignar
const nombre = "Camila";
nombre = "Ana"; // TypeError: Assignment to constant variable.const declara una variable que no se puede reasignar; let, una que sí. La recomendación general es usar const por defecto y let solo cuando el valor tiene que cambiar, como un contador. Así, al leer el código, sabes de inmediato qué valores pueden cambiar.
También existe var, la forma antigua. Tiene reglas de alcance confusas y no hay motivo para usarla en código nuevo, pero la vas a ver en tutoriales viejos.
Tipos de datos
typeof 21 // 'number' (enteros y decimales son el mismo tipo)
typeof 1.75 // 'number'
typeof "hola" // 'string'
typeof true // 'boolean'
typeof undefined // 'undefined'
typeof null // 'object' (un error histórico del lenguaje)
typeof [1, 2] // 'object'
Array.isArray([1, 2]) // truenumber: todos los números, con o sin decimales. Incluye valores especiales comoNaN("no es un número") eInfinity.string: texto, entre comillas simples, dobles o invertidas.boolean:trueofalse, en minúsculas.undefined: el valor de una variable declarada a la que todavía no se le asignó nada.null: "ningún valor", asignado a propósito.- Objetos y arrays, que tienen sus propias guías.
Template literals: textos con valores dentro
Un texto escrito entre comillas invertidas, en vez de simples o dobles, es un template literal: dentro, ${...} inserta cualquier expresión. Es la forma más cómoda de armar textos, y además permite saltos de línea.
const nombre = "Camila";
const edad = 21;
`${nombre} tiene ${edad} años` // 'Camila tiene 21 años'
`El próximo año: ${edad + 1}` // 'El próximo año: 22'Convertir entre tipos
Number("42") // 42
Number("3.5") // 3.5
Number("abc") // NaN
Number("") // 0 (¡ojo!)
parseInt("42px") // 42 (lee hasta donde puede)
String(10) // '10'
Boolean("") // false
Boolean("0") // true (es un texto no vacío)JavaScript también convierte solo, y ahí aparecen las sorpresas. El + con un texto une en vez de sumar, pero los demás operadores convierten a número:
"5" + 1 // '51'
"5" - 1 // 4
"5" * "2" // 10
1 + 2 + "3" // '33' (se evalúa de izquierda a derecha)Lo que viene de un formulario, de la URL o de prompt() siempre es texto. Conviértelo explícitamente con Number() antes de hacer cuentas.
Errores comunes
Usar una variable antes de declararla
console.log(total);
let total = 5;
// ReferenceError: Cannot access 'total' before initializationLas variables con let y const solo existen desde la línea en que se declaran. Declara antes de usar.
Creer que const hace inmutable un objeto
const persona = { nombre: "Ana" };
persona.nombre = "Luisa"; // funciona
persona = {}; // TypeErrorconst impide reasignar la variable, pero el objeto al que apunta se puede modificar. Lo mismo pasa con los arrays.
Comparar con NaN
NaN === NaN es false: NaN no es igual a nada, ni a sí mismo. Para saber si una conversión falló, usa Number.isNaN(valor).
Decimales inexactos
0.1 + 0.2 da 0.30000000000000004, igual que en casi todos los lenguajes. Para mostrarlo, usa (0.1 + 0.2).toFixed(2), que devuelve el texto '0.30'. Con dinero, lo más seguro es trabajar en enteros (pesos, centavos).
Ejercicios resueltos
Intenta resolver cada ejercicio antes de abrir la solución: equivocarse y corregir es la parte que más enseña.
1.Describir a una persona
Los ejercicios se escriben como funciones: los valores llegan entre paréntesis y return entrega el resultado. Las funciones se explican a fondo en su propia guía.
Escribe una función describir(nombre, edad) que devuelva el texto "<nombre> tiene <edad> años".
describir("Camila", 21)→"Camila tiene 21 años"
function describir(nombre, edad) {
// ...
}Ver soluciónOcultar solución
function describir(nombre, edad) {
return `${nombre} tiene ${edad} años`;
}Un template literal inserta los valores directamente. Con + también funciona (nombre + " tiene " + edad + " años"), pero es más fácil olvidar un espacio, y con más valores se vuelve difícil de leer.
2.Sumar números que llegan como texto
Escribe una función sumarTextos(a, b) que reciba dos números escritos como texto y devuelva su suma como número.
sumarTextos("12", "30")→42sumarTextos("-5", "5")→0sumarTextos("1.5", "2")→3.5
function sumarTextos(a, b) {
// ...
}Ver soluciónOcultar solución
function sumarTextos(a, b) {
return Number(a) + Number(b);
}Sin convertir, a + b devolvería "1230", porque + une textos. Number() acepta enteros, decimales y negativos. parseInt() no serviría para el tercer ejemplo: corta los decimales y daría 3.
3.El tipo real de un valor
Escribe una función tipoDeDato(valor) que devuelva lo mismo que typeof, salvo en dos casos: para null debe devolver "null" y para un array, "array".
tipoDeDato(null)→"null"tipoDeDato([1, 2])→"array"tipoDeDato({})→"object"tipoDeDato("hola")→"string"
function tipoDeDato(valor) {
// ...
}Ver soluciónOcultar solución
function tipoDeDato(valor) {
if (valor === null) return "null";
if (Array.isArray(valor)) return "array";
return typeof valor;
}typeof responde "object" tanto para null como para los arrays, así que esos dos casos se resuelven antes. Para null se compara con ===; para los arrays, Array.isArray() es la forma confiable de preguntarlo. Todo lo demás lo resuelve typeof.