Global Objects in Node js: How They Can Make or Break Your Code?

Global objects in Node js are built-in objects accessible throughout the runtime without import. They provide core functions like console, process, and global to handle I/O operations, system interaction, and application processes. 

These objects are crucial for tasks such as logging, environment configuration, handling asynchronous operations, managing process state, and interacting with system events.

In this blog, we’ll cover what global objects in Node js are, how they work, and why they’re crucial for writing efficient, high-performance server-side JavaScript.

Understanding global objects is essential for writing efficient backend code in Node.js. If you're looking to strengthen your server-side skills, consider upGrad’s Online Software Development Courses designed for backend developers.

Global Objects in Node js: 12 Common Objects Explained

Global objects in Node js are built-in objects that provide direct access to system-level features and resources, essential for managing runtime and application behavior. These objects enable operations such as file handling, stream management, and data processing. Unlike client-side JavaScript, which uses the window object as the global scope, Node.js uses the global object for server-side operations.

Want to strengthen your Node.js expertise and write production-quality code? Explore upGrad’s tech courses, designed to provide hands-on experience with practical projects and help you build efficient, scalable solutions.

• AI-Powered Full Stack Development Course by IIITB
• Generative AI Foundations Certificate Program
• Post Graduate in Product Management Course from Duke

Let’s explore the 12 most commonly used global objects in Node js and how they simplify development by providing direct access to critical system resources.

1. global

The global object is the root object in a Node.js application, acting as the global context for the runtime environment. It allows variables or functions to be globally accessible, similar to the window object in client-side JavaScript. While helpful in sharing data across the app, it’s generally discouraged for managing application state due to potential debugging issues.

Code Example:

global.myVar = 'Hello, Node.js!';
console.log(myVar);

Explanation: The value 'Hello, Node.js!' is assigned to myVar using global.myVar, making it accessible throughout the application. By logging myVar to the console, it is confirmed that the variable is globally available, even without importing or requiring it.

Output: The value "Hello, Node.js!" is printed to the console. This happens because myVar is set on the global object, making it accessible across modules and functions in the Node.js application.

Hello, Node.js!

2. process

The process object in Node.js provides information and control over the current Node.js process. It enables interaction with the environment, such as accessing environment variables, command-line arguments, and process state. The process object is crucial for controlling the execution flow and managing system-level operations.

Code Example:

console.log(process.env.NODE_ENV);

Explanation: This code accesses the NODE_ENV environment variable from the process.env object and logs it to the console. This is commonly used to distinguish between development and production environments.

Output: The output displays the value of the NODE_ENV environment variable, enabling you to manage environment-specific logic within your application.

development

3. Buffer

In Node.js, a buffer is used to handle raw binary data, allowing for the efficient manipulation of binary data streams. It is advantageous when working with file I/O, networking, or other binary protocols that require high performance without converting binary data into strings.

Code Example:

const buffer = Buffer.from('Hello, Buffer!', 'utf8');
console.log(buffer);

Explanation: The Buffer.from() method creates a buffer from the given string ('Hello, Buffer!'), encoded in UTF-8 format. Buffers are often used when dealing with binary data, such as reading files or network operations.

Output: The output shows the buffer in hexadecimal representation, where each byte corresponds to the encoded value of the characters in the string 'Hello, Buffer!'.

<Buffer 48 65 6c 6c 6f 2c 20 42 75 66 66 65 72 21>

4. __dirname

__dirname provides the absolute path of the directory where the current script resides. It is commonly used to construct file paths relative to the module's location, which is crucial for reliable file system operations in Node.js.

Code Example:

console.log(__dirname);

Explanation: __dirname automatically returns the directory of the currently executing module, making it useful for path manipulation and resolving file locations relative to the script.

Output: The output displays the directory path of the file being executed. This helps in building absolute file paths or referencing files from the same directory or relative locations.

/Users/username/projects/node-app

5. __filename

Similar to __dirname, __filename provides the full path of the currently executing file. This global variable is valid when working with file paths or when debugging to determine the location of the executing file.

Code Example:

console.log(__filename);

Explanation: __filename outputs the complete path, including the filename, of the current script, which helps manage files or debug the application's flow.

