En la lección anterior seguiste un ciclo que conoces bien: escribir código, guardar, ejecutar node src/catalogo.js, leer la salida, corregir, repetir. Ese ciclo es correcto para construir un programa, pero es lentísimo cuando lo que quieres es responder a una pregunta pequeña: ¿cómo se comporta reduce con este array?, ¿qué devuelve exactamente Object.entries sobre una sesión?, ¿cuánto suma el aforo total del Auditorio Ribera?

Para eso existe el REPL: un intérprete interactivo donde escribes una expresión y ves el resultado al instante. Es una de las herramientas más infravaloradas del ecosistema y, bien usada, ahorra horas. En esta lección aprenderás a manejarlo con soltura y a explorar en vivo los datos de Escena Viva antes de escribirlos en un script.

1. Qué es un REPL y para qué sirve
2. Arrancar el REPL y evaluar expresiones
3. La variable _ y el resultado de las declaraciones
4. Autocompletado, historial y navegación
5. Los comandos de punto
6. Cargar el catálogo de Escena Viva en el REPL
7. Explorar y transformar los datos en vivo
8. El modo .editor para funciones de varias líneas
9. Ejecutar código suelto sin REPL: node -e y node -p
10. Peculiaridades: promesas, await de nivel superior y otras sorpresas
11. Cuándo usar el REPL y cuándo no

REPL son las siglas de Read-Eval-Print-Loop: leer, evaluar, imprimir y repetir. Es un bucle que:

1. Lee (Read) lo que escribes.
2. Lo evalúa (Eval) como código JavaScript.
3. Imprime (Print) el resultado.
4. Repite (Loop) esperando la siguiente línea.

No es una peculiaridad de Node: la consola del navegador es un REPL, y también lo son python, irb o psql. Su valor está en el coste cero del experimento: probar algo no requiere crear ficheros ni recordar rutas.

Usos reales en el día a día:

• Comprobar el comportamiento exacto de un método de array que no usas a menudo.
• Verificar una expresión regular antes de meterla en el código.
• Explorar la forma de unos datos que acabas de recibir.
• Convertir valores rápidamente (fechas, céntimos a euros, bytes a megabytes).
• Comprobar qué exporta un módulo instalado, sin leer su documentación.

Escribe node sin argumentos:

El símbolo > indica que el REPL espera una línea. Prueba:

El REPL mantiene el estado entre líneas: las variables que declaras siguen existiendo.

También funciona con código de varias líneas: si una línea está incompleta, el símbolo cambia a ... y el REPL espera a que cierres.

Para salir: .exit, o Ctrl+D, o Ctrl+C dos veces.

Habrás notado algo desconcertante: al escribir const sala = 'Auditorio Ribera' el REPL respondió undefined. No es un error. El REPL imprime el valor de la expresión evaluada, y en JavaScript una declaración de variable no produce ningún valor: produce undefined.

Lo mismo ocurre con function, class, bucles y console.log (que devuelve undefined después de imprimir):

La primera línea es lo que imprime console.log; la segunda es su valor de retorno. Con el tiempo dejas de verlo.

_ guarda el resultado de la última expresión evaluada. Es comodísimo para encadenar exploraciones sin declarar variables intermedias.

Hay una variable hermana, _error, que guarda el último error lanzado:

Cuidado: si asignas manualmente _ = 5, pierdes esta funcionalidad en esa sesión (el REPL te avisa). Evita usar _ como nombre de variable propia.

Estas teclas convierten el REPL en algo verdaderamente rápido:

El autocompletado es la joya. Escribe un objeto y un punto, y pulsa Tab:

También funciona con módulos internos, lo que lo convierte en una documentación instantánea:

El historial se conserva entre sesiones en el fichero ~/.node_repl_history. Puedes cerrar el REPL, abrirlo mañana y recuperar con ↑ lo que probaste hoy.

Todo lo que empieza por . en el REPL es una orden del propio REPL, no JavaScript.

Ejemplo del ciclo completo .load / .save:

.save escribe todas las líneas que has tecleado (no los resultados). Es una forma cómoda de rescatar una exploración que ha salido bien y convertirla en el punto de partida de un script.

.break te salva del atasco clásico:

Sin .break (o Ctrl+C), el REPL se queda esperando eternamente el cierre de la llave.

.clear merece un aviso: reinicia el contexto y pierdes todas las variables definidas. Úsalo cuando quieras empezar de cero, no por error.

