The tutorial provides the detail on the node.js TTY module. The node.js TTY module provides the capability to run the node.js with a Text Terminal (TTY) attached. The node.js tty module provides the tty.ReadStream and tty.WriteStream classes. The node.js tty module can be accessed using the below command

const tty = require('tty');

The node.js peforms the below activities when it is being run as a TTY context:

• process.stdin to be initialized as an instance of tty.ReadStream
• process.stdout and process.stderr to be the instances of tty.WriteStream

Validate if Node.js is running as TTY context

The below command can be used to identify if the node.js is being run as TTY context

C:\Users\user\Desktop>node -p -e "Boolean(process.stdout.isTTY)"

var tty = require('tty');  
process.stdin.setRawMode(true);  
process.stdin.resume();  
 console.log('This is sample text to show TTY module usage...');  
process.stdin.on('keypress', function(char, key) {  
  if (key && key.ctrl && key.name == 'c') {  
     
    process.exit()  
  }  
});

C:\Users\user\Desktop >node nodejs-tty.js
This is sample text to show TTY module usage...

Class tty.ReadStream in node.js TTY module

The class tty.ReadStream in the TTY module is for reading the TTY Context and uses the process.stdin as the instance for the tty.ReadStream. The below given are the class methods for tty.ReadStream

Class tty.WriteStream in node.js TTY module

The class tty.WriteStream in the TTY module is for writing the TTY Context and uses the process.stdout and process.stderr as the instance for the tty.WriteStream.

Event: ‘resize’: The event resize is invoked when the writeStream.cloumns or writeStream.rows have changed but it does not return any arguments to the listener callback.

process.stdout.on('resize', () => {
  console.log('application screen size has changed!');
  console.log(`${process.stdout.columns}x${process.stdout.rows}`);
});

The tutorial provides the details on the node.js streams module. The node.js streams module provides the capability of reading the data from the source and writing the data to the destination. Thus, node.js provides the readable and writable streaming process.

The node.js streams module can be accessed using the below given command:

const stream = require('stream');

Node.js stream types:

The below given are the node.js stream types available for the usage:

Node.js stream events

The below given are the events supported by the stream types:

Reading data from node.js stream

var fs = require("fs");  
var data = '';  
// Define the readable stream object
var readerStream = fs.createReadStream('stream-readable-file.txt');  
// Define encoding for the stream - UTF8  
readerStream.setEncoding('UTF8');  
// DEfine stream events   
readerStream.on('data', function(chunk) {  
   data += chunk;  
});  
readerStream.on('end',function(){  
   console.log(data);  
});  
readerStream.on('error', function(err){  
   console.log(err.stack);  
});  
console.log("Reading though steam module is completed");

Writing data to stream

var fs = require("fs"); 
// custom message for writing 
var data_to_write = 'This is an exmaple of writing the data to the file using writable stream ';  
// DEfine the writable stream  
var writerStream = fs.createWriteStream('stream-writable-file.txt');  
//seeting the data with the encoding 
writerStream.write(data_to_write,'UTF8');  
writerStream.end();  
writerStream.on('finish', function() {  
    console.log("Write completed.");  
});  
writerStream.on('error', function(err){  
   console.log(err.stack);  
});  
console.log("progam for writing the data through stream module is completed"); 

Node.js stream buffering

The node.js streaming process uses the internal buffer for storing the data . The below given are the methods to retrieve buffer data for readable and writable streams

The maximum streaming data data can be stored in buffer depends on the highWaterMark option passed into the stream’s constructor. HighWaterMark can stores the data into bytes or into objects.

The streaming data in readable streams is buffered when implementation calls the stream.push(chunk)

The streaming data in writable streams is buffered when implementation calls the writable.write(chunk)

The limit of buffering the data to avoid memory consumption or perfromance issue is maintained by stream.pipe() method in the stream API

Duplex and Transform streams are both readable and writable and maintains separate buffer to perform read and write operations

Node.js Piping Stream

The piping stream is the mechanism where the output of one stream becomes the input for the another stream.

var fs = require("fs");  
var readerStream = fs.createReadStream('stream-readable-file.txt');  
var writerStream = fs.createWriteStream('stream-writable-file.txt');  
readerStream.pipe(writerStream);  
console.log("Node.js piping stream program completed"); 

