Global, Process and buffer in Node.js
Last Updated :
05 Apr, 2023
Global: Global objects in node.js is available in all the modules and are scoped locally to their respective modules.
Some of the global objects are:
- exports
- module
- require
- __filename
- __dirname
The above objects and require functions can be accessed everywhere without importing.
Process: A process object is a global object that gives information about and controls the node.js process. As it is global, it can be used in the project without importing it from any module.
It is an instance of EventEmitter class and has many useful methods that help us in knowing more about the processes that happened and also about currently undergoing the process.
Important events of the process:
beforeExit Event: This event is triggered when the Node.js event loop is getting hollow and has no additional work scheduled. In general cases, the Node.js process will exit when there is no process left, but a listener registered on the ‘beforeExit’ can make asynchronous calls.
Javascript
const process = require('process');
process.on('beforeExit', (data) => {
console.log('Process beforeExit event with code.');
});
process.on('exit', (data) => {
console.log('Process exit event with code');
});
console.log('This code is rendered first.');
|
Output:
This code is rendered first.
Process beforeExit event with code.
Process exit event with code.
Exit Event: The ‘exit’ event is emitted when the Node.js process is about to exit as a result of either:
- The process.exit() method is called explicitly.
- The Node.js event loop no longer has any additional work to perform.
There is no way to prevent the exiting of the event loop at this point, and once all ‘exit’ listeners have finished running the Node.js process will terminate.
Javascript
process.on('exit', (data) => {
console.log(`code execution is going to end `);
});
|
Output:
code execution is going to end
Apart from the above two main events, there are also many more events that come with process objects.
Buffer: The Buffer class in Node.js is made to handle raw binary data. Each buffer corresponds to some raw memory allocated outside V8. Buffers act somewhat like arrays of integers, but aren’t resizable and have a whole bunch of methods specifically for binary data.
Creating a buffer:
let buffer = Buffer.alloc(6);
Output:
This will print out 6 bytes of zero
let buffer = Buffer.from("Welcome to GeeksforGeeks!", "utf-8");
Output:
This will print out a chain of values in utf-8
Writing to a buffer: If it contains two arguments, the first argument is the data and the second argument is the type of encoding.
buffer.write("GeeksForGeeks", "utf-8")
Output:
This will print out 13 as size of buffer
Reading a buffer: We can use the toString() method to read a buffer.
Javascript
let buf = Buffer.from('GeeksForGeeks');
console.log(buf.toString());
|
Output:
GeeksForGeeks
Similar Reads
Global, Process and buffer in Node.js
Global: Global objects in node.js is available in all the modules and are scoped locally to their respective modules. Some of the global objects are: exportsmodulerequire__filename__dirname The above objects and require functions can be accessed everywhere without importing. Process: A process objec
3 min read
Difference Between process.cwd() and __dirname in Node.js
In Node.js, both process.cwd() and __dirname are used to get the directory paths, but they serve different purposes. The key difference is that process.cwd() returns the current working directory from which the Node.js process was started, while __dirname returns the directory name of the current mo
3 min read
How to Exit Process in Node.js ?
In this article, we will see how to exit in NodeJS application. There are different types of methods to exit in Nodejs application, here we have discussed the following four methods. Table of Content Using ctrl+C keyUsing process.exit() FunctionUsing process.exitCode variableUsing process.on() Funct
3 min read
Node.js Process exit Event
The process is the global object in Node.js that keeps track of and contains all the information of the particular node.js process that is executing at a particular time on the machine. The process.exit() method is the method that is used to end the Node.js process. Every process action on the machi
2 min read
Node.js Buffer.buffer Property
The Buffer.buffer property is an inbuilt application programming interface of class Buffer within buffer module which is used to get the object of array buffer equivalent to this buffer object. Syntax: const buf.buffer Return Value: This property returns the object of array buffer. Example 1: Filena
1 min read
Node.js Global Objects
The Node.js Global Object is a built-in object that provides global variables and functions accessible throughout the Node.js runtime environment. It is analogous to the window object in browsers but tailored for server-side JavaScript. Global Objects in Node.jsNode.js Global Objects are the objects
5 min read
How to read and write files in Node JS ?
NodeJS provides built-in modules for reading and writing files, allowing developers to interact with the file system asynchronously. These modules, namely fs (File System), offer various methods for performing file operations such as reading from files, writing to files, and manipulating file metada
2 min read
Node.js Process beforeExit Event
The 'beforeExit' is an event of class Process within the process module which is emitted when Node.js empties its event loop and has no additional work to schedule. Syntax: Event: 'beforeExit'Parameters: This event does not accept any argument as the parameter. Return Value: This event returns nothi
2 min read
How to refresh a file in Node.js ?
Node.js has seen an important growth in past years and is still increasing its value in many organizations and business models. Companies like Walmart or PayPal have already started to adopt it. NPM, the package manager of Node.js has been already installed when you install Node.js and is ready to r
2 min read
Node.js Buffer Complete Reference
Buffers are instances of the Buffer class in Node.js. Buffers are designed to handle binary raw data. Buffers allocate raw memory outside the V8 heap. Buffer class is a global class so it can be used without importing the Buffer module in an application. Example: C/C++ Code <script> // Node.js
8 min read