El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

Ya conoces la gramática del lenguaje: sentencias, bloques, nombres válidos y modo estricto. Ahora toca el contenido: los datos. Programar consiste, en el fondo, en guardar información, transformarla y mostrarla. En esta lección aprenderás a crear variables con let y const, entenderás por qué var pertenece al pasado, y recorrerás todos los tipos de datos primitivos de JavaScript. Al terminar podrás modelar con precisión cada campo de una tarea de Nómada Tareas usando el tipo adecuado en cada caso.

Contenido

Qué es una variable
Declarar variables: let y const
var y por qué está desaconsejado
Tipado dinámico y el operador typeof
El tipo string: texto
El tipo number: números
El tipo boolean: verdadero o falso
undefined y null
symbol y bigint
Primitivos frente a referencias
Modelar una tarea de Nómada Tareas
Errores Comunes y Consejos
Ejercicios
Conclusión

Qué es una variable

Una variable es un nombre asociado a un valor guardado en memoria. La imagen habitual es la de una caja etiquetada: la etiqueta es el nombre y dentro está el valor.

const responsable = 'Marta';

Tres piezas:

Pieza	Función
`const`	La palabra clave de declaración: crea la variable
`responsable`	El identificador: el nombre con el que la usarás
`'Marta'`	El valor que se guarda

A partir de esa línea, escribir responsable en cualquier punto posterior equivale a escribir 'Marta'.

Es importante entender que la variable no es el valor: es una referencia con nombre. Puedes cambiar lo que guarda (si la declaraste con let) sin cambiar su nombre.

Declarar variables: `let` y `const`

JavaScript moderno ofrece dos formas de declarar variables.

2.1 `const`: el valor no se reasigna

const responsable = 'Iván';
// responsable = 'Lucía'; // TypeError: Assignment to constant variable.

Dos reglas de const:

Hay que darle un valor al declararla. const x; es un SyntaxError.
No se puede reasignar después.

2.2 `let`: el valor puede cambiar

let estado = 'pendiente';
console.log(estado); // pendiente

estado = 'en-curso';
console.log(estado); // en-curso

estado = 'hecha';
console.log(estado); // hecha

let sí admite declararse sin valor inicial; en ese caso la variable vale undefined hasta que le asignes algo:

let siguienteResponsable;
console.log(siguienteResponsable); // undefined

siguienteResponsable = 'Lucía';
console.log(siguienteResponsable); // Lucía

2.3 Cuál usar

La regla es simple y no tiene excepciones prácticas: usa const por defecto; usa let solo cuando sepas que el valor va a cambiar.

¿Por qué? Porque const comunica una intención. Cuando alguien lee const fechaLimite = ..., sabe de inmediato que ese valor no cambiará en toda la función. Es información gratuita que reduce la carga mental de leer código.

// El id y el título de una tarea no cambian mientras la procesamos
const id = 1;
const titulo = 'Rediseñar la sala polivalente';

// El estado sí cambia a lo largo de la vida de la tarea
let estado = 'pendiente';

2.4 Un matiz crucial sobre `const`

const no significa "el valor es inmutable". Significa "la variable no se puede reasignar". Si el valor es un objeto o un array, su contenido sí puede modificarse:

const etiquetas = ['diseño', 'espacio'];

etiquetas.push('urgente');       // Permitido: modificamos el contenido
console.log(etiquetas);          // ['diseño', 'espacio', 'urgente']

// etiquetas = ['otra cosa'];    // TypeError: no se puede reasignar

Esto desconcierta a mucha gente. La explicación está en el apartado 10 (primitivos frente a referencias) y se desarrolla en el Módulo 4.

`var` y por qué está desaconsejado

Antes de ES2015 solo existía var. Lo encontrarás en código antiguo y en tutoriales desactualizados, así que conviene saber por qué se abandonó.

3.1 Problema 1: ámbito de función, no de bloque

function revisarTareas() {
  if (true) {
    var mensaje = 'Con var';
    let aviso = 'Con let';
  }
  console.log(mensaje); // 'Con var' — se escapa del bloque
  // console.log(aviso); // ReferenceError — se queda dentro
}

var ignora las llaves: solo respeta los límites de una función. let y const respetan cualquier bloque, que es lo intuitivo.

3.2 Problema 2: permite redeclarar

