Node.js Global Objects

In JavaScript, there is a special object called the Global Object, which, along with all its properties, can be accessed anywhere in the program, i.e., global variables.

In browser JavaScript, the global object is typically window, whereas in Node.js, the global object is global. All global variables (except global itself) are properties of the global object.

In Node.js, we can directly access the properties of global without needing to include it in our application.

Global Objects and Global Variables

The primary role of global is to act as the host for global variables. According to ECMAScript specifications, a variable is considered global if it meets the following criteria:

• Defined in the outermost scope;
• A property of the global object;
• Implicitly defined variables (variables assigned without being declared).

When you define a global variable, it also becomes a property of the global object, and vice versa. It's important to note that in Node.js, you cannot define variables in the outermost scope because all user code belongs to the current module, and the module itself is not the outermost context.

Note: It's best to avoid using var to define variables to prevent introducing global variables, as they can pollute the namespace and increase the risk of code coupling.

__filename

__filename represents the file name of the currently executing script. It outputs the absolute path of the file location, which may not be the same as the file name specified in the command line arguments. If used in a module, it returns the path of the module file.

Example

Create a file main.js with the following code:

// Output the value of the global variable __filename
console.log(__filename);

Execute the main.js file:

$ node main.js
/web/com/tutorialpro/nodejs/main.js

__dirname

__dirname represents the directory of the currently executing script.

Example

Create a file main.js with the following code:

// Output the value of the global variable __dirname
console.log(__dirname);

Execute the main.js file:

$ node main.js
/web/com/tutorialpro/nodejs

setTimeout(cb, ms)

setTimeout(cb, ms) is a global function that executes the specified function (cb) after the specified number of milliseconds (ms). The setTimeout() function executes the specified function only once.

It returns a handle value representing the timer.

Example

Create a file main.js with the following code:

function printHello() {
   console.log("Hello, World!");
}
// Execute the above function after 2 seconds
setTimeout(printHello, 2000);

Execute the main.js file:

$ node main.js
Hello, World!

clearTimeout(t)

clearTimeout(t) is a global function used to stop a timer previously created with setTimeout(). The parameter t is the timer created by the setTimeout() function.

Example

Create a file main.js with the following code:

function printHello() {
   console.log("Hello, World!");
}
// Execute the above function after 2 seconds
var t = setTimeout(printHello, 2000);

// Clear the timer
clearTimeout(t);

Execute the main.js file:

$ node main.js

setInterval(cb, ms)

setInterval(cb, ms) is a global function that executes the specified function (cb) every specified number of milliseconds (ms).

It returns a handle value representing the timer. The timer can be cleared using the clearInterval(t) function.

The setInterval() method will keep calling the function until clearInterval() is called or the window is closed.

Example

Create a file main.js with the following code:

function printHello() {
   console.log("Hello, World!");
}
// Execute the above function every 2 seconds
setInterval(printHello, 2000);

Execute the main.js file:

$ node main.js

The above program will output "Hello, World!" every two seconds and will continue to run indefinitely until you press ctrl + c.

console

The console is used to provide standard output for the console. It was originally a debugging tool provided by the JScript engine of Internet Explorer and later became a de facto standard for browsers.

Node.js adopted this standard, providing a console object that behaves consistently with customary practices, used for outputting characters to the standard output stream (stdout) or the standard error stream (stderr).

Console Methods

Below are the methods of the console object:

console.log accepts several parameters. If there is only one parameter, it outputs the string representation of this parameter. If there are multiple parameters, it outputs in a format similar to the C language's printf() command.

The first parameter is a string. If there are no parameters, it only prints a newline.

console.log('Hello world'); 
console.log('byvoid%diovyb'); 
console.log('byvoid%diovyb', 1991);

The output will be:

Hello world 
byvoid%diovyb 
byvoid1991iovyb

• console.error(): Same usage as console.log(), but outputs to the standard error stream.

• console.trace(): Outputs the current call stack to the standard error stream.

  console.trace();
  

The output will be:

Trace: 
at Object.<anonymous> (/home/byvoid/consoletrace.js:1:71) 
at Module._compile (module.js:441:26) 
at Object..js (module.js:459:10) 
at Module.load (module.js:348:31) 
at Function._load (module.js:308:12) 
at Array.0 (module.js:479:10) 
at EventEmitter._tickCallback (node.js:192:40)

Example

Create a file named main.js with the following code:

console.info("Program started:");

var counter = 10;
console.log("Count: %d", counter);

console.time("Fetch data");
//
// Execute some code
// 
console.timeEnd('Fetch data');

console.info("Program finished.")

Run the main.js file with the following command:

$ node main.js
Program started:
Count: 10
Fetch data: 0ms
Program finished

Process

process is a global variable, an attribute of the global object. It is an object used to describe the current Node.js process status, providing a simple interface with the operating system. It is commonly used when writing native command-line programs. Below are some of the most commonly used member methods of the process object.

Example

Create a file named main.js with the following code:

process.on('exit', function(code) {

  // The following code will never execute
  setTimeout(function() {
    console.log("This code will not run");
  }, 0);

  console.log('Exit code:', code);
});
console.log("Program execution complete");

Execute the main.js file with the following command:

$ node main.js
Program execution complete
Exit code: 0

Exit Status Codes

Process Properties

Process provides many useful properties to better control system interaction:

Example

Create a file named main.js with the following code:

// Output to the terminal
process.stdout.write("Hello World!" + "\n");

// Read through arguments
process.argv.forEach(function(val, index, array) {
   console.log(index + ': ' + val);
});

// Get the execution path
console.log(process.execPath);

// Platform information
console.log(process.platform);

Execute the main.js file with the following command:

$ node main.js
Hello World!
0: node
1: /web/www/node/main.js
/usr/local/node/0.10.36/bin/node
darwin

Method Reference Manual

The Process object provides many useful methods to better control system interactions:

Example

Create a file main.js with the following code:

// Output the current directory
console.log('Current directory: ' + process.cwd());

// Output the current version
console.log('Current version: ' + process.version);

// Output memory usage
console.log(process.memoryUsage());

Execute the main.js file with the following command:

$ node main.js
Current directory: /web/com/tutorialpro/nodejs
Current version: v0.10.36
{ rss: 12541952, heapTotal: 4083456, heapUsed: 2157056 }