Top 126 Node.js Interview Questions And Answers

Question 1

What `npm` is used for?

Accepted Answer

`npm` stands for Node Package Manager. npm provides the following two main functionalities:

*   Online repositories for Node.js packages/modules which are searchable on [search.nodejs.org](http://search.nodejs.org)
*   Command-line utility to install packages, do version management and dependency management of Node.js packages.
* Another important use for npm is _dependency management_. When you have a node project with a package.json file, you can run npm install from the project root and npm will install all the dependencies listed in the package.json.

Question 2

What are the _benefits_ of using Node.js?

Accepted Answer

Following are main benefits of using Node.js

*   **Aynchronous and Event Driven** - All APIs of Node.js library are aynchronous that is non-blocking. It essentially means a Node.js based server never waits for a API to return data. Server moves to next API after calling it and a notification mechanism of Events of Node.js helps server to get response from the previous API call.
*   **Very Fast** - Being built on Google Chrome's V8 JavaScript Engine, Node.js library is very fast in code execution.
*   **Single Threaded but highly Scalable** - Node.js uses a single threaded model with event looping. Event mechanism helps server to respond in a non-bloking ways and makes server highly scalable as opposed to traditional servers which create limited threads to handle requests. Node.js uses a single threaded program and same program can services much larger number of requests than traditional server like Apache HTTP Server.
*   **No Buffering** \- Node.js applications never buffer any data. These applications simply output the data in chunks.

Question 3

What is _Callback Hell_ and what is the _main cause_ of it?

Accepted Answer

Asynchronous JavaScript, or JavaScript that uses callbacks, is hard to get right intuitively. A lot of code ends up looking like this:

```js
fs.readdir(source, function (err, files) {
  if (err) {
    console.log('Error finding files: ' + err)
  } else {
    files.forEach(function (filename, fileIndex) {
      console.log(filename)
      gm(source + filename).size(function (err, values) {
        if (err) {
          console.log('Error identifying file size: ' + err)
        } else {
          console.log(filename + ' : ' + values)
          aspect = (values.width / values.height)
          widths.forEach(function (width, widthIndex) {
            height = Math.round(width / aspect)
            console.log('resizing ' + filename + 'to ' + height + 'x' + height)
            this.resize(width, height).write(dest + 'w' + width + '_' + filename, function(err) {
              if (err) console.log('Error writing file: ' + err)
            })
          }.bind(this))
        }
      })
    })
  }
})
```

See the pyramid shape and all the `})` at the end? This is affectionately known as **callback hell**.

The **cause of callback hell** is when people try to write JavaScript in a way where execution happens visually from top to bottom. Lots of people make this mistake! In other languages like C, Ruby or Python there is the expectation that whatever happens on line 1 will finish before the code on line 2 starts running and so on down the file.

Question 4

What are the key features of Node.js?

Accepted Answer

Let’s look at some of the key features of Node.js.

*   **Asynchronous event driven IO helps concurrent request handling –** All APIs of Node.js are asynchronous. This feature means that if a Node receives a request for some Input/Output operation, it will execute that operation in the background and continue with the processing of other requests. Thus it will not wait for the response from the previous requests.
*   **Fast in Code execution –** Node.js uses the V8 JavaScript Runtime engine, the one which is used by Google Chrome. Node has a wrapper over the JavaScript engine which makes the runtime engine much faster and hence processing of requests within Node.js also become faster.
*   **Single Threaded but Highly Scalable –** Node.js uses a single thread model for event looping. The response from these events may or may not reach the server immediately. However, this does not block other operations. Thus making Node.js highly scalable. Traditional servers create limited threads to handle requests while Node.js creates a single thread that provides service to much larger numbers of such requests.
*   **Node.js library uses JavaScript –** This is another important aspect of Node.js from the developer’s point of view. The majority of developers are already well-versed in JavaScript. Hence, development in Node.js becomes easier for a developer who knows JavaScript.
*   **There is an Active and vibrant community for the Node.js framework –** The active community always keeps the framework updated with the latest trends in the web development.
*   **No Buffering –** Node.js applications never buffer any data. They simply output the data in chunks.

Question 5

Explain the difference between _local_ and _global_ `npm` packages installation

Accepted Answer

The main difference between local and global packages is this: - **local packages** are installed in the directory where you run `npm install `, and they are put in the `node_modules` folder under this directory - **global packages** are all put in a single place in your system (exactly where depends on your setup), regardless of where you run `npm install -g ` In general, **all packages should be installed locally**. * This makes sure you can have dozens of applications in your computer, all running a different version of each package if needed. * Updating a global package would make all your projects use the new release, and as you can imagine this might cause nightmares in terms of maintenance, as some packages might break compatibility with further dependencies, and so on.

Question 6

What do you mean by _Asynchronous API_?

Accepted Answer

All APIs of Node.js library are aynchronous that is non-blocking. It essentially means a Node.js based server never waits for a API to return data. Server moves to next API after calling it and a notification mechanism of Events of Node.js helps server to get response from the previous API call.

Question 7

What is _V8_?

Accepted Answer

The V8 library provides Node.js with a JavaScript engine (a program that converts Javascript code into lower level or machine code that microprocessors can understand), which Node.js controls via the V8 C++ API. V8 is maintained by Google, for use in Chrome.

The Chrome V8 engine :

* The V8 engine is written in C++ and used in Chrome and Nodejs.
* It implements ECMAScript as specified in ECMA-262.
* The V8 engine can run standalone we can embed it with our own C++ program.

Question 8

What is `libuv`?

Accepted Answer

**libuv** is a C library that is used to abstract non-blocking I/O operations to a consistent interface across all supported platforms. It provides mechanisms to handle file system, DNS, network, child processes, pipes, signal handling, polling and streaming. It also includes a thread pool for offloading work for some things that can't be done asynchronously at the operating system level.

Question 9

What is _Callback_?

Accepted Answer

A **callback** is a function called at the completion of a given task; this prevents any blocking, and allows other code to be run in the meantime. Callbacks are the foundation of Node.js. Callbacks give you an interface with which to say, "and when you're done doing that, do all this."

```js
var myCallback = function(data) {
  console.log('got data: '+data);
};

var usingItNow = function(callback) {
  callback('get it?');
};
```

Question 10

Why does Node.js prefer _Error-First Callback_?

Accepted Answer

The usual pattern is that the callback is invoked as `callback(err, result)`, where only one of err and result is non-null, depending on whether the operation **succeeded** or **failed**. Without this convention, developers would have to maintain different signatures and APIs, without knowing where to place the error in the arguments array.

```js
fs.readFile(filePath, function(err, data) {
  if (err) {
    //handle the error
  }
  // use the data object
});
```

Top 126 Node.js Interview Questions

What npm is used for?

Why does Node.js prefer Error-First Callback?

What is V8?

What is libuv?

What does Promisifying technique mean in Node.js?

What are the benefits of using Node.js?

What's the difference between process.cwd() vs __dirname?

What do you mean by Asynchronous API?

What is the difference between returning a callback and just calling a callback?

Explain the difference between local and global npm packages installation

Why we always require modules at the top of a file? Can we require modules inside of functions?

What are the key features of Node.js?

Name some Built-in Globals in Node.js

What is Callback Hell and what is the main cause of it?

What is Callback?

What is the file package.json?

What is the meaning of the @ prefix on npm package?

What exactly does module.exports do in Node.js, and what would a simple example be?

Explain how does Node.js work?

How does Node.js handle Child Threads?

What is the difference between require(x) and ES6 import x in Node.js?

Which one is better: Node.js built in cluster or PM2 clustering?

What is the relationship between Node.js and V8?

Explain the concept of Domain in Node.js

Provide some of the reasons not to use Node.js

Provide your favourite reasons to use Node.js

When would you use cluster module in Node.js?

What is stream and what are types of streams available in Node.js?

What is the purpose of pm2 save?

How do I run a Node.js app as a background service?

Is an Event Emitter Synchronous or Asynchronous?

Explain the order of Event Listeners execution in Node.js

What is Event Loop in Node.js?

What is the preferred method of resolving unhandled exceptions in Node.js?

What is a Blocking Code in Node.js?

When should we use Node.js?

When should I use EventEmitter?

What is difference between synchronous and asynchronous method of fs module?

What is export default in JavaScript?

What are the use cases for the Node.js vm core module?

What is the difference between cluster and worker_threads packages in Node.js?

How do you debug Node.js applications?

Could we run an external process with Node.js?

What is the difference between browser global scope and Node.js global scope?

How to use global variable in Node.js?

What is the difference between setTimeout(fn,0) vs setImmediate(fn)?

When would you use global variables in Node.js? Are they always bad?

Are you familiar with differences between Node.js modules and ES6 modules?

What is N-API in Node.js?

How to avoid Callback Hell in Node.js?

What Are Buffer and why to use them in Node.js?

Is there any difference between res.send and return res.send in Express.js?

What are express.json() and express.urlencoded() in Express.js?

How does concurrency work in Node.js?

What are Event Emitters?

What is Stream Chaining in Node.js?

What is the purpose of using assert module in Node.js

What's the Event Loop?

Would you use Node.js assert library vs. other assert libraries like chai? Why?

What is Mocha in Node.js userland?

What is chai and chai-http in Node.js userland?

Compare PM2 Cluster Mode vs. Node.js Cluster module usage

How to gracefully shutdown Node.js server?

Do I need Dependency Injection in Node.js and how to deal with it?

What is the difference between fork() & spawn() in Node.js?

What is the difference between the child_process spawn and execute functions in Node.js? When to use each one?

When would you use import * as X from 'X' ?

List some differences between CommonJS module loader and ECMAScript module loader

What is the difference between Cluster and Fork mode in PM2?

Explain what is Arrange-Act-Assert pattern?

How can you have one global variable between all clustered workers in Node.js?

Compare strict vs legacy mode for Assert module in Node.js

What is the difference between pm2 restart and pm2 reload?

How would you prevent Callback Hell without using promises, async or generators?

Is an Event Emitter synchronous or asynchronous?

How would you handle errors for async code in Node.js?

Why to use Buffer instead of binary string to handle binary data ?

How the V8 engine works?

Does Node.js support multi-core platforms? And is it capable of utilizing all the cores?

What `npm` is used for?

What is `libuv`?

What's the difference between `process.cwd()` vs `__dirname`?

Explain the difference between local and global `npm` packages installation

Why we always `require` modules at the top of a file? Can we `require` modules inside of functions?

What is the file `package.json`?

What is the meaning of the `@` prefix on npm package?

What exactly does `module.exports` do in Node.js, and what would a simple example be?

What is the difference between `require(x)` and ES6 `import x` in Node.js?

Which one is better: Node.js built in `cluster` or PM2 clustering?

When would you use `cluster` module in Node.js?

What is `stream` and what are types of streams available in Node.js?

What is the purpose of `pm2 save`?

When should I use `EventEmitter`?

What is difference between synchronous and asynchronous method of `fs` module?

What is `export default` in JavaScript?

What are the use cases for the Node.js `vm` core module?

What is the difference between `cluster` and `worker_threads` packages in Node.js?

How to use `global` variable in Node.js?

What is the difference between `setTimeout(fn,0)` vs `setImmediate(fn)`?

Is there any difference between `res.send` and `return res.send` in Express.js?

What are `express.json()` and `express.urlencoded()` in Express.js?

Would you use Node.js `assert` library vs. other assert libraries like `chai`? Why?

What is the difference between `fork()` & `spawn()` in Node.js?

What is the difference between the child_process `spawn` and `execute` functions in Node.js? When to use each one?

When would you use `import * as X from 'X'` ?

Explain what is `Arrange-Act-Assert` pattern?

Compare `strict` vs `legacy` mode for Assert module in Node.js

What is the difference between `pm2 restart` and `pm2 reload`?

Is an `Event Emitter` synchronous or asynchronous?

How would you handle errors for `async` code in Node.js?

Why to use `Buffer` instead of binary string to handle binary data ?

Is it possible to use `Class` in Node.js?

What is the purpose of `__filename` variable in Node.js?

What are `async` functions in Node? Provide some examples.

Does JavaScript have a `map` function to iterate over an object properties?

Explain usage of `NODE_ENV`

What is the difference between `process.nextTick()` and `setImmediate()`?

How to solve `Process out of Memory Exception` in Node.js ?

Does the `cluster` in Node.js utilizes same event loop?

What's the difference between `pm2` and `pm2-runtime` and when to use one?

How would you implement process communication when using `cluster` module in Node.js?

What is the difference between `cluster.fork()` vs `child_process.fork()` in Node.js?

Explain what is wrong with `async/await` use in the `forEach` loop

Rewrite promise-based Node.js applications to `async/await`

When is it best to use a `module.exports` vs a `class` vs an `object` literal when defining Node.js modules?

Explain the usage of `module.exports` vs `exports` in that Node.js code sample

Provide some example of config file separation for `dev` and `prod` environments

Rewrite the code sample without `try/catch` block