Working with Process in Node.js: From Basics to Advanced

8 mins0
Working with Process in Node.js

When we run a Node.js application, it doesn’t just execute JavaScript. it runs inside a process managed by the operating system. This process is what makes your application alive, keeps it running, and provides all the necessary resources like memory, environment variables, and command-line arguments.

In this blog, we’ll learn what a process is in Node.js, why it is important, understand its commonly used properties and methods, and see how it can be useful in real-world applications.

What is Process in Node JS?

A process in Node.js is simply a program that is being executed by the operating system. When you run node app.js, Node.js creates a process that runs as your application. This process has a unique ID, its own memory, space, and can interact with the operating system.

Think of it like running a music player or a browser or any other application. Each one is a process on your computer.

Why is Process Important is Node.js?

The processes are Node.js is important because it allows us to:

  1. Access system information like platform, memory, and up-time.
  2. Read environment variables for secure configuration (API keys, DB credentials).
  3. Work with command-line arguments to build command line interface tools.
  4. Gracefully handle errors and prevent sudden crashes.
  5. Control life-cycle of your app using exit codes.
  6. To Perform cleanup tasks before shutting down application.

What is the Process Object?

The Node.js provides a global process object that gives us information and control with the current running process. It doesn’t required to import. it’s always available or running in your code.

Commonly Used Process Properties In Node.js

The process object in Node.js comes with several built-in properties that help us interact with the running application and its environment. These properties allow us to read command-line arguments, check environment variables, get process IDs, monitor up-time, and more.

Let’s learn more about these properties one by one.

Command-Line Arguments

The argv property gives an array of command-line arguments passed when starting a Node.js app. This is very useful while building CLI tools.

const [,, num1, num2] = process.argv;
console.log(`Sum: ${Number(num1) + Number(num2)}`);

// Run: node calculator.js 10 20
// Output: Sum: 30

Environment Variables

The env property gives access to environment variables. These are key-value pairs used for configuration.

if (process.env.NODE_ENV === "production") {
  console.log("Running in production mode");
} else {
  console.log("Running in development mode");
}

Process IDs

For process IDs there is two properties for that one will return current process ID and another one will return process ID of parent process.

  • pid: Current process ID
  • ppid: Parent process ID
console.log("Process ID:", process.pid);
console.log("Parent Process ID:", process.ppid);

Helpful when monitoring or killing a specific process using tools like kill in Linux.

process.cwd() – Current Working Directory

This property returns the folder where your Node.js process is running. Useful when handling file uploads or serving static files.

console.log("Current directory:", process.cwd());

process.uptime() – Application Uptime

Returns how long the app has been running in seconds.

console.log(`App running for ${process.uptime()} seconds`);

Great for monitoring tools and health checks in production apps.

Methods in Process

The process object in Node.js also provides useful methods that let us control the life-cycle of our application, handle errors, listen to system events, and monitor performance.

These methods are useful for building large scale and productive Node.js applications. Let’s go through most commonly used ones with examples and real-world use cases.

Exit the Process

The exit method ends the Node.js process. In process, 0 means that app exited successfully. However, any non zero code indicates error while exiting the process.

if (!process.env.DB_HOST) {
  console.error("Database host not set!");
  process.exit(1); // Exit with error code
}

As per this example, it will stop application when database connection is not set.

Listen to Process Events

The on method lets us listen to process-level events such as exit, uncaughtException, and operating system signals like SIGINT (Ctrl+C).

process.on("exit", (code) => {
  console.log(`Process exiting with code: ${code}`);
});

process.on("SIGINT", () => {
  console.log("Process interrupted (Ctrl+C)");
  process.exit(0);
});

Before shutting down, you can close database connections, clear cache, or save logs. This ensures the application exits gracefully and avoids data loss.

Monitor Memory Usage

The memoryUsage method returns an object with memory details such as heap size, RSS (Resident Set Size), and external memory.

console.log(process.memoryUsage());

This can be useful for tracking performance and debugging memory leaks in large scale node.js applications.

Conclusion

The process in Node.js is the bridge between your application and the operating system. It provides the ability to read environment variables, work with command-line arguments, manage life-cycle, handle errors, and perform cleanup before shutdown.

For a quick guide on creating QR codes in Node.js, read our blog How to Generate QR Code in Node.js to generate codes dynamically in your applications.

Related Articles