Aquí está la aplicación práctica de .load. Vamos a preparar un fichero que contenga solo los datos, sin la parte de presentación ni el filtrado por argumentos, para poder cargarlo limpiamente en el REPL.

Crea src/catalogo-datos.js:

Ahora, desde la raíz del proyecto:

El REPL muestra el contenido del fichero mientras lo evalúa línea a línea. Al terminar, la constante catalogo existe en tu sesión:

Punto importante: .load no es lo mismo que require. .load copia y evalúa el texto del fichero dentro del contexto del REPL, como si lo hubieras tecleado. require carga un módulo aislado y solo te da lo que ese módulo exporta. Por eso .load funciona aunque el fichero no exporte nada, y por eso es la herramienta ideal para explorar. Los módulos de verdad llegan en el Módulo 2.

Con el catálogo cargado, empieza lo divertido: probar transformaciones antes de escribirlas en el script.

Para inspeccionar un objeto anidado sin que Node lo recorte con [Object]:

Las sesiones están anidadas dentro de cada evento. Para trabajar con todas a la vez:

Y si necesitamos saber a qué evento pertenece cada una, añadimos el dato al aplanar:

El operador ... (propagación) copia todas las propiedades del objeto original y añade las nuevas. Lo estudiaremos formalmente en la siguiente lección.

Sesenta y cuatro mil doscientos ochenta y seis euros de recaudación acumulada. Este es exactamente el tipo de pregunta que respondes en veinte segundos en el REPL y que tardarías cinco minutos en programar, guardar y ejecutar.

Nota el [...sesiones] antes de sort: sort modifica el array original. Copiarlo primero evita alterar los datos que estás explorando. Es un error clásico que el REPL te ayuda a descubrir.

El operador ?? devuelve el valor de la derecha solo si el de la izquierda es null o undefined. Lo veremos en detalle en la próxima lección.

Escribir una función de diez líneas en el REPL línea a línea es incómodo: si te equivocas en la tercera, no puedes volver atrás. Para eso está .editor.

Pulsa Ctrl+D para salir del modo editor y evaluar todo el bloque de golpe. Luego pruébala:

Cuando la función funciona, .save informes/exploracion.js guarda la sesión y ya tienes el código listo para pegarlo en src/.

Ctrl+D termina, Ctrl+C cancela. Confundirlos hace perder el bloque entero. En Windows, si Ctrl+D no responde, prueba con Ctrl+Z seguido de Enter.

A veces solo quieres una respuesta y no una sesión interactiva. Node acepta código directamente desde la línea de comandos.

Un caso muy práctico: procesar un fichero JSON desde la terminal sin instalar herramientas adicionales.

Node sabe leer un .json con require y devolverlo ya convertido en objeto. Este truco te resolverá muchas comprobaciones rápidas a partir del Módulo 3, cuando el fichero datos/eventos.json sea la fuente real del catálogo.

También puedes encadenar el REPL con una tubería, aunque en ese caso no verás el símbolo >:

El REPL de Node soporta await en el nivel superior, algo que en un fichero .js de tipo CommonJS no se puede hacer. Esto lo convierte en un banco de pruebas excelente para código asíncrono (tema del Módulo 2).

Si no usas await, el REPL te muestra la promesa, no su valor:

Poco después el REPL imprime el resultado resuelto por su cuenta, lo que puede parecer que "aparece de la nada". No te alarmes: es el REPL informando de que la promesa se ha resuelto.

Prueba tú mismo la primera:

