¿Qué es el objeto process y qué puede hacer?

Question

Accepted Answer

**`process`** es un objeto global que provee información sobre, y control sobre, el **proceso actual de Node.js**. Es tu interfaz hacia el entorno, los argumentos de línea de comandos, los streams de E/S, el ciclo de vida y las señales.

## Lectura de variables de entorno

```js
process.env.NODE_ENV;        // "production" | "development"
process.env.DATABASE_URL;    // configuración y secretos inyectados por el entorno
const port = process.env.PORT || 3000;
```

`process.env` es la forma estándar de leer la configuración y los secretos (definidos fuera del código) — algo central en la configuración de twelve-factor.

## Argumentos de línea de comandos

```js
// node script.js --name=Ann
process.argv; // ["node", "/path/script.js", "--name=Ann"]
const args = process.argv.slice(2); // omite los dos primeros
```

## Streams de E/S estándar

```js
process.stdout.write("output
");   // console.log escribe aquí
process.stderr.write("error
");    // console.error escribe aquí
process.stdin.on("data", (chunk) => { /* leer la entrada */ });
```

## Ciclo de vida del proceso y salida

```js
process.exit(0);   // salir con código de éxito (1 = error)
process.exitCode = 1; // preferido: define el código y deja que el proceso termine naturalmente
process.pid;       // el id del proceso
process.cwd();     // directorio de trabajo actual
process.uptime();  // segundos que el proceso lleva en ejecución
```

## Manejo de señales y errores no capturados (para apagado controlado / redes de seguridad)

```js
process.on("SIGTERM", () => { /* limpiar y luego salir — p. ej. al detener un contenedor */ });
process.on("SIGINT", () => { /* Ctrl+C */ });
process.on("uncaughtException", (err) => { log(err); process.exit(1); });
process.on("unhandledRejection", (reason) => { log(reason); });
```

Escuchar `SIGTERM`/`SIGINT` es la manera de implementar un **apagado controlado** (terminar las solicitudes en curso, cerrar las conexiones a la base de datos antes de salir), y los manejadores de errores no capturados son redes de seguridad de último recurso.

## Otros miembros útiles

```js
process.memoryUsage(); // estadísticas del heap (detección de fugas)
process.nextTick(cb);  // programa un callback antes de la siguiente fase del event loop
process.platform;      // "linux" | "darwin" | "win32"
```

## Por qué es importante

`process` es la conexión de tu programa con su entorno de ejecución.

Lo usas constantemente: leer la configuración/secretos vía `process.env`, manejar los argumentos de la CLI y — de forma importante para producción — capturar señales para un apagado controlado y manejadores de error de último recurso.

Entenderlo es esencial para construir aplicaciones de Node configurables, robustas y listas para producción.