Process IO and Events

The Control Room: Mastering Node.js Process IO and Events

Imagine your Node.js app is a spaceship. The process object is your control room — it tells you everything about your journey and lets you communicate with the universe outside!

What is the Process Object?

Think of the process object as your spaceship’s main dashboard. It shows you:

• Where you are
• What fuel (memory) you’re using
• What commands were given at launch
• How to talk to the outside world

The process object is always available — you don’t need to import anything!

// It's already there, ready to use!
console.log(process.version);
// → v20.10.0

console.log(process.platform);
// → linux (or darwin, win32)

Quick Dashboard Tour

process.argv — The Launch Commands

When you launch a spaceship, you give it instructions. process.argv is the list of all those instructions!

The Story

Imagine yelling commands when your spaceship takes off:

“Go to Mars! Speed: Fast! Bring snacks!”

Node.js captures ALL of this in an array.

// Run: node app.js hello world
console.log(process.argv);

Output:

[
  '/usr/bin/node',    // The engine (Node itself)
  '/home/app.js',     // Your spaceship (your file)
  'hello',            // First command you gave
  'world'             // Second command you gave
]

Getting Your Actual Arguments

Skip the first two — they’re always Node and your file:

const myArgs = process.argv.slice(2);
console.log(myArgs);
// → ['hello', 'world']

Real Example: A Greeter

// Run: node greet.js Alice
const name = process.argv[2] || 'Friend';
console.log(`Hello, ${name}!`);
// → Hello, Alice!

process.env — Secret Supplies

process.env is like the secret compartment in your spaceship where you store sensitive things — passwords, API keys, configurations.

Why Use It?

You wouldn’t paint your password on the spaceship’s hull, right? Environment variables keep secrets safe and separate from your code.

// Someone sets: DATABASE_URL=mongodb://secret
console.log(process.env.DATABASE_URL);
// → mongodb://secret

Setting Environment Variables

On the command line:

# Linux/Mac
API_KEY=abc123 node app.js

# Windows (cmd)
set API_KEY=abc123 && node app.js

In your code (for testing):

process.env.MY_VAR = 'testing';
console.log(process.env.MY_VAR);
// → testing

Environment Variables Deep Dive

Environment variables are like sticky notes on your spaceship’s dashboard that the crew reads when they need information.

Common Patterns

// Check if we're in production
const isProd = process.env.NODE_ENV === 'production';

// Use a default if not set
const port = process.env.PORT || 3000;

// Boolean check
const debug = process.env.DEBUG === 'true';

The .env Pattern

Many projects use a .env file:

# .env file
DATABASE_URL=mongodb://localhost
API_KEY=super-secret-key
PORT=3000

Then load it with a library like dotenv:

require('dotenv').config();
console.log(process.env.API_KEY);
// → super-secret-key

Standard Streams — Talking to the Universe

Your spaceship needs ways to send and receive messages. Node.js gives you three communication channels:

graph TD
    A["stdin"] -->|Input| B["Your App"]
    B -->|Normal Output| C["stdout"]
    B -->|Errors| D["stderr"]

The Three Channels

Writing Output

// Same as console.log()
process.stdout.write('Hello!\n');

// For errors (same as console.error())
process.stderr.write('Oops!\n');

Reading Input

// Listen for typed data
process.stdin.on('data', (chunk) => {
  const input = chunk.toString().trim();
  console.log(`You said: ${input}`);
});

console.log('Type something:');

Why Two Output Streams?

You can separate them! Send errors to a file, keep normal output on screen:

node app.js > output.txt 2> errors.txt

Process Events — The Alert System

Your spaceship has alarms for different situations. The process object emits events you can listen to!

Common Events

// Before the app exits
process.on('beforeExit', (code) => {
  console.log('About to exit with code:', code);
});

// When the app is exiting
process.on('exit', (code) => {
  console.log('Goodbye! Exit code:', code);
  // Note: Only sync code works here!
});

The Exit Event Gotcha

Inside exit, you can only run synchronous code. No async, no callbacks, no promises!

process.on('exit', () => {
  // ✅ This works
  console.log('Sync goodbye!');

  // ❌ This WON'T work
  setTimeout(() => {
    console.log('Never happens!');
  }, 100);
});

Global Error Events — Catching Disasters

Sometimes things go wrong. The process object can catch errors before they crash your app!

Uncaught Exceptions

When an error isn’t caught by try/catch:

process.on('uncaughtException', (err) => {
  console.error('Uncaught error:', err.message);
  // Log it, clean up, then exit
  process.exit(1);
});

// This error has no try/catch!
throw new Error('Boom!');

Unhandled Promise Rejections

When a Promise fails and nobody catches it:

process.on('unhandledRejection', (reason) => {
  console.error('Promise rejected:', reason);
});

// Oops! No .catch()
Promise.reject('Something went wrong');

Warning Events

Node.js sends warnings (not errors) for deprecated features:

process.on('warning', (warning) => {
  console.log('Warning:', warning.name);
  console.log('Message:', warning.message);
});

Signal Handling — Emergency Protocols

Signals are like emergency buttons from the outside world. Someone presses Ctrl+C? That’s a signal!

Common Signals

Handling Signals

process.on('SIGINT', () => {
  console.log('\nReceived Ctrl+C');
  console.log('Cleaning up...');

  // Do cleanup work here
  process.exit(0);
});

console.log('Press Ctrl+C to stop');

Graceful Shutdown Pattern

let server; // Imagine an HTTP server

process.on('SIGTERM', async () => {
  console.log('Received SIGTERM');

  // Stop accepting new requests
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });

  // Force exit after 10 seconds
  setTimeout(() => {
    process.exit(1);
  }, 10000);
});

Putting It All Together

Here’s a mini-app that uses everything we learned:

// app.js - Run with: node app.js --name=Pilot

// 1. Parse arguments
const args = process.argv.slice(2);
const name = args[0]?.split('=')[1] || 'Astronaut';

// 2. Use environment variables
const mission = process.env.MISSION || 'Explore';

// 3. Output to stdout
process.stdout.write(`Welcome, ${name}!\n`);
process.stdout.write(`Mission: ${mission}\n`);

// 4. Handle errors
process.on('uncaughtException', (err) => {
  process.stderr.write(`Error: ${err.message}\n`);
  process.exit(1);
});

// 5. Handle shutdown
process.on('SIGINT', () => {
  process.stdout.write('\nMission aborted!\n');
  process.exit(0);
});

console.log('Press Ctrl+C to abort mission');

Quick Reference

graph LR
    P["process object"]
    P --> A["argv - Command line args"]
    P --> E["env - Environment vars"]
    P --> S["Streams"]
    S --> SI["stdin - Input"]
    S --> SO["stdout - Output"]
    S --> SE["stderr - Errors"]
    P --> EV["Events"]
    EV --> EX["exit/beforeExit"]
    EV --> ER["uncaughtException"]
    EV --> PR["unhandledRejection"]
    P --> SG["Signals"]
    SG --> INT["SIGINT - Ctrl+C"]
    SG --> TERM["SIGTERM - Kill"]

You Did It!

You now understand the process control room:

• process.argv — Launch commands from the command line
• process.env — Secret configuration storage
• Standard Streams — stdin, stdout, stderr for communication
• Process Events — exit, beforeExit for cleanup
• Error Events — Catching uncaught exceptions and rejections
• Signals — Handling Ctrl+C and shutdown requests

Your spaceship is now fully under your control! You can receive commands, read secrets, communicate with the universe, and handle any emergency that comes your way.

Happy coding, Commander!