Output: The output displays the full path to the app.js file. This is important when you need to load other resources or resolve paths relative to the current file’s location.

/Users/username/projects/node-app/app.js

Finding prototypes, scopes, or async code in JavaScript confusing? Take upGrad’s Advanced JavaScript for All Course to strengthen your understanding of classes, modules, and asynchronous programming, all covered in 25 hours of learning.

6. require

The require function is used to import modules in Node.js. It enables you to load built-in modules, third-party packages, or local files into your application, providing modularity and separation of concerns. The require function is a central part of Node.js’s modular system.

Code Example:

const fs = require('fs');
fs.readFileSync('example.txt', 'utf8');

Explanation: We use require('fs') to import the fs module, and then readFileSync() is called to read the contents of example.txt synchronously.

Output: The output is the content of the file example.txt, demonstrating how to use the require() function to import and interact with modules.

File contents of example.txt

Also Read: Node.js vs JavaScript: Key Differences and Benefits Explained

7. setTimeout() / setInterval()

setTimeout() and setInterval() are global methods in Node.js used for scheduling asynchronous operations. setTimeout() runs a function once after a specified delay, while setInterval() runs a function repeatedly at regular intervals.

Code Example:

setTimeout(() => {
    console.log('Executed after 2 seconds');
}, 2000);

Explanation: This code uses setTimeout() to execute a function that logs a message after a 2-second delay.

Output: The output is logged after a 2-second delay. The use of setTimeout() allows for asynchronous execution, preventing the blocking of the event loop while waiting for the callback to execute.

Executed after 2 seconds

8. console

The console object provides methods for outputting messages to the console, including console.log(), console.error(), and console.warn(). It is widely used for debugging and displaying runtime information.

Code Example:

console.log('This is a normal log.');
console.error('This is an error.');

Explanation: Here, console.log() logs a regular message, while console.error() outputs an error message, helping to differentiate between normal logs and error messages.

Output: The output includes two different log levels, regular and error. This helps developers identify various types of messages and debug issues effectively.

This is a normal log.
This is an error.

9. URL

The URL object in Node.js is used for parsing and manipulating URLs. It allows you to easily break down URLs into their components (e.g., hostname, pathname) or build new URLs from individual parts.

Code Example:

const url = new URL('https://example.com/path?name=John');
console.log(url.hostname);

Explanation: The URL object parses the given URL string and allows you to access various components, such as hostname, pathname, or search.

Output: The hostname part of the URL is extracted, showing how you can easily access and manipulate URL components.

example.com

Also Read: 10 Practical Applications of JavaScript And Career Tips

10. URLSearchParams

URLSearchParams is used to work with query string parameters in URLs. It provides an easy way to parse, manipulate, and construct query strings, making it easier to work with URL parameters.

Code Example:

const params = new URLSearchParams('name=John&age=30');
console.log(params.get('name'));

Explanation: We create a new URLSearchParams object, passing in a query string. The get() method retrieves the value of the name parameter from the query string.

Output: The output shows the value of the name query parameter, 'John'. This demonstrates how you can easily manipulate URL query strings with URLSearchParams

John

Also Read: Node JS Versions: Which One to Download?

11. TextEncoder

The TextEncoder class is used to encode a string into a Uint8Array of bytes. This is useful for working with binary data and is commonly used for encoding text data before sending it over the network or saving it to files.

Code Example:

const encoder = new TextEncoder();
const encoded = encoder.encode('Hello, Node.js!');
console.log(encoded);

Explanation: The TextEncoder object is used to convert the string 'Hello, Node.js!' into a Uint8Array, a byte representation of the string.

Output: The output represents the UTF-8 encoded bytes of the string 'Hello, Node.js!', where each byte corresponds to the character's encoded value.

Uint8Array(13) [72, 101, 108, 108, 111, 44, 32, 78, 111, 100, 101, 46, 115]

12. TextDecoder

TextDecoder is used to decode a Uint8Array (or other binary data) back into a string. It is essential when working with binary data to convert it back into human-readable text.

Code Example:

const decoder = new TextDecoder();
const decoded = decoder.decode(encoded);
console.log(decoded);

Explanation: We use TextDecoder to decode the byte array (encoded) back into the string 'Hello, Node.js!'.

