Dominá el objeto process en Node.js: argv, env, códigos de salida y streams stdin/stdout

Introducción

En el ecosistema de Node.js, el objeto global process es la puerta de entrada a todo lo que ocurre fuera del propio proceso de JavaScript: argumentos de línea de comandos, variables de entorno, códigos de salida y los flujos de entrada/salida estándar. Si alguna vez te preguntaste cómo leer los parámetros que le pasás a tu script, cómo configurá variables de entorno o cómo interactuar con la consola de forma programática, este artículo es para vos.

¿A quién va dirigido?

• Desarrolladores que ya manejan JavaScript y quieren dar el siguiente paso en Node.js.
• QA y DevOps que necesitan crear scripts de automatización robustos.
• Estudiantes que buscan entender cómo funciona la capa del sistema operativo desde Node.

¿Qué vas a aprender?

1. Cómo usar process.argv para leer los argumentos de la línea de comandos.
2. Acceder y manipular process.env y entender su alcance.
3. Emitir códigos de salida con process.exit() y por qué son importantes.
4. Trabajar con los streams process.stdin, process.stdout y process.stderr para leer y escribir datos.
5. Buenas prácticas y errores comunes al usar process.

1. process.argv – Argumentos de la línea de comandos

process.argv es un array que contiene todos los argumentos con los que se invocó el proceso. Los dos primeros elementos son siempre:

• process.argv[0]: la ruta al ejecutable de Node.
• process.argv[1]: la ruta al archivo JavaScript que está siendo ejecutado.

A partir del índice 2 aparecen los parámetros que vos le pasás.

1.1. Ejemplo básico

// archivo: args-demo.js
console.log('argv completo:', process.argv);
console.log('solo argumentos:', process.argv.slice(2));

Ejecución esperada

$ node args-demo.js hola mundo --flag=123
argv completo: [ '/usr/local/bin/node', '/ruta/args-demo.js', 'hola', 'mundo', '--flag=123' ]
solo argumentos: [ 'hola',{ 'mundo',      '--flag=123' }]

1.2. Parseo manual de opciones

Aunque existen librerías como yargs o commander, a veces basta con un parseo rápido:

// archivo: simple-parse.js
const args = process.argv.slice(2);
const options = {};
const positional = [];

args.forEach(arg => {
  if (arg.startsWith('--')) {
    const [key, value] = arg.slice(2).split('=');
    options[key] = value !== undefined ? value : true;
  } else {
    positional.push(arg);
  }
});

console.log('positional:', positional);
console.log('options:', options);

Salida esperada

$ node simple-parse.js file.txt --verbose --mode=prod
positional: [ 'file.txt' ]
options: { verbose: true, mode: 'prod' }

2. process.env – Variables de entorno

Las variables de entorno son la forma tradicional de pasar configuración al proceso sin hardcodearla. En Node, están accesibles a través de process.env, que es un objeto tipo Dictionary con pares clave/valor, siempre como cadenas.

2.1. Lectura de variables

// archivo: env-demo.js
console.log('NODE_ENV:', process.env.NODE_ENV);
console.log('HOME:', process.env.HOME);

Ejemplo de ejecución

$ NODE_ENV=production node env-demo.js
NODE_ENV: production
HOME: /home/juan

2.2. Definir variables en tiempo de ejecución

process.env.MI_VARIABLE = 'valor-dinamico';
console.log('MI_VARIABLE:', process.env.MI_VARIABLE);

Nota: Cambiar process.env solo afecta al proceso actual y a los procesos hijos que pueda lanzar con child_process.spawn.

2.3. Seguridad y buenas prácticas

• Nunca guardes secretos (API keys, passwords) en código; usá variables de entorno.
• En producción, cargá variables mediante un gestor como dotenv (solo en desarrollo) o el propio mecanismo del hosting.
• Validá la existencia y el formato de las variables al iniciar la aplicación.

3. Códigos de salida con process.exit()

Los códigos de salida (exit codes) indican al sistema operativo cómo terminó el proceso. Por convención:

• 0 → éxito.
• Cualquier otro número (usualmente entre 1‑255) → error.

3.1. Salida explícita

// archivo: exit-demo.js
if (process.argv.length < 3) {
  console.error('Falta argumento obligatorio');
  process.exit(1); // error de uso
}
console.log('Todo bien');
process.exit(0); // éxito explícito (opcional)

Ejemplo de uso

$ node exit-demo.js
Falta argumento obligatorio
$ echo $?
1
$ node exit-demo.js hola
Todo bien
$ echo $?
0

3.2. Manejo de eventos de salida

Node permite interceptar la señal de salida con el evento process.on('exit', ...).

process.on('exit', code => {
  console.log('Proceso finalizó con código', code);
});
process.exit(2);

Salida

Proceso finalizó con código 2

Importante: Dentro del manejador de exit no podés realizar operaciones asíncronas; el proceso ya está cerrándose.

4. Streams estándar: stdin, stdout y stderr

Los streams de Node son objetos Readable o Writable. Los tres flujos estándar están disponibles como propiedades de process.

4.1. Lectura de stdin

// archivo: leer-stdin.js
process.stdout.write('Escribí algo y presioná ENTER: ');
process.stdin.setEncoding('utf8');
process.stdin.once('data', data => {
  const texto = data.trim();
  console.log('Leíste:', texto);
  process.exit(0);
});

Ejecución

$ node leer-stdin.js
Escribí algo y presioná ENTER: Hola Mundo
Leíste: Hola Mundo

4.2. Escritura en stdout y stderr

console.log('Este es un mensaje normal (stdout)');
console.error('Este es un error (stderr)');

Redirigir la salida:

$ node script.js > salida.txt 2> errores.txt

4.3. Pipe de datos entre procesos

Un caso típico es usar cat para alimentar datos a un script Node:

$ echo 'línea 1
línea 2' | node pipe-demo.js

// archivo: pipe-demo.js
process.stdin.setEncoding('utf8');
let acumulado = '';
process.stdin.on('data', chunk => {
  acumulado += chunk;
});
process.stdin.on('end', () => {
  console.log('Recibí el siguiente texto:
', acumulado);
});

Salida esperada

Recibí el siguiente texto:
 línea 1
 línea 2

5. Buenas prácticas y errores comunes

5.1. Manejo de SIGINT y SIGTERM

process.on('SIGINT', () => {
  console.log('
Recibí SIGINT, cerrando recursos...');
  // cerrar conexiones, etc.
  process.exit(0);
});

Conclusión

Dominar el objeto global process te permite crear herramientas de línea de comandos potentes, scripts de automatización y servicios que interactúan de forma fluida con el entorno del sistema operativo. Repasamos cómo:

• Leer argumentos con process.argv.
• Acceder a variables de entorno mediante process.env.
• Comunicar el estado de tu aplicación con códigos de salida (process.exit).
• Intercambiar datos mediante los streams estándar (stdin, stdout, stderr).

Próximos pasos

1. Implementá un CLI propio usando commander y aprovecha process para la lógica base.
2. Integra manejo de señales (SIGINT, SIGTERM) para cerrar conexiones a bases de datos.
3. Explora el módulo child_process y cómo heredarlo de los streams padre.

Con estos conocimientos, estarás listo para escribir scripts de Node.js que no solo funcionen, sino que también se comporten como herramientas profesionales.