The content of the input file is written to the writable file

Node.js chaining stream

The node.js chaining stream is the mechanism where the chain is created with multiple streams operations by connecting output of one stream as the input of another stream.

var fs = require("fs");  
var zlib = require('zlib');  
fs.createReadStream('stream-readable-file.txt')  
  .pipe(zlib.createGzip())  
  .pipe(fs.createWriteStream('stream-readable-file.txt.gz'));  
  console.log("The input file is compressed successfully.");  

The tutorial provides the details on the node.js debugger module. The node,js debugger module provides the debugging utilies using in-built debugging client and V8 inspector ( https://nodejs.org/api/debugger.html #debugger_v8_inspector_integration_for_node_js ) .

Node.js debugger syntax

The usage of debugging in the node.js can be done by starting the node.js with the inspect argument , provided with the script path for which debugging is to be enabled.

Syntax:

node debug [script.js | -e “script” | <host>:<port>]  

Example : node debug crypto-cipher.js

Node.js Debugger – Points to consider

• The inclusion of the statement debugger in the script code enables the breakpoint at that line code.
• The REPL Commands allows the code to be evaluated remotely.
• The next command enables debugger to step to the next line for debugging
• Help Commands provides the list of available commands for Debugger
• Pressing ENTER only without comamds , executes the previous debugger command
• Node.js debugger allows to watch/ display the values for expressions and variables. The command watch(‘expression_to_watch’) to be typed. To remove the watcher , type the command unwatch(‘expression_to_watch’)
• The command cont, c allows the continue execution of debugging the code
• The command step, s allows the step-into the debugging
• The command out, 0 allows the step-out of the debugging
• The command pause stops the debugging
• The command run allows to run the script
• The command restart allows to restart the script
• The command kill allows to kill the script

The Tutorial provides the detailing about node.js global objects and the listing of node.js global objects and its usage. There are some objects which are considered to be global objects but actually they have scope within the module only. Let’s discuss in detail.

Node.js Global Objects

The below given is the list of node.js global objects which are available in all modules by default and does not need to include specifically in the application.

• console
• process
• buffer
• setInterval(callback, delay[, arg][, …])
• setTimeout(callback, delay[, arg][, …])
• clearImmediate(immediateObject)
• clearInterval(intervalObject)
• clearTimeout(timeoutObject)

Node.js objects with module scope

The below given is the list of node.js objects which has module level scope

• __dirname
• __filename
• exports
• module
• require()

Node.js console class

The node.js console class can be read at the below given link

Node.js console Tutorial 

Node.js Buffer class

The node.js buffer class can be read at the below given link

Node.js Tutorial – Buffer Class

Node.js _dirname

The node.js _dirname is of type “string” and depicts the directory name of the current module.

The execution of node.js _dirname is similar to the execution of path.dirname of the _filename.

Example: Insert the below command and save the file as global_dirname.js

console.log(__dirname);

Node.js _filename

The node.js _filename is of type “string” and returns the file name of the current module.

Node.js exports

The node.js exports is of type “object” and is available within a module’s file-level scope. Before the module is evaluated , the exports variable is assigned the value of module.exports.

The module.exports object is created by the Module system, In case it is required the module to be an instance of the class, then assignment of the object to the module.exports , rebinds the local export variable.

const alphaModule = require('./alphaModule');
alphaModule.on('ready', () => {
  console.log('module "alphaModule" is ready');
});

Assignment to module.exports cannot be done in callbacks and thus to be done immediately.

Example: late callback which does not work

const callbackObj = require('./callbackObj');
console.log(callbackObj.x);

Node.js module.id

The module.id depicts the identifier for the module. module.id is of type “string”

Node.js module.loaded

The node.js module loaded depicts if the module is done loading or in the process of loading. module loaded is of type “boolean”

Node.js module.parent

This is the first module to be required . The module.parent is of type “module”

Node.js module.path

The module.path depicts the search paths for the module

Node.js module.require(id)

The node.js module.require(id) allows to load the required module for which the reference of the module object is required. The require() returns module.exports object and the scope of the module is within the module code, thus module needs to be explicitly exported to be in use.

module.require(id) requires:

id : <string>

Returns: <exported module object>