var responsable = 'Marta';
var responsable = 'Iván'; // Permitido, sin ningún aviso

let horas = 8;
// let horas = 6; // SyntaxError: Identifier 'horas' has already been declared

Redeclarar por accidente en un fichero largo es una forma silenciosa de perder datos. let te avisa.

3.3 Problema 3: hoisting confuso

console.log(conVar);  // undefined  (no falla, pero engaña)
var conVar = 'valor';

// console.log(conLet); // ReferenceError: Cannot access 'conLet' before initialization
let conLet = 'valor';

Con var obtienes undefined en lugar de un error, lo que oculta el problema real. Con let obtienes un error claro. El mecanismo se explica en Hoisting y el Contexto de Ejecución.

3.4 Tabla comparativa

Característica	`var`	`let`	`const`
Ámbito	Función	Bloque	Bloque
Se puede reasignar	Sí	Sí	No
Se puede redeclarar	Sí	No	No
Uso antes de declarar	`undefined`	`ReferenceError`	`ReferenceError`
Requiere valor inicial	No	No	Sí
Crea propiedad en el objeto global	Sí	No	No
Recomendado hoy	No	Sí, si cambia	Sí, por defecto

Conclusión: no escribas var en código nuevo. Solo necesitas reconocerlo cuando lo veas.

Tipado dinámico y el operador `typeof`

JavaScript es de tipado dinámico: las variables no tienen tipo, los valores sí. Una misma variable puede guardar valores de tipos distintos a lo largo del programa.

let dato = 'alta';    // ahora contiene un texto
dato = 12;            // ahora un número
dato = true;          // ahora un booleano

Es flexible, pero también peligroso: nada te avisa si una variable acaba conteniendo algo distinto de lo que esperabas.

Para saber qué tipo tiene un valor, existe el operador typeof:

console.log(typeof 'Marta');    // 'string'
console.log(typeof 12);         // 'number'
console.log(typeof true);       // 'boolean'
console.log(typeof undefined);  // 'undefined'
console.log(typeof Symbol());   // 'symbol'
console.log(typeof 10n);        // 'bigint'
console.log(typeof {});         // 'object'
console.log(typeof []);         // 'object'  ← un array también es 'object'
console.log(typeof null);       // 'object'  ← ¡el famoso error histórico!

Las dos últimas líneas merecen atención:

typeof [] devuelve 'object' porque en JavaScript un array es un tipo especial de objeto.
typeof null devuelve 'object' por un fallo de la primerísima implementación de 1995 que nunca se ha corregido, porque hacerlo rompería código existente. Es la cicatriz histórica que mencionamos en la primera lección.

4.1 El mapa de tipos

JavaScript tiene siete tipos primitivos y un tipo de referencia (object, que engloba arrays, funciones, fechas...).

flowchart TD
    T["Tipos de datos en JavaScript"]
    T --> P["Primitivos<br/>(valor inmutable)"]
    T --> O["Objetos<br/>(referencia)"]
    P --> S["string"]
    P --> N["number"]
    P --> B["boolean"]
    P --> U["undefined"]
    P --> NU["null"]
    P --> SY["symbol"]
    P --> BI["bigint"]
    O --> OB["object · array · function · Date..."]

El tipo `string`: texto

Un string es una secuencia de caracteres: nombres, títulos, estados, fechas en formato texto.

5.1 Las tres formas de escribir texto

const conSimples = 'Rediseñar la sala polivalente';
const conDobles = "Rediseñar la sala polivalente";
const conPlantilla = `Rediseñar la sala polivalente`;

Las comillas simples y dobles son equivalentes. La convención mayoritaria en JavaScript es usar comillas simples, y reservar las dobles para cuando el texto contenga un apóstrofo:

const nota = "Marta dice que el taller no está listo";
const otra = 'Marta dice que el taller no está listo';
const conApostrofo = "L'espai polivalent";  // más cómodo con dobles

También puedes escapar un carácter con la barra invertida:

const escapado = 'L\'espai polivalent';

5.2 Template literals: la forma moderna

