• Control the order of execution
• Collect data
• Limit concurrency
• Call the following step in the program.

• setTimeout/clearTimeout: It implement delays in code execution.
• setInterval/clearInterval: It runs a code block multiple times.
• setImmediate/clearImmediate: It set the execution of the code at the end of the event loop cycle.
• process.nextTick: It set the execution of code at the beginning of the next event loop cycle.

• It makes building accessible network programs easy.
• It is fast
• It rarely blocks
• It provides a unified programming language and data type
• Everything in Node.js is asynchronous
• Node.js yields great concurrency

var http = require(“http”);

http.createServer(function (request, response) {

response.writeHead(200, {‘Content-Type’: ‘text/plain’});

response.end(‘Hello World\n’);

}).listen(3000);

• Asynchronous, non-blocking functions: In this API function I/O operations can be forked out from the main loop.
• Synchronous, blocking functions: In this most of the operations influence the process that is running in the main loop

• Task Function
• Concurrency Value

Node.js Interview Questions And Answers

module.exports are basically used to reveal functions of a specific module or file to be used somewhere else in the project. This can be used to capture all same functions in a file which further develops the project structure.

For example, let assume you have filed for all utils functions with util to acquire solutions in various programming languages of a problem statement.

const getSolutionInJavaScript = async ({

problem_id

}) => {

…

};

const getSolutionInPython = async ({

problem_id

}) => {

…

};

module.exports = { getSolutionInJavaScript, getSolutionInPython }

Thus using module.exports you are able to use these functions in some other file:

