Paths, Environment and Process

Real programs must find their files, remember their settings and answer to the shell that started them. The Node.js for Beginners series now covers the three tools for that job: the path module for safe path maths, process.env for configuration, and the process object for arguments, exit codes and shutdown. Everything from here on assumes these are second nature.

Why path maths needs a module

Paths use / on macOS and Linux but \ on Windows, and concatenating strings by hand breaks the moment your code runs elsewhere. path does the joining with the platform's own separator.

import path from 'node:path';

console.log(path.join('logs', '2026', 'app.txt'));
console.log(path.join('logs', '../secrets.txt'));
console.log(path.resolve('logs', 'app.txt'));
console.log(path.extname('server.js'));
console.log(path.basename('/etc/config/app.json'));

Expected output:

logs/2026/app.txt
secrets.txt
/Users/asha/projects/logs/app.txt
.js
app.json

• join — concatenates and normalises ./..; use it for building relative paths.
• resolve — walks from the current working directory to an absolute path; the last segment that is not absolute is interpreted against process.cwd().
• parse / dirname / extname — split a path into dir, name and extension.

__dirname and friends

CommonJS files get __dirname (the folder holding the file) and __filename. ESM does not — but the standard equivalent ships in modern Node:

// CommonJS
const base = path.join(__dirname, 'templates');

// ESM ("type": "module")
import { fileURLToPath } from 'node:url';
import { dirname } from 'node:path';
const legacyWay = dirname(fileURLToPath(import.meta.url));  // older Node
console.log(import.meta.dirname);                            // Node 21.2+ ✅

Expected output: the absolute directory of the current file. Always anchor file lookups to the file's directory — process.cwd() changes with every shell command and is a classic "works on my machine" source.

process.env: configuration without hard-coding

Environment variables are strings set outside your code — per machine, per environment, never committed.

PORT=3000 NODE_ENV=development node src/server.js

const port = Number(process.env.PORT ?? 3000);
const dev = process.env.NODE_ENV !== 'production';

console.log(`listening on ${port}, dev=${dev}`);
console.log('home dir:', process.env.HOME ?? process.env.USERPROFILE);

Expected output:

listening on 3000, dev=true
home dir: /Users/asha

Node does not read .env files by itself — add dotenv (or node --env-file=.env on Node 20.6+) and keep .env in .gitignore while committing a documented .env.example.

process: arguments, working directory, exit

console.log('args:', process.argv.slice(2));
console.log('cwd :', process.cwd());
console.log('node:', process.version);
console.log('pid :', process.pid);

if (!process.argv[2]) {
  console.error('missing: ');
  process.exitCode = 2;
}

Expected output: argument list, current directory, Node version and the process id; with no argument the script ends with shell status 2 (check with echo $?). Distinct exit codes let scripts and CI distinguish "usage error" from "crash".

Signals and graceful shutdown

Long-running processes are stopped by signals — a Ctrl+C in your terminal sends SIGINT. Production hosts send SIGTERM when redeploying, and a well-built server drains connections instead of dying mid-write:

process.on('SIGTERM', () => {
  console.log('SIGTERM received — closing gracefully');
  server.close(() => process.exit(0));   // stop accepting, finish in-flight
  setTimeout(() => process.exit(1), 5000).unref(); // hard deadline
});

Expected output: on shutdown, the log line prints once, existing requests complete, and the process exits with status 0. Chapter 18 installs this pattern in the project.

Common mistakes

• String-concatenating paths — dir + '/' + file breaks on Windows; use path.join.
• Anchoring to cwd() — scripts stop working when run from another folder; anchor to the file.
• Trusting env types — everything is a string; process.env.PORT === 8080 is never true.
• Committing secrets — keys in .env pushed to Git must be rotated; use environment variables and ignore files.
• Calling process.exit() while writing — truncates logs and responses; set exitCode or drain first.

Practice checklist

1. Build a path from __dirname (or import.meta.dirname) to a data file and read it.
2. Print path.parse(process.argv[1]) and explain each field.
3. Run a script with three custom environment variables and read them back with defaults.
4. Exit with two different codes based on input and verify each in the shell.
5. Register a SIGINT handler that logs before the process ends.

With files, paths and configuration under your belt, the next safety net is what happens when things go wrong. Next: Errors and Debugging in Node.