Los template literals usan acentos graves (`) y aportan dos superpoderes.

Superpoder 1: interpolación con ${}. Puedes insertar el valor de cualquier expresión dentro del texto:

const responsable = 'Iván';
const horasEstimadas = 12;

// Forma antigua: concatenación
const antigua = 'Tarea de ' + responsable + ': ' + horasEstimadas + ' horas';

// Forma moderna: template literal
const moderna = `Tarea de ${responsable}: ${horasEstimadas} horas`;

console.log(moderna); // Tarea de Iván: 12 horas

Se lee muchísimo mejor, y desaparecen los errores de espacios olvidados entre comillas.

Dentro de ${} puede ir cualquier expresión, no solo una variable:

const horasIvan = 12;
const horasLucia = 8;
console.log(`Carga conjunta: ${horasIvan + horasLucia} horas`); // 20 horas

Superpoder 2: saltos de línea reales. El texto se escribe tal cual, en varias líneas:

const resumen = `Tarea: Rediseñar la sala polivalente
Responsable: Iván
Prioridad: alta`;

console.log(resumen);

Con comillas normales habría que usar \n, que se lee mucho peor.

5.3 Propiedades y métodos básicos

Aunque string es un primitivo, JavaScript te permite usar propiedades y métodos sobre él:

const titulo = 'Rediseñar la sala polivalente';

console.log(titulo.length);         // 28 — número de caracteres
console.log(titulo.toUpperCase());  // REDISEÑAR LA SALA POLIVALENTE
console.log(titulo.includes('sala')); // true
console.log(titulo[0]);             // 'R' — primer carácter (posición 0)

Un detalle fundamental: los strings son inmutables. Ningún método modifica el original; todos devuelven uno nuevo.

const original = 'pendiente';
const enMayusculas = original.toUpperCase();

console.log(original);      // 'pendiente' — intacto
console.log(enMayusculas);  // 'PENDIENTE' — nuevo string

El tipo `number`: números

JavaScript tiene un solo tipo numérico: number. No distingue entre enteros y decimales como otros lenguajes.

const horasEstimadas = 12;      // entero
const horasReales = 12.5;       // decimal
const desviacion = -0.5;        // negativo
const casiCero = 1.5e-4;        // notación científica: 0.00015
const conSeparador = 1_000_000; // el guion bajo mejora la lectura

6.1 Valores numéricos especiales

Hay tres valores que son de tipo number pero no son números normales:

Valor	Significa	Cómo aparece
`Infinity`	Infinito positivo	`1 / 0`, o un número demasiado grande
`-Infinity`	Infinito negativo	`-1 / 0`
`NaN`	Not a Number: resultado no numérico	`'alta' * 2`, `Number('hola')`

console.log(10 / 0);            // Infinity
console.log('alta' * 2);        // NaN
console.log(typeof NaN);        // 'number' ← sí, NaN es de tipo number

NaN tiene una propiedad desconcertante: no es igual a sí mismo.

console.log(NaN === NaN); // false

Por eso, para detectarlo se usa la función Number.isNaN():

const horas = Number('doce'); // NaN
console.log(Number.isNaN(horas)); // true

NaN es el resultado típico de un error de datos: alguien escribió texto donde esperabas un número. Verlo en la consola casi siempre significa "revisa de dónde viene ese dato".

6.2 La precisión en coma flotante

Este es uno de los primeros sustos de todo programador:

console.log(0.1 + 0.2);           // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);   // false

No es un fallo de JavaScript. Los números se almacenan en binario siguiendo el estándar IEEE 754, y algunos decimales (como 0.1) no tienen representación binaria exacta, igual que 1/3 no tiene representación decimal exacta. Casi todos los lenguajes se comportan igual.

Soluciones prácticas:

const total = 0.1 + 0.2;

// Redondear a los decimales que necesites
console.log(total.toFixed(2));        // '0.30' (ojo: devuelve un string)
console.log(Number(total.toFixed(2))); // 0.3 (número)

// Comparar con una tolerancia
console.log(Math.abs(total - 0.3) < Number.EPSILON); // true

Consejo profesional: para dinero, no uses decimales. Guarda céntimos como enteros. En Nómada Tareas trabajaremos con horas, donde medio punto de precisión es más que suficiente.

6.3 Operaciones matemáticas útiles

const horas = 12.7;

console.log(Math.round(horas));  // 13 — redondeo normal
console.log(Math.floor(horas));  // 12 — hacia abajo
console.log(Math.ceil(horas));   // 13 — hacia arriba
console.log(Math.max(12, 8, 6)); // 12
console.log(Math.min(12, 8, 6)); // 6

El tipo `boolean`: verdadero o falso

Un boolean solo puede valer true o false. Es el tipo de las decisiones.

const estaCompletada = false;
const esUrgente = true;

Los booleanos suelen surgir de comparaciones:

const horasEstimadas = 12;
const esTareaLarga = horasEstimadas > 8;

console.log(esTareaLarga);        // true
console.log(typeof esTareaLarga); // 'boolean'

Convención de nombres: a los booleanos se les pone un nombre que se lea como una afirmación verdadera o falsa: esUrgente, estaCompletada, tieneEtiquetas, puedeEditarse. Compara if (estaCompletada) con if (completada): el primero se lee solo.

`undefined` y `null`

Los dos representan "ausencia de valor", pero no son lo mismo, y la diferencia es conceptual:

	`undefined`	`null`
Significado	"No se ha asignado ningún valor"	"Deliberadamente vacío"
Quién lo pone	JavaScript, automáticamente	Tú, explícitamente
`typeof`	`'undefined'`	`'object'` (error histórico)
Cuándo aparece	Variable declarada sin valor, parámetro no pasado, propiedad inexistente	Cuando decides que algo está vacío

// undefined: JavaScript no tiene nada que poner
let siguienteRevisor;
console.log(siguienteRevisor); // undefined

// null: nosotros declaramos que no hay responsable asignado
let responsable = null;
console.log(responsable); // null

La distinción práctica en Nómada Tareas: si una tarea todavía no tiene responsable, usaremos null (sabemos que está sin asignar). Si consultamos un campo que ni siquiera existe, obtendremos undefined (no hay información).

console.log(null == undefined);  // true  ← comparación laxa
console.log(null === undefined); // false ← comparación estricta

Ese contraste es la puerta de entrada a la próxima lección; ahí verás por qué ocurre.

`symbol` y `bigint`

Los dos primitivos restantes son especializados. Basta con que sepas que existen.

symbol (ES2015) crea identificadores únicos e irrepetibles, usados sobre todo como claves de propiedad que no colisionan con otras:

const clave1 = Symbol('id');
const clave2 = Symbol('id');
console.log(clave1 === clave2); // false — cada símbolo es único

bigint (ES2020) permite trabajar con enteros mayores de los que number puede representar con exactitud. Se escribe añadiendo n al final:

const enorme = 9007199254740993n;
console.log(typeof enorme); // 'bigint'

Es útil en criptografía o identificadores muy grandes. En Nómada Tareas no lo necesitaremos: los id de tarea serán números normales.

Primitivos frente a referencias

Esta es la idea más importante de la lección y la que más errores evita a largo plazo.

Los valores primitivos se copian por valor. Al asignar una variable primitiva a otra, se copia el contenido: quedan dos valores independientes.

let horasIvan = 12;
let horasLucia = horasIvan; // se copia el valor 12

horasLucia = 8;

console.log(horasIvan);  // 12 — no le ha afectado
console.log(horasLucia); // 8

Los objetos y arrays se copian por referencia. Al asignarlos, no se copia el contenido: se copia la dirección donde está el contenido. Las dos variables apuntan al mismo sitio.

const etiquetasIvan = ['diseño', 'espacio'];
const etiquetasCopia = etiquetasIvan; // se copia la referencia, no la lista

etiquetasCopia.push('urgente');

console.log(etiquetasIvan);  // ['diseño', 'espacio', 'urgente'] ← ¡también cambió!
console.log(etiquetasCopia); // ['diseño', 'espacio', 'urgente']

Esto sorprende siempre la primera vez. La analogía habitual: un primitivo es como fotocopiar un documento (dos papeles independientes); un objeto es como enviar la dirección de una casa (dos personas con la misma dirección entran a la misma casa).

flowchart TD
    subgraph PR["Primitivos: copia por valor"]
        A1["horasIvan → 12"]
        A2["horasLucia → 12"]
        A1 -.->|copia independiente| A2
    end
    subgraph RE["Objetos: copia por referencia"]
        B1["etiquetasIvan"] --> C["['diseño','espacio','urgente']"]
        B2["etiquetasCopia"] --> C
    end

Y esto explica también el comportamiento de const que vimos antes: const protege la referencia, no el contenido apuntado.

Cómo copiar objetos de verdad (copia superficial y profunda) se estudia en JSON y Copias de Objetos. Por ahora quédate con la idea: primitivos, copia; objetos, referencia compartida.

Modelar una tarea de Nómada Tareas

Apliquemos todo lo aprendido. Estos son los campos de una tarea de Taller Nómada con el tipo que le corresponde a cada uno:

Campo	Tipo	Por qué ese tipo	Ejemplo
`id`	`number`	Identificador numérico correlativo	`1`
`titulo`	`string`	Texto libre	`'Rediseñar la sala polivalente'`
`responsable`	`string` (o `null`)	Nombre de la persona; `null` si está sin asignar	`'Iván'`
`prioridad`	`string`	Uno de tres valores fijos	`'alta'`
`estado`	`string`	Uno de tres valores fijos	`'en-curso'`
`etiquetas`	`array` de `string`	Cero o más etiquetas	`['diseño', 'espacio']`
`horasEstimadas`	`number`	Cantidad, admite decimales	`12`
`fechaLimite`	`string`	Fecha ISO `'yyyy-mm-dd'`: se ordena bien como texto	`'2026-09-30'`

Y el código, usando solo lo visto en esta lección:

'use strict';

// --- Tarea 1 de Taller Nómada -------------------------------------
const id = 1;                                    // number
const titulo = 'Rediseñar la sala polivalente';  // string
const responsable = 'Iván';                      // string
const prioridad = 'alta';                        // string
let estado = 'en-curso';                         // string (cambiará: let)
const etiquetas = ['diseño', 'espacio'];         // array de strings
const horasEstimadas = 12;                       // number
const fechaLimite = '2026-09-30';                // string ISO

// Un valor derivado, calculado a partir de otros
const esTareaLarga = horasEstimadas > 8;         // boolean

// Todavía no sabemos quién la revisará
const revisor = null;                            // null: vacío a propósito

// Resumen con template literals
console.log(`[${id}] ${titulo}`);
console.log(`Responsable: ${responsable} · Prioridad: ${prioridad}`);
console.log(`Estado: ${estado} · ${horasEstimadas} h · Vence: ${fechaLimite}`);
console.log(`Etiquetas: ${etiquetas.join(', ')}`);
console.log(`¿Tarea larga? ${esTareaLarga}`);
console.log(`Revisor asignado: ${revisor}`);

Salida:

[1] Rediseñar la sala polivalente
Responsable: Iván · Prioridad: alta
Estado: en-curso · 12 h · Vence: 2026-09-30
Etiquetas: diseño, espacio
¿Tarea larga? true
Revisor asignado: null

Decisiones de diseño que conviene entender:

estado es let porque una tarea pasa de 'pendiente' a 'en-curso' y a 'hecha'. Todo lo demás es const.
fechaLimite es un string, no un objeto Date. El formato ISO yyyy-mm-dd tiene una propiedad muy práctica: ordenado alfabéticamente coincide con el orden cronológico. Simplifica muchísimo el trabajo.
esTareaLarga no es un dato: es un cálculo. Se deriva de horasEstimadas. No se guarda como campo de la tarea.
revisor es null, no undefined. Estamos afirmando que no hay revisor, no que no sepamos nada del asunto.

Ahora mismo son ocho variables sueltas, lo cual es incómodo si hay que manejar tres tareas. En el Módulo 4 aprenderás a agruparlas en un objeto, que es como estarán realmente en Nómada Tareas.

Errores Comunes y Consejos

Errores comunes

Creer que const congela el contenido. Protege la variable frente a reasignaciones, no el objeto al que apunta.
Usar let por defecto. Empieza siempre por const y cambia a let solo cuando el compilador mental te diga "esto cambia".
Confundir el número 12 con el string '12'. Parecen iguales en la consola pero se comportan de forma muy distinta: 12 + 12 es 24, '12' + '12' es '1212'. La próxima lección se dedica a esto.
Comparar decimales con ===. 0.1 + 0.2 === 0.3 es false. Usa toFixed o una tolerancia.
Comparar con NaN. NaN === NaN es false. Usa Number.isNaN().
Usar null y undefined indistintamente. undefined lo pone JavaScript; null lo pones tú. Mantén la distinción y tu código dirá más.
Copiar un array esperando independencia. const copia = original; no copia nada: comparte la misma lista.

Consejos

const por defecto, let cuando cambie, var nunca.
Usa template literals para todo texto que combine variables. Menos errores y mejor lectura.
Nombra los booleanos como afirmaciones: esUrgente, estaHecha, tieneRevisor.
Usa typeof cuando algo se comporte de forma rara. Un console.log(typeof x, x) resuelve la mitad de los misterios.
Guarda las fechas en formato ISO 'yyyy-mm-dd'. Se ordenan solas y se leen igual en cualquier país.
Escribe los números decimales con cuidado en dinero y porcentajes. Redondea al mostrar, no al calcular.

Ejercicios

Ejercicio 1: Elige el tipo correcto

Para cada dato de Taller Nómada, indica el tipo más adecuado, si usarías let o const, y escribe la línea de código:

El identificador de una tarea, que vale 7 y no cambiará.
El número de tareas pendientes, que irá variando.
Si el taller de serigrafía está reservado para el jueves.
El nombre de la persona que revisará la tarea, todavía sin decidir.
El número máximo de horas semanales del equipo: 40, valor fijo de configuración.
Las horas dedicadas hasta ahora, que valen 3.5 y aumentarán.

Ejercicio 2: Predice la salida

Sin ejecutar el código, escribe lo que imprime cada línea y explica por qué:

let horasIvan = 12;
let horasLucia = horasIvan;
horasLucia = 8;
console.log(horasIvan, horasLucia);          // A

const etiquetas = ['diseño'];
const copia = etiquetas;
copia.push('urgente');
console.log(etiquetas.length);               // B

console.log(typeof null);                    // C
console.log(typeof NaN);                     // D
console.log(0.1 + 0.2 === 0.3);              // E

const titulo = 'Revisar facturas';
titulo.toUpperCase();
console.log(titulo);                         // F

let revisor;
console.log(revisor === null);               // G

Ejercicio 3: Ficha completa con template literals

Escribe un script que declare, con el tipo y la palabra clave adecuados, todos los campos de esta tarea:

id: 4
Título: Montar la exposición de otoño
Responsable: Lucía
Prioridad: media
Estado: pendiente (podrá cambiar)
Etiquetas: montaje, evento
Horas estimadas: 7.5
Fecha límite: 2026-11-05

Después, calcula y muestra:

Una cabecera con el id y el título, usando un template literal.
Una línea con responsable, prioridad y estado.
Un booleano esTareaLarga (más de 8 horas) mostrado como texto.
El número de etiquetas.
El título en mayúsculas, comprobando después que el original sigue intacto.
El tipo de horasEstimadas y el de fechaLimite, usando typeof.

Soluciones

Ejercicio 1

#	Tipo	Palabra clave	Código
1	`number`	`const`	`const id = 7;`
2	`number`	`let`	`let tareasPendientes = 5;`
3	`boolean`	`const`	`const estaReservadoJueves = true;`
4	`null`	`let`	`let revisor = null;`
5	`number`	`const`	`const MAX_HORAS_SEMANA = 40;`
6	`number`	`let`	`let horasDedicadas = 3.5;`

El caso 4 merece un comentario: usamos null porque sabemos que no hay revisor asignado, y let porque más adelante habrá uno. El caso 5 va en UPPER_SNAKE_CASE por ser una constante global de configuración.

Ejercicio 2

Línea	Salida	Explicación
A	`12 8`	Los números son primitivos: al asignar se copia el valor, quedan independientes
B	`2`	Los arrays se copian por referencia: `copia` y `etiquetas` son la misma lista
C	`'object'`	Error histórico de 1995 que nunca se corrigió por compatibilidad
D	`'number'`	`NaN` es de tipo `number`: representa un resultado numérico inválido
E	`false`	`0.1 + 0.2` da `0.30000000000000004` por la representación binaria IEEE 754
F	`'Revisar facturas'`	Los strings son inmutables: `toUpperCase()` devuelve uno nuevo que aquí se descarta
G	`false`	`revisor` vale `undefined`, y `undefined === null` es `false` (tipos distintos)

Ejercicio 3

'use strict';

// --- Datos de la tarea --------------------------------------------
const id = 4;
const titulo = 'Montar la exposición de otoño';
const responsable = 'Lucía';
const prioridad = 'media';
let estado = 'pendiente';                  // let: cambiará con el tiempo
const etiquetas = ['montaje', 'evento'];
const horasEstimadas = 7.5;
const fechaLimite = '2026-11-05';

// --- Valores derivados --------------------------------------------
const esTareaLarga = horasEstimadas > 8;   // false
const tituloEnMayusculas = titulo.toUpperCase();

// --- Salida --------------------------------------------------------
console.log(`[${id}] ${titulo}`);
console.log(`Responsable: ${responsable} · Prioridad: ${prioridad} · Estado: ${estado}`);
console.log(`¿Tarea larga? ${esTareaLarga} (${horasEstimadas} h, vence ${fechaLimite})`);
console.log(`Etiquetas (${etiquetas.length}): ${etiquetas.join(', ')}`);
console.log(`En mayúsculas: ${tituloEnMayusculas}`);
console.log(`Original intacto: ${titulo}`);
console.log(`Tipo de horasEstimadas: ${typeof horasEstimadas}`);
console.log(`Tipo de fechaLimite: ${typeof fechaLimite}`);

Salida:

[4] Montar la exposición de otoño
Responsable: Lucía · Prioridad: media · Estado: pendiente
¿Tarea larga? false (7.5 h, vence 2026-11-05)
Etiquetas (2): montaje, evento
En mayúsculas: MONTAR LA EXPOSICIÓN DE OTOÑO
Original intacto: Montar la exposición de otoño
Tipo de horasEstimadas: number
Tipo de fechaLimite: string

Fíjate en la última línea: fechaLimite es un string, no un tipo de fecha. Es una decisión deliberada del proyecto y la mantendremos durante todo el curso.

Conclusión

Ya sabes guardar información. Declaras variables con const por defecto y let cuando el valor cambia, y entiendes por qué var pertenece al pasado (ámbito de función, redeclaración permitida y hoisting engañoso). Conoces el tipado dinámico y el operador typeof, con sus dos rarezas famosas (typeof null y typeof [] devuelven 'object'). Dominas los primitivos: string con sus template literals e interpolación ${}, number con NaN, Infinity y la precisión en coma flotante, boolean, la distinción entre undefined y null, y la existencia de symbol y bigint. Y has entendido la diferencia entre copia por valor (primitivos) y copia por referencia (objetos y arrays), que explica por qué const no congela un array.

Sobre todo, has modelado por primera vez una tarea completa de Nómada Tareas eligiendo el tipo adecuado para cada campo.

Ahora que tienes datos, el paso natural es operar con ellos. En la siguiente lección, Operadores Básicos, aprenderás a sumar horas, calcular porcentajes de avance, combinar condiciones lógicas y usar operadores modernos como ?? y ?.. Con ellos calcularás la carga de trabajo real de Marta, Iván y Lucía.

Variables y Tipos de Datos

Contenido

Qué es una variable

Declarar variables: let y const

2.1 const: el valor no se reasigna

2.2 let: el valor puede cambiar

2.3 Cuál usar

2.4 Un matiz crucial sobre const

var y por qué está desaconsejado

3.1 Problema 1: ámbito de función, no de bloque

3.2 Problema 2: permite redeclarar

3.3 Problema 3: hoisting confuso

3.4 Tabla comparativa

Tipado dinámico y el operador typeof

4.1 El mapa de tipos

El tipo string: texto

5.1 Las tres formas de escribir texto

5.2 Template literals: la forma moderna

5.3 Propiedades y métodos básicos

El tipo number: números

6.1 Valores numéricos especiales

6.2 La precisión en coma flotante

6.3 Operaciones matemáticas útiles

El tipo boolean: verdadero o falso

undefined y null

symbol y bigint

Primitivos frente a referencias

Modelar una tarea de Nómada Tareas

Errores Comunes y Consejos

Ejercicios

Ejercicio 1: Elige el tipo correcto

Ejercicio 2: Predice la salida

Ejercicio 3: Ficha completa con template literals

Soluciones

Conclusión

Curso de JavaScript: De Principiante a Avanzado

Módulo 1: Introducción a JavaScript

Módulo 2: Estructuras de Control

Módulo 3: Funciones

Módulo 4: Objetos y Arrays

Módulo 5: Objetos y Funciones Avanzadas

Módulo 6: El Modelo de Objetos del Documento (DOM)

Módulo 7: APIs del Navegador y Temas Avanzados

Módulo 8: Pruebas y Depuración

Módulo 9: Rendimiento y Optimización

Módulo 10: Frameworks y Librerías de JavaScript

Módulo 11: Proyecto Final