En el primer caso, JavaScript lee { como inicio de bloque y titulo: como una etiqueta; el valor del bloque es la última expresión. Con paréntesis, se fuerza la interpretación como objeto literal.

El REPL es una herramienta de exploración, no de construcción. Esta tabla resume la elección correcta:

La regla es sencilla: si vas a necesitar el resultado más de una vez, no pertenece al REPL. Prototipa en el REPL, guarda con .save, refina en un fichero.

Y sobre el depurador: el REPL te dice qué hace una expresión aislada; el depurador te deja detener un programa en marcha, en la línea que quieras, e inspeccionar todas sus variables en ese instante. Son complementarios, no alternativos.

Error 1: alarmarse por el undefined tras cada declaración. Es el valor de la expresión, no un fallo. const x = 5 no produce ningún valor.

Error 2: escribir { clave: valor } esperando un objeto. El REPL lo lee como un bloque. Envuélvelo en paréntesis.

Error 3: quedarse atrapado en el símbolo .... Has dejado una llave, un paréntesis o una comilla sin cerrar. Sal con .break o Ctrl+C.

Error 4: confundir .load con require. .load evalúa el texto en tu sesión (ves todas las variables). require devuelve solo lo exportado.

Error 5: usar .clear sin querer. Borra todas las variables de la sesión. Si has invertido tiempo en cargar y transformar datos, primero .save.

Error 6: ordenar con sort y estropear el array original. sort, reverse, splice, push y pop modifican el array. Copia con [...array] antes de ordenar.

Consejo 1: usa _ sin miedo. Encadenar _ es la forma más rápida de refinar un cálculo paso a paso.

Consejo 2: .save al terminar una exploración productiva. Guardar en informes/ la sesión te evita reconstruir el razonamiento mañana.

Consejo 3: el Tab es tu documentación. Antes de buscar en internet qué métodos tiene path, escribe path. y pulsa Tab dos veces.

Consejo 4: mantén un REPL abierto en una pestaña de la terminal. Con el catálogo cargado, resolver dudas cuesta segundos.

Abre el REPL, carga src/catalogo-datos.js con .load y responde a estas preguntas usando una sola expresión cada vez. Anota el comando y el resultado.

1. ¿Cuántas sesiones hay en total en el catálogo?
2. ¿Cuál es el precio medio de una entrada, en euros?
3. ¿Qué eventos tienen más de dos sesiones?
4. ¿Cuántas entradas quedan sin vender en todo el catálogo?
5. ¿Cuál es la sesión más cara y a qué evento pertenece?

Usando .editor, escribe una función sesionesPorMes(eventos) que devuelva un objeto donde cada clave sea el mes en formato AAAA-MM y el valor el número de sesiones programadas ese mes. Pruébala con el catálogo y muestra el resultado con console.table. Después guarda la sesión en informes/exploracion-meses.js con .save.

Pista: sesion.fechaHora es una cadena ISO como '2026-10-03T20:00:00', así que el mes se puede extraer con slice(0, 7).

Sin abrir el REPL, escribe los comandos node -e o node -p que resuelvan lo siguiente:

1. Imprimir la versión mayor de Node instalada (solo el número, por ejemplo 24).
2. Imprimir cuántos milisegundos faltan desde ahora hasta el Concierto de Otono (2026-10-03T20:00:00).
3. Convertir 4200 céntimos a la cadena '42.00'.
4. Comprobar si la carpeta informes existe en el proyecto (imprimir true o false).

Solución 1

Alternativa más legible, en dos pasos con _:

(17.800 céntimos entre 7 sesiones = 2.542,86 céntimos, es decir 25,43 EUR.)

Aquí sort sobre el resultado de flatMap es seguro: ese array es nuevo, no el original.

Solución 2

Ctrl+D y a probar:

Ten en cuenta que .save guarda toda la sesión, incluidas las líneas fallidas. Revisa el fichero antes de reutilizarlo.

Solución 3

En el punto 2, restar dos objetos Date los convierte automáticamente a milisegundos desde época y devuelve la diferencia. Si prefieres días:

El REPL es el laboratorio de Node.js: un entorno donde probar ideas cuesta cero. Has aprendido a arrancarlo con node, a interpretar el undefined de las declaraciones, a encadenar cálculos con _, a moverte con Tab y el historial, y a manejar los comandos de punto —.help, .editor, .save, .load, .break, .clear, .exit—.

Lo has aplicado a Escena Viva creando src/catalogo-datos.js y cargándolo con .load para explorar en vivo: aplanar sesiones con flatMap, calcular la recaudación acumulada con reduce, detectar la sesión más cara con sort o descubrir que hay 1.189 entradas por vender. También has visto node -e y node -p para comprobaciones desde la terminal, y las peculiaridades que confunden al principio: los objetos literales que necesitan paréntesis, las promesas pendientes y el await de nivel superior.

Y sobre todo tienes claro el límite: el REPL sirve para explorar; lo que debe repetirse va a un fichero, y lo que debe garantizarse va a un test.

En esa exploración han aparecido, casi de contrabando, herramientas del JavaScript moderno: flatMap, el operador de propagación ..., la coalescencia nula ??, las funciones flecha y la desestructuración. En la siguiente lección, JavaScript Moderno para Node.js, las estudiaremos una por una y con calma, siempre resolviendo un problema real del catálogo de Escena Viva. Es el repaso que sostendrá todo el código que escribas de aquí al final del curso.