const { getSolutionInJavaScript, getSolutionInPython} = require("./utils”)

async_A(function(){

async_B(function(){

async_C(function(){

async_D(function(){

….

});

});

});

});

In the above coding, we are passing callback functions that make the code unreadable and not able to maintain it, which leads to changing the async logic to avoid this.

The Node.js main loop is single-threaded and all asynchronous calls are managed by libuv library.

For example:

const crypto = require(“crypto”);

const start = Date.now();

function logHashTime() {

crypto.pbkdf2(“a”, “b”, 100000, 512, “sha512”, () => {

console.log(“Hash: “, Date.now() - start);

});

}

logHashTime();

logHashTime();

logHashTime();

logHashTime();

This gives the output:

Hash: 1213

Hash: 1225

Hash: 1212

Hash: 1222

This is because libuv creates a thread pool to manage such concurrency.

Here is how you can use async-await pattern:

// this code is to retry with exponential backoff

function wait (timeout) {

return new Promise((resolve) => {

setTimeout(() => {

resolve()

}, timeout);

});

}

async function requestWithRetry (url) {

const MAX_RETRIES = 10;

for (let i = 0; i <= MAX_RETRIES; i++) {

try {

return await request(url);

} catch (err) {

const timeout = Math.pow(2, i);

console.log(‘Waiting’, timeout, ‘ms’);

await wait(timeout);

console.log(‘Retrying’, err.message, i);

}

}

}

Follow Simple Steps to apply in these MNC’s:

• Infosys Interview Process | Selection Criteria, Technical Questions
• TCS Interview Process - Complete Recruitment Guide, Tips
• SAP Interview Guide: SAP Labs Hiring Process, Tips, Questions
• HP Interview Guide, Application & Recruitment Process, Tips
• Adobe Hiring Process | Questions & Adobe’s Core Values
• Know All Companies Hiring Process Here

In Node.js streams are occurrences of EventEmitter that is used to work with streaming data. It is used to handle and manipulate streaming large files (such as videos, mp3, etc.) over the network.

Different types of the stream are:

• Writable: In these streams data can be written (for example, fs.createWriteStream()).
• Readable: In these streams data can be read (for example, fs.createReadStream()).
• Duplex: In these streams, data can be read and written (for example, net.Socket).
• Transform: In this Duplex, streams can change or transform the data as it is written and read (for example, zlib.createDeflate()).

• Reactor: Its dispatches the I/O event to suitable handlers
• Handler: It executes those events

EventEmitter is a Node.js class that involves all the objects which are fully capable of emitting events. By using an eventEmitter.on() function you can attach the named events that are released by the object. So, whenever this object emits an event the attached functions are invoked synchronously.

const EventEmitter = require(‘events’);

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on(‘event’, () => {

console.log(‘an event occurred!');

});

myEmitter.emit(‘event’);

Node.js Interview Questions For 2 Year Experience

Performance API gives us with tools to measure performance metrics. Here are the examples of using async_hooks and perf_hooks

‘use strict’;

const async_hooks = require(‘async_hooks’);

const {

performance,

PerformanceObserver

} = require(‘perf_hooks’);

const set = new Set();

const hook = async_hooks.createHook({

init(id, type) {

if (type === ‘Timeout’) {

performance.mark(`Timeout-${id}-Init`);

set.add(id);

}

},

destroy(id) {

if (set.has(id)) {

set.delete(id);

performance.mark(`Timeout-${id}-Destroy`);

performance.measure(`Timeout-${id}`,

`Timeout-${id}-Init`,

`Timeout-${id}-Destroy`);

}

}

});

hook.enable();

const obs = new PerformanceObserver((list, observer) => {

console.log(list.getEntries()[0]);

performance.clearMarks();

observer.disconnect();

});

obs.observe({ entryTypes: [‘measure’], buffered: true });

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

This would give us the exact time it took to execute the callback.

Performance API gives us tools to calculate the performance metrics.

For Example:

const { PerformanceObserver, performance } = require(‘perf_hooks’);

const obs = new PerformanceObserver((items) => {

console.log(items.getEntries()[0].duration);

performance.clearMarks();

});

obs.observe({ entryTypes: [‘measure’] });

performance.measure(‘Start to Now’);

performance.mark(‘A’);

doSomeLongRunningProcess(() => {

performance.measure(‘A to Now’, ‘A’);

performance.mark(‘B’);

performance.measure(‘A to B’, ‘A’, ‘B’);

});

1. Real-time chats
2. Internet of Things
3. Complex SPAs (Single-Page Applications)
4. Real-time collaboration tools
5. Streaming applications
6. Microservices architecture

NPM means Node Package Manager is totally responsible for handling all the packages and modules for Node.js.

Functionalities:

• Provides online sources for node.js packages/modules, that is searchable on search.nodejs.org
• It gives command-line utility to set up Node.js packages and also handles Node.js versions and dependencies.

• Node.js is very fast than other
• Node Package Manager (NPM) has more than 50,000 bundles available at the developer’s disposal
• It is perfect for data-intensive, real-time web applications, as Node.js never postpones an API to return data
• Better sync of code with server and client as they have the same code base
• Node.js is a JavaScript library so it is easy for web developers to use.

Node.js Interview Questions For 5 Years Experience

• ExpressJS: It is a flexible Node.js web application framework that gives you a wide set of features to make web and mobile applications.
• Mongoose: It is also a Node.js web application framework that easily connects an application to a database.

For importing external libraries the “require” command is used. As an example - the “var http=require (“HTTP”)” command will load the HTTP library and exported object via HTTP variable.

var http = require(‘http’);

It is basically a flexible Node.js web application framework that gives an extensive set of features to develop web and mobile-based applications.

You may also prepare:

• Networking Interview Questions
• TypeScript Interview Questions
• MVC Interview Questions
• CSS Interview Questions

In the given code you can see that the async code requests the JavaScript engine running the code to hold the request.get() function to finish before moving to the next line for execution.

async function fun1(req, res){

let response = await request.get(‘http://localhost:3000’);

if (response.err) {console.log(‘error’);}

else { console.log(‘fetched response’);

}

• GET: it is used to recover the data
• POST: It makes a change in reactions or state on the server
• HEAD: Same as the GET method, but it asks for the reply without the response body
• DELETE: It deletes the predetermined resource

It tells us how a process got terminated or the motive behind the termination.

• Uncaught fatal exception - (code - 1) - An exception that is not handled
• Unused - (code - 2) – It reserved by bash
• Fatal Error - (code - 5) - An error found in V8 with stderr output of the description
• Internal Exception handler Run-time failure - (code - 7) - An exception while bootstrapping function is called
• Internal JavaScript Evaluation Failure - (code - 4) - An exception when the bootstrapping process failed to bring back function value when evaluated.

I hope these Node.js interview questions will help you in your preparation for your upcoming Node.js technical interview. You can also prepare other coding language questions from this site.