This is the continuation of my previous post in the Node.js series,
In the last post of the series, we learned about the global, which contains all the available functionalities by default to a node.js program without importing or requiring any modules explicitly. This post will go a bit deeper and learn about some useful globals that are important for node.js programming.
Global Objects
The followings are available by default in all modules.
__dirname
The directory name of the current module.
console.log(__dirname);
__filename
The file name of the current module.
console.log(__filename);
exports
exports or module.exports are used for defining what a module exports and make available for other modules to import and use. We will learn about exports in greater detail in our future posts.
require()
It is used to import the module(non-global) and make use of what has been exported from that module. require takes an id as an argument which is usually a module name or path. It follows the CommonJS Module Pattern. We will dive in more into require() along with exports in the upcoming post. Few examples of require():
const path = require("path");
const v8 = require("v8");
const { sum, sub, mul } = require('./calcModule');
Process Object
The process object is a global one that provides information about the current process and provides a way to control it. As it is a global, we will not need the require(id) to use it.
There are plenty of useful methods and event listeners as part of a Process object.
process.pid
Get Current Process id.
console.log(process.pid);
Output: 25668 (for you, it will be something else)
process.version
Get node.js version at the run time.
console.log(process.version);
Output: v12.7.0
process.argv
Pass command-line arguments when we launched the Node.js process. This handy property is to pass command-line arguments where you might want to pass configurations like memory limit, default values, etc. when a process is launched.
process.argv returns an array of the arguments passed to it. By default, there will be two elements in this array,
- The first element will be the path to the node.js executable
- The second element will be the path to the JavaScript file being executed. The remaining elements will be any additional command-line arguments.
console.log(process.argv);
It outputs:
Example of passing command line arguments:
process.argv.forEach((val, index) => {
console.log(`${index}: ${val}`);
});
Now, run it like:
node src/global/global.js firstValue memory=512 last
Output:
process.exit()
The process.exit() method instructs Node.js to terminate the process synchronously. Calling process.exit() will force the process to exit as quickly as possible even if there are still asynchronous operations pending that have not yet been completed fully, including I/O operations to process.stdout and process.stderr.
Another feature of the Process object is Standard Input and Output.
process.stdin
The stdin property of the process object is a Readable Stream. It listens for the user input. We can wire up a listener using process.stdin and use the on function to listen for the event.
process.stdin.on('data', data => {
console.log(`You typed ${data.toString()}`);
process.exit();
});
When we run the above code, we will get a prompt to enter any texts using the keyboard. Once we did with typing and pressed enter key, we will see the text is printed to the console as:
process.stdout
The stdout property of the process object is a Writable Stream, and it implements a write() method. We can use this property to send data out of our program.
process.stdout.write('GreenRoots Blog\n');
It will just write the text 'GreenRoots Blog' and a new line character into the console. Can you guess what would be the implementation of console.log()? I know, you guessed it already!
Learn more about the Process object from here. I hope you found it useful. Stay tuned for the next post as a continuation of the series on Node.js concepts.