Output: The decoded output is the original string, demonstrating how binary data can be converted back into human-readable text.

Hello, Node.js!

In Node.js, global objects can be beneficial in fields like AI, data science, and machine learning for managing application-wide settings, shared utilities, or system-level configurations across different modules.

Also Read: Node JS vs Python: Difference Between Node JS and Python 

Let’s examine specific use cases where global objects in Node js help optimize performance and improve resource management.

Ideal Scenarios for Using Global Objects in Node js

Global objects in Node js are most beneficial in specific scenarios where efficiency and system-level management are crucial. They provide seamless access to system resources, enabling direct manipulation of critical application processes, memory, and I/O operations.

Below are some ideal situations for utilizing global objects:

1. Managing Application-Wide Configuration

Global objects are useful when configuration settings or constants need to be shared across the entire application. The global object helps store and access data across modules without requiring repeated imports.

Code Example:

// Storing configuration data in the global object
global.config = { appName: "MyApp", debug: true };

// Accessing configuration in another module
console.log(global.config.appName);  // MyApp
console.log(global.config.debug);    // true

Explanation: Here, configuration values are stored in the global.config. These values can then be accessed throughout different parts of the application, reducing the need to pass configuration settings repeatedly between modules.

Output: The configuration values are accessible globally, which simplifies accessing standard settings, such as the application name (appName) and debug status (debug), throughout the app.

MyApp
true

2. Handling Environment-Specific Settings

The process object is essential when working with environment-specific configurations. Using process.env, you can access environment variables that differentiate between development, production, or testing environments.

Code Example:

// Set an environment variable for the current process
process.env.NODE_ENV = 'production';

// Check the environment in the application
if (process.env.NODE_ENV === 'production') {
  console.log('Production mode enabled.');
} else {
  console.log('Development mode enabled.');
}

Explanation: In this code, process.env.NODE_ENV is set to 'production'. The if statement checks this environment variable to determine if the application should run in production or development mode.

Output: Since the NODE_ENV is set to 'production', the application runs in production mode. This allows easy switching between environments using environment variables.

Production mode enabled.

3. Working with Binary Data

For handling raw binary data, such as when reading files or processing network data, the Buffer object is essential. It ensures efficient handling of large amounts of binary data without blocking the event loop.

Code Example:

// Creating a buffer to handle binary data
const buffer = Buffer.from('Hello, Node.js!', 'utf-8');

// Output the buffer content in hexadecimal format
console.log(buffer);

Explanation: The Buffer.from() method creates a buffer containing the string 'Hello, Node.js!' encoded in UTF-8 format. This binary representation is stored in the buffer, which can later be used in network operations or file reading.

Output: The string is converted to its binary representation and stored in a buffer. This is necessary for efficiently handling binary data, especially for performance-sensitive operations.

<Buffer 48 65 6c 6c 6f 2c 20 4e 6f 64 65 2e 6a 73 21>

4. Error Management and Process Monitoring

Node.js allows process-level error handling with the process object. Using process.on('uncaughtException'), you can catch unhandled errors and prevent the application from crashing unexpectedly.

Code Example:

process.on('uncaughtException', (err) => {
  console.error('Caught exception: ', err);
  process.exit(1);  // Exit after handling the error
});

// Simulate an uncaught error
setTimeout(() => {
  throw new Error('Something went wrong!');
}, 1000);

Explanation: This example sets up a global handler for uncaught exceptions using process.on('uncaughtException'). When an uncaught error occurs, the handler logs the error and exits the process to prevent further issues.

Output: The application catches the unhandled error, logs it, and then exits. This prevents the application from crashing abruptly and allows for graceful error handling.

Caught exception:  Error: Something went wrong!

5. Asynchronous Task Scheduling

Global functions like setTimeout() and setImmediate() enable the scheduling of non-blocking, asynchronous tasks. These functions allow you to control the order of task execution without blocking the main event loop, ensuring smooth performance.

Code Example:

// Scheduling a non-blocking task with setTimeout
setTimeout(() => {
  console.log('This task runs after a delay.');
}, 2000);

// Scheduling a task to run immediately after the current event loop
setImmediate(() => {
  console.log('This task runs immediately.');
});

