Node.js Interview Questions and Answers

Node.js works on V8 Virtual Machine Environment which uses Javascript as its Scripting Language

It is a Programming Paradigm where the events like Messages or threads define the flow of the program. This application architecture has two sections – Event Selection and Event Handling

Node.js is an Asynchronous, Event-driven based Javascript Run-time. It is designed to build and handle scalable Network Applications.

The non-blocking I/O is the prominent feature of Node.js and hence there is no need for Locks. This helps in building reasonably scalable systems.

There are two types of API functions, they are

1. Asynchronous Non-blocking Functions and
2. Synchronous Blocking Functions

Yes. That is the advantage of Node.js as it is designed for asynchronous processing on Single Thread and it is believed that more performance and scalability can be achieved for web loads than typical thread based applications.

• Control the Order of Execution
• Collect Data
• Limit Concurrency
• Call the Next step in the Program

• Anything which requires Blocking
• Heavy Computations and
• I/O Operations

There are two arguments, namely the Task Function and Concurrency Value. These are the commonly asked Node.js Interview Questions and Answers for the Fresher graduates.

This is a loop which process external events and converts them into callback invocations. So for I/O Calls, node.js can switch from one request to another.

Node.js is a loop based Server for Javascript which gives the ability to write JavaScript code on the Server to access HTTP Stack, file I/O, TCP and Databases very easily by the programmers. This feature is gaining attention from Java programmers.

Because Node.js overcomes this problem by using the Event based Model instead of Threads based model.

AJAX is a Client Side technology to update the contents of the page without refreshing and it is executed by the Browser. Whereas Node.js is a Server-Side Javascript technology which is executed by the Server and not by the Browser.

The Challenge is to have one Process with One Thread to scale up on Multi Core Server.

External Libraries can be imported using the “require” command in Node.js. Example, “var http=require(‘http’)”.

Express Framework is most commonly used with Node.js

It is used to handle multiple requests to the node.js Server. Callback Function allows the server to prioritize pending requests first, and call the other Function when it is finished.

All the async Callbacks are handled by the Event Loop. As node.js is a Single Threaded Event Driven language where Listeners are attached to the events. When the said event is triggered, the Listener executes the Callback we provided. All the Functions are queued in a Loop and will be executed one by one when the response is received.

It is called Input/Output and it accesses anything outside of the Application. It is loaded in the memory when the Application is started. These are the commonly asked Node.js Interview Questions for Freshers and Experienced candidates in an interview.

No, DOM cannot be accessed from node.js

Read-Eval-Print-Loop is a virtual environment that comes with node.js. It is an Interactive language Shell used to quickly test simple Node.js/JavaScript code

The Debugger Utility can be used which is included with Node.js. To enable a Breakpoint at a specific position of the code, insert the “debugger” statement .

It is a file which contains all the metadata information about a project. This file is used by the “npm” to identify the project and install the project and all the dependencies that are listed in this file

The most popular Node.js Modules are Express, Async, socket.io, Bower, gulp, grunt and browserify.

Streams are a type of Pipe which is used to read data from a source and pipe it to a destination. Technically, Stream is an EventEmitter with special Methods. Readable, Writable, Duplex and Transform are the types of Streams.

“readFile” is an asynchronous method to read files. The “readFileSync” is the same as “readFile” except it reads synchronously. Whereas the “createReadStream” will read the file in default chunk size of 64kb.

The “crypto” Module is used for cryptographic functionality with wrappers for OpenSSL Hash, HMAC, decipher, sign and Verify Functions.

The Timer module provides functions to execute codes at a set period. The functions setTimeout(), setImmediate() and setInterval() can be used to execute code after some point from the present moment.

Node.js primarily uses Authentication to identify users to permit access for an application. The Authentication can be session-based or Token-based. In the Session based Authentication, the user credentials are verified against the user account stored on the Server. In Token-based Authentication, user credentials are applied to create a string based Token that will be associated with the user’s request to the Server. Other options being Request Validation and use of Security tools like Helmet, csurf and node rate limiter. These are the commonly asked Node.js Interview Questions for the Experienced Candidates in an Interview.

