REPL y primer script

Ya tienes Node instalado. Ahora aprenderás a usar el REPL para probar código al instante, a ejecutar tus primeros archivos y a conocer los objetos globales que Node te da: process, console, argumentos de terminal y más.

Concepto

REPL significa Read–Eval–Print Loop: lee lo que escribes, lo evalúa, imprime el resultado y vuelve a empezar. Es como una calculadora de JavaScript. Ideal para probar una función o recordar cómo funciona un método.

Un script es un archivo .js que ejecutas con node archivo.js. Es lo que usarás en proyectos reales.

El REPL

Escribe node en la terminal sin argumentos:

$ node
Welcome to Node.js v22.x.x.
Type ".help" for more information.
> 2 + 2
4
> const nombres = ['Ana', 'Luis']
undefined
> nombres.map(n => n.toUpperCase())
[ 'ANA', 'LUIS' ]
> _            // el último resultado
[ 'ANA', 'LUIS' ]
> await fetch('https://api.github.com').then(r => r.status)
200

Comandos útiles del REPL:

Comando	Qué hace
.help	Lista los comandos
.editor	Modo multilínea (Ctrl+D para ejecutar)
.load archivo.js	Carga un archivo en la sesión
.save sesion.js	Guarda lo que escribiste
Tab	Autocompleta (prueba fs. + Tab)
.exit o Ctrl+C dos veces	Salir

TIP

En el REPL puedes usar await directamente y los módulos internos están disponibles sin importarlos: escribe os.cpus().length y verás cuántos núcleos tiene tu CPU.

Tu primer script

Crea una carpeta y un archivo:

mkdir hola-node && cd hola-node

// hola.js
const nombre = 'mundo'
const hora = new Date().toLocaleTimeString('es-MX')

console.log(`¡Hola, ${nombre}! Son las ${hora}`)
console.log('Node versión:', process.version)
console.log('Sistema:', process.platform)

node hola.js
# ¡Hola, mundo! Son las 10:32:15
# Node versión: v22.x.x
# Sistema: win32

Modo watch: recarga automática

Node incluye un modo que reinicia el script al guardar cambios (ya no necesitas nodemon):

node --watch hola.js

Objetos globales importantes

process

Representa el proceso actual de Node.

// proceso.js
console.log('PID:', process.pid)
console.log('Carpeta actual:', process.cwd())
console.log('Memoria usada (MB):', (process.memoryUsage().rss / 1024 / 1024).toFixed(1))
console.log('Variable PATH existe:', Boolean(process.env.PATH))

// Terminar el proceso con un código de salida (0 = éxito, distinto de 0 = error)
if (process.argv.includes('--fallar')) {
  console.error('Algo salió mal')
  process.exit(1)
}

Argumentos de terminal: process.argv

// saludar.js
// process.argv = [ruta de node, ruta del script, ...argumentos]
const [, , nombre = 'desconocido', veces = '1'] = process.argv

for (let i = 0; i < Number(veces); i++) {
  console.log(`Hola, ${nombre}`)
}

node saludar.js Ana 3
# Hola, Ana
# Hola, Ana
# Hola, Ana

Para opciones con nombre, Node trae parseArgs:

// cli.mjs
import { parseArgs } from 'node:util'

const { values } = parseArgs({
  options: {
    nombre: { type: 'string', short: 'n', default: 'mundo' },
    gritar: { type: 'boolean', short: 'g', default: false }
  }
})

let saludo = `Hola, ${values.nombre}`
if (values.gritar) saludo = saludo.toUpperCase() + '!!!'
console.log(saludo)

node cli.mjs --nombre Luis -g
# HOLA, LUIS!!!

(Usamos .mjs porque tiene import; en la próxima lección verás por qué.)

console más allá de log

console.info('Información')
console.warn('Advertencia')          // va a stderr
console.error('Error')               // va a stderr
console.table([{ id: 1, nombre: 'Ana' }, { id: 2, nombre: 'Luis' }])
console.time('bucle')
for (let i = 0; i < 1e6; i++) {}
console.timeEnd('bucle')             // bucle: 2.1ms
console.dir({ a: { b: { c: { d: 1 } } } }, { depth: null })

Leer entrada del usuario

// pregunta.mjs
import readline from 'node:readline/promises'
import { stdin as input, stdout as output } from 'node:process'

const rl = readline.createInterface({ input, output })

const nombre = await rl.question('¿Cómo te llamas? ')
const edad = Number(await rl.question('¿Cuántos años tienes? '))

console.log(`${nombre}, en 10 años tendrás ${edad + 10}.`)
rl.close()

Caso real: script de utilidad

Un script que genera contraseñas seguras, algo que podrías usar en tu día a día:

// password.mjs
import { randomInt } from 'node:crypto'
import { parseArgs } from 'node:util'

const { values } = parseArgs({
  options: {
    largo: { type: 'string', short: 'l', default: '16' },
    simbolos: { type: 'boolean', short: 's', default: false }
  }
})

const letras = 'abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'
const especiales = '!@#$%&*?-_'
const caracteres = values.simbolos ? letras + especiales : letras

let password = ''
for (let i = 0; i < Number(values.largo); i++) {
  // randomInt es criptográficamente seguro (Math.random NO lo es)
  password += caracteres[randomInt(caracteres.length)]
}

console.log(password)

node password.mjs -l 20 -s
# k7Qm!xP2_aZr9#tWb4Lh

Buena práctica

Usa node --watch durante el desarrollo y códigos de salida correctos (process.exit(1) ante errores) en scripts: así herramientas como CI o PM2 saben si algo falló.

Error común

Intentar usar document o window en Node: ReferenceError: document is not defined. Node no tiene DOM. Si necesitas algo global, usa globalThis.

Ejercicios

1. Crea calc.mjs que reciba dos números y una operación por argumentos (node calc.mjs 5 3 suma) e imprima el resultado. Si la operación no existe, muestra un error y sal con código 1.
2. Crea edad.mjs que pregunte el año de nacimiento con readline y diga cuántos años cumple este año.

Ver solución

// calc.mjs
const [, , a, b, op] = process.argv
const x = Number(a)
const y = Number(b)

const operaciones = {
  suma: () => x + y,
  resta: () => x - y,
  multiplica: () => x * y,
  divide: () => (y === 0 ? 'No se puede dividir entre 0' : x / y)
}

if (Number.isNaN(x) || Number.isNaN(y) || !operaciones[op]) {
  console.error('Uso: node calc.mjs <num> <num> <suma|resta|multiplica|divide>')
  process.exit(1)
}

console.log(operaciones[op]())

// edad.mjs
import readline from 'node:readline/promises'
import { stdin as input, stdout as output } from 'node:process'

const rl = readline.createInterface({ input, output })
const anio = Number(await rl.question('¿En qué año naciste? '))
rl.close()

const actual = new Date().getFullYear()
if (Number.isNaN(anio) || anio > actual) {
  console.error('Año inválido')
  process.exit(1)
}
console.log(`Este año cumples ${actual - anio} años.`)

Resumen

• node sin argumentos abre el REPL; node archivo.js ejecuta un script.
• node --watch recarga al guardar cambios.
• process da acceso a argumentos (argv), variables de entorno (env), carpeta actual y salida (exit).
• parseArgs y readline/promises permiten crear herramientas de línea de comandos sin librerías.