Code Explanation: In this example, setTimeout() schedules a task to run after 2 seconds, while setImmediate() runs a task immediately after the current event loop cycle completes. These functions allow for precise task scheduling without blocking other operations.

Output: setImmediate() executes first because it runs immediately after the current event loop cycle, while setTimeout() runs after the specified 2-second delay. This ensures that tasks are executed in the correct order without blocking the main event loop.

This task runs immediately.
This task runs after a delay.

These scenarios highlight how global objects can be effectively used in Node.js. While they offer significant advantages in terms of simplicity and performance, it’s essential to use them with caution to avoid unintended side effects in large applications.

Curious how global objects and backend code fit into AI-driven apps? Enroll in upGrad’s AI-Driven Full-Stack Development program to apply backend concepts in building innovative software using tools like OpenAI, GitHub Copilot, and more.

Also Read: Top 45+ Node.js Project Ideas for Beginners and Professionals

Let’s explore specific situations where global objects should be avoided and how adopting better approaches can resolve potential issues.

When to Avoid Using Global Objects in Node js?

Global objects in Node js can introduce issues in several scenarios, especially when it comes to maintainability, testability, and performance. Misusing them can lead to data inconsistencies and make debugging complex applications more challenging.

Below are some specific scenarios where using global objects should be avoided:

1. Modifying Shared State

Global objects often expose shared state across your application. When multiple parts of your code modify this shared state, it can lead to inconsistent results, race conditions, and bugs that are difficult to trace, especially in asynchronous environments.

Code Example:

global.counter = 0;

function increment() {
  global.counter++;
}

increment();
console.log(global.counter);
increment();
console.log(global.counter);

Code Explanation: Here, the global.counter is modified by the increment() function. Each time the function is called, it modifies the shared global state. This can lead to unpredictable behavior, especially in larger applications where multiple modules might alter the same global variable.

Output: The counter value is modified globally, which could lead to inconsistent state across the application. This global modification causes side effects that make the application unpredictable.

1
2

Better Approach: To avoid modifying shared state globally, use a local variable to ensure the state is isolated and not exposed to other parts of the application.

let counter = 0;

function increment() {
  counter++;
}

increment();
console.log(counter);
increment();
console.log(counter);

Explanation: By using a local variable (counter), we ensure that it’s scoped to the function and not shared globally. Each function call operates on its isolated state, making the behavior predictable and reducing the risk of side effects.

Output: The output is predictable and isolated to the function, ensuring that other parts of the application do not accidentally modify the state.

1
2

2. Loss of Encapsulation

Global objects violate encapsulation, a key principle of modular programming. Exposing data globally makes it accessible and modifiable from anywhere in the application, which complicates maintenance and debugging.

Code Example:

global.config = { debug: true };

function changeDebugSetting() {
  global.config.debug = false;
}

changeDebugSetting();
console.log(global.config.debug);

Explanation: Here, global.config is used to store configuration data. This data is accessible and modifiable by any part of the application. This lack of control over the data exposes the application to unintentional changes.

Output: The config.debug value is changed globally by changeDebugSetting(), which can result in inconsistent configuration states across the application.

false

Better Approach: To maintain encapsulation and ensure that data is not directly modified, use a local scope for configuration and expose only necessary data.

const config = { debug: true };

function changeDebugSetting() {
  config.debug = false;
}

changeDebugSetting();
console.log(config.debug);

Code Explanation: The configuration data is encapsulated within a module, and only the necessary parts are exposed. The internal state is protected, and modification is controlled via functions.

Output: The configuration is controlled within the module, and the value is changed only through the changeDebugSetting() function, ensuring better data integrity and control.

false

3. Impact on Testability

Global state can interfere with testing. Since global variables persist across tests, one test may modify a global variable, leading to inconsistent results in other tests. This reduces the reliability of unit tests and increases the complexity of debugging.

Code Example:

global.state = { value: 10 };

function addValue(num) {
  global.state.value += num;
}

addValue(5);
console.log(global.state.value);

Explanation: The global.state object is modified globally, making it difficult to isolate tests. Since global state persists across tests, modifying it in one test can affect others, leading to unreliable and flaky tests.

Output: The global state is changed by the addValue() function, and this modification persists across function calls and tests. This could lead to conflicts when tests depend on the same global state.

15