Passport is basically an Authentication middleware for Node.js. Passport.js supports any express.js based applications.

The “module.exports” is used to combine multiple functions or objects as a single unit of Code in a .js file. The “module.exports” instructs Node.js which unit of code to export from a given file to another file for access.

The LTS version of Node.js is supported for at least 18 Months by providing critical bug fixes, security updates, performance improvements and focuses on stability and security.

Callback Hell is the outcome of improper implementation of asynchronous logic by intensively nesting callbacks which becomes unreadable and hard to debug.

Actually Middleware is a Function which receives the Request and Responses Objects in an application’s request-response cycle with access to the Next Function of the cycle. Middleware performs the following tasks;

• Execute Any type of code
• Update and or Modify the request and the response Objects
• Finish the request-response cycle
• Invoke the next middleware of the stack

This is a built-in module which provides various utilities for URL Resolution and parsing that helps in splitting up the web address into a readable format.

V8 is a chrome runtime engine which converts JavaScript code into Native Machine Code which gives fastest application execution and response processing. This is the reason that Node.js gives you a fast running application.

The Control Flow Function Codes are basically executed between the asynchronous function calls by Node.js. Follow these steps to execute Control Flow Function;

• Control the Order of the Execution
• Required data need to be collected
• The Concurrency must be Limited
• Then, the next step of the program has to be Invoked

Global is a container for Global Objects and always exists in the Global Scope and are available to access from all the Modules of the application. These objects can be used directly without including them explicitly. Modules, Functions, Strings, Objects can all be Global Objects.

Stubs are Programs or Functions which can stimulate the module or component behavior. This can be used in Test Cases.

The process.nextTick() and setImmediate(), both are functions of the Timers module that help in executing the code after a predefined period of time. They differ in the way that process.nextTick function waits for the execution of action till the next pass around of the event loop (or only after the event loop is completed) to invoke the callback function. The setImmediate() is used to execute a callback method on the next cycle of the event loop which eventually returns it to the event loop in order to execute the I/O operations.

Buffer class in Node.js stores the raw data in a similar manner of an array of integers except that it corresponds to a raw memory allocation that is located outside the V8 heap. It is a global class that is easily accessible in an application without importing a buffer module. Since pure JavaScript is not compatible with binary data, buffer class is used. So, when dealing with TCP streams or the file system, it’s necessary to handle octet streams.

Node.js is a single threaded process and will not expose the child threads or the thread management methods. But spawn() function can be used to make use of the Child threads for some specific asynchronous I/O tasks which execute in the background and don’t usually execute any JS code or hinder the main event loop of the application. To use the Threading Concept, the “child_process” module must be included in the application explicitly.

NODE_ENV is an environment Variable which specifies the environment in which the application is running. This can be Set to either Development or Production. When Set to Production, the application performs faster than normal.

Exit codes are used for finishing a specific process which can include the global object as well. Some of the Exit Codes are

• Uncaught fatal exception
• Unused
• Fatal Error
• Internal Exception handler Run-time failure
• Internal JavaScript Evaluation Failure

It is a Node.js class that includes all the objects that are capable of emitting events. With the eventEmitter.on() function more than one function can be attached to the named events that are emitted by the object. All the attached functions of an event are invoked synchronously whenever an EventEmitter object throws an event

Since Node.js is a single threaded framework, it should not be used for cases where the application requires long processing time. For example, if the server is doing some calculation, it won’t be able to process any other requests. So Node.js is the best choice for applications where processing needs less dedicated CPU time.

Callback Hell can be avoided by following the below mentioned points;

• Make the Program Modular
• Use the Async Mechanism
• Use Promises
• Use Generators