Better Approach: To make the code more testable and avoid shared global state, use local variables within the scope of each test.

let state = { value: 10 };

function addValue(num) {
  state.value += num;
}

addValue(5);
console.log(state.value);

Explanation: By using a local variable (state), each test can run independently without modifying a shared global state. This ensures tests are isolated and more reliable.

Output: The test now operates on an isolated local state, ensuring consistent results and preventing interference from other tests.

15

4. Performance Issues

Global objects persist throughout the entire runtime of a Node.js application, preventing garbage collection and potentially leading to memory leaks. This is particularly problematic when large objects are stored globally.

Code Example:

global.largeObject = new Array(1000000).fill('data');

function processData() {
  // Simulate some operation
}

processData();

Explanation: Here, a large array is stored in global.largeObject. Since it is stored globally, it remains in memory throughout the application’s lifecycle. This prevents it from being garbage collected, leading to potential memory issues.

Output: No immediate output, but memory usage will increase over time due to the large object being retained globally. Since it is not eligible for garbage collection, it will persist throughout the application lifecycle, causing increased memory consumption.

Better Approach: To avoid memory leaks and improve performance, scope large objects within functions so they can be cleaned up after execution is complete.

function processData() {
  let largeObject = new Array(1000000).fill('data');
  // Perform operation
}

processData();

Explanation: The large object is scoped locally within the function, allowing it to be cleaned up after the function execution. This prevents unnecessary memory usage and ensures proper garbage collection.

Output: No immediate output, but the memory used by largeObject will be released once the function execution is complete. This ensures better memory management and helps prevent memory leaks.

5. Concurrency Problems

Global objects can cause race conditions when multiple asynchronous operations modify the same global state simultaneously. This leads to inconsistent data and unpredictable behavior in concurrent environments.

Code Example:

global.counter = 0;

setTimeout(() => {
  global.counter++;
}, 1000);

setTimeout(() => {
  global.counter++;
}, 500);

setTimeout(() => {
  console.log(global.counter);  // Output can vary between 1 or 2
}, 1500);

Explanation: Multiple asynchronous tasks attempt to modify global.counter at different intervals. The outcome depends on the order in which these tasks are completed, which introduces race conditions and makes the final value unpredictable.

Output: Since the asynchronous tasks modify global.counter independently, the final result depends on the timing of the setTimeout() calls, leading to inconsistent outcomes.

1
or
2

Better Approach: To avoid race conditions, use local variables and ensure that each asynchronous task operates on isolated data.

let counter = 0;

setTimeout(() => {
  counter++;
}, 1000);

setTimeout(() => {
  counter++;
}, 500);

setTimeout(() => {
  console.log(counter);  // Always outputs 2
}, 1500);

Explanation: By using a local variable (counter), each asynchronous operation operates on its isolated data. This ensures consistent results and prevents race conditions.

Output: The output is consistent (2), as each asynchronous operation modifies the local variable without interfering with other tasks. This prevents race conditions and ensures predictable results.

2

Using local state instead of global objects helps make Node.js code more maintainable, predictable, and performant. It also streamlines cross-language development with JavaScript and TypeScript, or when integrating with Python, especially when integrating services through child processes or APIs.

Also Read: Top 50 Most Asked JavaScript Interview Questions in 2025

Sharpen Your Programming Skills with upGrad!

Global objects in Node js are built-in components that provide core functionality across your application. Objects like global, process, and Buffer help manage system processes, memory, and runtime information. These objects are crucial for the seamless operation of real-time applications, such as messaging platforms and collaborative tools, ensuring smooth and efficient performance.

Many developers struggle to apply this knowledge when building production-level applications. This is where upGrad comes in, offering comprehensive tech courses that blend theory with practical coding experience to help bridge that gap.

Here are a few additional upGrad programs to strengthen your development skills:

• Data Structures & Algorithms
• Advanced JavaScript for All
• React.js For Beginners
• Object-Oriented Analysis and Design for Beginners
• Professional Certificate Program in Data Science and AI

Struggling to find the right Node.js course for your 2025 goals? Reach out to upGrad for personalized counseling and valuable insights, or visit your nearest upGrad offline center for more details.

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software

Reference Link:
https://www.brilworks.com/blog/nodejs-usage-statistics/