Yes, we have to change the “Content-type” in the HTML code from “text/plain” to “text/html” to load the HTML Code. These are the commonly asked Node.js Interview Questions and Answers to the Fresher candidates in an Interview.

NPM is Node Package Manager. The two main functionalities of NPM are;

• It can be used as an Online repository for node.js packages/modules which are present at nodejs.org.
• NPM can be used as a Command line utility to install packages, do version management and dependency management of Node.js packages.

These are packages/dependencies that are stored in <user-directory>/npm directory. Globally Installed dependencies can be used in CLI mode function of any node.js, but cannot be imported using require() in the Node application directly. You can use the –g flag to install a node project globally.

The default installation for any dependency by NPM is in the local mode. This means that the package gets installed in the “node_modules” directory which is present in the same folder, where Node application is placed. The local dependencies are accessible via require(). If the –g flag is not used while installation, then it is installed as Local Dependencies.

By Default Node.js is a single-threaded application and it can’t completely utilize the multi-core system but it can run in Multi-core platforms.

However, the Cluster Module, which is capable of starting multiple Node.js worker processes that will share the same port, can be used to make use of the Multi-core platform effectively.

The callback handler follows a standard signature and usually the first argument is an optional error object. The argument defaults to null or undefined on No Error.

When the output of one stream is connected to the input of another stream, it creates a chain of multiple stream operations and this is called a chaining process.

The APIs of Node.js library use an asynchronous method which means it is non-blocking. This means a Node.js based server never waits for an API to return data. The node.js Server moves to calling the next API after calling a function with a callback notification mechanism. This callback of Events of Node.js helps the server to get response from the previous API call.

If any I/O Operation takes time to complete and makes the application to wait, then the code responsible for making the application to wait is called Blocking Code. This can be avoided by using Callback Function.

The “fs” module is used for File operations whereas the “buffer” module is used for Buffer based Operations.

The “fs” module has Synchronous and Asynchronous for all the methods. It is suggested to use Asynchronous method as it never blocks the program execution because of a last parameter as completion function callback unlike the Synchronous method which returns control only after completion of the operation thereby blocking I/O.

Some of the commonly triggered Streams events are: data – This event is triggered when data is available to read. end – This event is triggered when there is no more data to read. error – This event is triggered when there is any error receiving or writing data. finish – This event is triggered when all data has been flushed to underlying system

Often nested callback functions are used a lot while developing an Application in Node.js. While writing code to perform multiple nested operations, the code becomes very complex and hard to manage. This scenario can lead to “Callback Hell” which can be avoided by using “Promises”. A Promise, as its name suggests will either complete the defined action and return Completed or if the defined action cannot be completed, it returns Rejected. So, a Callback attached to Promises using the “.then” will notify whether the request is Completed or Rejected, thereby making the codes easy to manage. One of the important advantages of Promise is that they can be Chained.

A promise provides with some guarantees, they are;

• Callbacks will be called only after the completion of the current run of the Event Loop.
• Callbacks added with a Promise using then() will be called, even after the success or failure of the asynchronous operation
• Multiple callbacks may be added using then() and Each callback is executed one after the other following the same order in which they were inserted.
• One of the great things about using promises is chaining.

Libuv, is used for asynchronous Input/output. The important features of Libuv are;

• File System Events
• Child Processes
• Full-featured event loop backed
• Asynchronous TCP & UDP sockets

ExpressJS is a JS framework used to handle the flow of information between the routes and server in server-side apps. Because of its lightweight, flexible and variety of relevant features, it is apt for mobile and web application development.

Once the Programming is completed, the source code is compiled into bytecode by a compiler according to the destination hardware platform processor.

JIT – Just-in-time compiler sends bytecode to the processor by converting it into instruction.

Node.js uses JIT compilation which improves the speed of code execution as it takes the source code and converts it into machine code in runtime. With this, functions that are called regularly are compiled to machine code, increasing the overall speed of code execution.

CLI – Command Line Interface is a utility or program where users type commands to perform some action or run some script rather than clicking on the screen. Node.js has an excellent CLI environment through which many useful tasks can be carried out easily.

The following code will create a simple server in Node.js that returns Hello World

var http =require(‘http’);

http.createServer(function(req,res){

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

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

}).listen(1320,’127.0.0.3′);

Utility modules are available in Node.js to perform important tasks while developing an application. The following are the most commonly used utilities;

• “os” Module : Provides functions related to Operation System
• “path” Module : Provides functionalities to handle Path transformations
• “net” Module : This module acts as a network wrapper providing servers and clients as streams
• “DNS” Module : Used for actual DNS lookup and OS name resolution functionalities
• “domain” Module: Provides functionalities to handle multiple different I/O Operations as a single group

Node.js Web applications has four different layers and they are;

• Client Layer : Any devices or applications which can make an HTTP request to the web server forms the Client Layer. Examples are web browsers, mobile browsers or applications etc.,
• Server Layer : This layer contains the Web Server which handles the request made by the Client and pass them the responses
• Business Layer : This layer contains the Application Server which is used by the Web Server to perform the required processing. The Application server in this layer interacts with the Data Layer with some external programs or directly to the database.
• Data Layer : This layer runs the Databases or Data Sources

Underscore variable is used to fetch the last result

Operational errors are not classified as bugs, but may create problems with the system like hardware failure or timeouts. Programmer errors are actual bugs.

Asserts can be used to write tests in Node.js. It provides feedback when the test fails. The assert module can be used in application using the require(‘assert’) code. The assert module provides a set of assertions which can be used to test invariants.

Punycode is an encoding syntax with which the Unicode (UTF-8) characters can be converted to ASCII characters. You have to import it using require(‘Punycode’).

Node.js supports creation of child processes which can be leveraged to perform parallel processing on multi-core CPU systems. The Child process provides the “child.stdin”, “child.stdout” and “child.stderr” streams which can be shared with the parent process.

The following functions are available in the child_process module to create a child process.

• exec− child_process.exec method runs a command in a shell or console and stores the output in a buffer. This is executed within the same process and only one copy of the node module is active in the processor.
• spawn− child_process.spawn method creates a new process with a given command to execute.
• fork− The child_process.fork method is a special case of the spawn() to create child processes with a new instance of the v8 engine with which multiple workers can be created to make use of multi-core CPUs

The following are the popular frameworks that are used with Node.js;

• AdonisJs : Supports with SQL and No-SQL Databases with MongoDB
• js : Used as a middleware to handle servers and routes
• js : Used to develop modern Mobile and Web Applications
• js : One of the most highly recommended MVC framework for developing Enterprise Grade Applications for Node.js

Yes, it is very important for a developer to keep track of trend updates in technology. The following interesting points got my attention;

• The recent and updated Node.js is a Serverless and hardware-free solution with enhanced performance and productivity
• Because Node.js supports micro services architecture, it is now easy to manage code
• The support for WebSockets Protocols has made it an excellent data serving platform to provide strong back-end support for Applications
• With its data centric approach, Node.js is gaining momentum as a solution for IoT platform

Node.js V12 was launched in 2019 and here are the notable features of this update;

• The V8 engine is now updated to version 7.4
• The new “Diagnostic Reports” feature is introduced
• The TLS1.3 is now the new default Max Protocol
• With the Async stack traces updates, Node.js can now trace asynchronous call frames

Top companies like PayPal, LinkedIn, Yahoo, Mozilla, Netflix, Uber, e-bay, Medium, Trello and NASA uses Node.js

A handler can be attached to the “uncaughtException” event with the use of “Process” to catch unhandled exceptions.

Test Pyramid defines an optimum ratio of Unit tests, Integration tests and end-to-end tests, that a developer should perform while developing an application.

The Fact that Node.js is single-threaded and the Event Loop is what allows Node.js to perform non-blocking Input/Output Operations by offloading operations to the system kernel whenever possible.

Most of the modern kernels are Multi-threaded, and on this basis, Node.js attaches a callback to every I/O and pushes it to the system kernel for execution as the kernel can handle multiple operations executing in the background. When the operation is completed, the kernel tells Node.js so that appropriate callback is added to the poll queue to be executed eventually and pushed onto the Event Loop.

Buffer can be used to process Binary Data, such as Pictures, mp3 audio, database files as it supports plenty of encoding and decoding binary string conversions.

All the native code bindings of Node.js such as the “fs” module or the “net” module all need the V8 engine to work. Node.js is exclusively designed to work with the V8 script engine.

There is a node-chakraproject by Microsoft, which actually uses the JavaScript Engine of the Edge browser to make Node.js work and it’s progressing now.

V8 uses 4 extra threads that are created to carry out various tasks such as GC-related background tasks and performing compiler optimization tasks.

To execute code after a specific period of time, Node.js provides the Timers Module with the following functions;

• setTimeout/clearTimeout– Used to schedule code execution after a specified amount of milliseconds
• setInterval/clearInterval– To execute a block of code multiple times, this function is used.
• setImmediate/clearImmediate– When used, the code is executed when the current event loop ends.
• nextTick– Used to invoke a callback function in the next iteration of the Event Loop.

Yes, with ES6, “actual” classes can be created and used. It can be exported and imported using the module.exports and require. Example;

class car {

constructor(name) {

this.name = name;

}

print() {

console.log(‘Name is’ + this.name);

}

}

To export ; module.exports = class car { }

To import and use Class;

Var car = require(‘./car’);

Class audi extends car {

……

}

While developing codes as teams, there is a necessity to enforce consistency and style to catch common errors using static analysis. The tools like JSLint, JSHint, ESLint, JSCS can be used.

No, Node.js can be called as a “runtime” or “environment” based on V8 engine to execute Javascript code on the server-side.

While working with multi-core systems, Node.js handles the thread execution load with a Process called Cluster. These are the commonly asked Node.js Interview Questions and Answers to the Fresher candidates in an Interview.

This “req.connection.remoteAddress” is used to get the IP address which is using the Application. With “req.connection.remoteAddress” we can get the proxy’s IP Address only if the Client is using Proxy. To get the Actual IP Address of the client, by resolving the proxy using headers, you can use “req.ip”. But ensure that the “trust proxy” setting is Enabled.

 The important building blocks of Node.js are;

• The Reactor Pattern
• Libuv
• Bindings
• Chrome V8 Script Engine
• Core JavaScript Library

They both are defined in package.json file;

• The “dependencies” field will have the list of all the packages on which the node project is dependent.
• The “devDependencies” field will have the list of all the packages which are required for testing and development.

The “path” module is used to resolve file system paths. Also it can be used to find relative paths, check the existence of paths and to extract components from paths.

• Cookies cannot be handled
• There is no built-in support for sessions
• There is no built-in support for routing
• There is no static file serving

This is a most popular node.js module for Web Socket Programming which supports two way communication. Events are used for transmitting messages between Client and the Server.

Yes, there are popular and powerful REST API frameworks such as Restify, LoopBack, ActionHero and Fortune.js which can be used to build REST API server using Node.js

To take care of the development and releases of Node.js, the Node.js independent foundation was formed. This foundation has developers from IBM, PayPal, Fidelity, Microsoft, Joyent, SAP and other companies. The foundation has combined the io.js and Node.js as a single code base on Sep, 2015. This also included several new features of ES6.

The “await” expression is used with the async keyword in a function. The “await” expression pauses the function and waits for the resolution of the passed Promise to return. It then resumes the function and returns the resolved value.

Ryan Dahl created Node.js in 2009 and the development was sponsored by Joyent.

Popular IDEs are Visual Studio Code, Atom, Webstorm, Node Eclipse and Sublime text among others.