Top Node Js Interview Questions and Answers

Node.js is a JavaScript runtime environment. Basically, Node.js allows you to run JavaScript on the server and is typically used to build fast and scalable web apps.

Instead of writing all data at once, stream objects in Node.js can help us read or write data in chunks. They are useful for dealing with large files and handling data flow efficiently. For example, reading files, network communications, or video streaming.
 

NPM (Node Package Manager) is a module that lets us install, manage, and share JavaScript packages or libraries for our Node.js projects.

Node.js is single-threaded to make programming simple (this is how it can handle many connections). You don’t need multiple threads.

The event loop in Node.js is the process of checking and working on tasks that have been added to the loop. The event loop executes functionality for Node.js and can manage multiple I/O operations. 

Node.js modules are pieces of reusable code that help to better manage and separate functionality into different files in a project, as well as helping with code maintenance.

In Node.js, synchronous functions will block execution, pausing the program until the task is complete and has to wait. Whereas Asynchronous functions run tasks in the background and the program goes on without waiting, thus improving performance.  

A callback function in Node.js is a function that can be passed as an argument to another function. A callback function will get executed after an operation is finished. We use it to handle asynchronous tasks most of the time. 

In Node.js, we can use the require() function to load and include modules or files into our code so we can use the functionality. 

Middleware is a function in Node.js that is executed during the request-response cycle, request processing, responses, or performing a task like logging, authentication, or parsing data before it gets to the final handler.

There are four main types of streams in Node.js.

1. Readable – Used to read data (e.g., reading a file).
2. Writable – Used to write data (e.g., writing to a file).
3. Duplex – Can read and write data (e.g., a TCP socket).
4. Transform – A duplex stream used to modify or transform the data as it’s written and read (e.g., compressing or encrypting data).
    

We use buffers in Node.js to deal with raw binary data, such as files or network streams. With buffers, we can read, store, and manipulate bytes straight away. Buffers are useful for working with streams, files, or binary data perfectly.

To schedule functions to run asynchronously, we can use setImmediate() and process.nextTick().
Immediately after the current code finishes, process.nextTick() executes. setImmediate() runs on the next tick of the event loop.

Node.js uses try-catch for sync code and error-first callbacks or catch() for async code. The first argument in error-first callbacks will be an error, if an error exists, and the remaining will be result data.

To run multiple instances of your app using multiple CPU cores, we can use the cluster module. By handling more requests in parallel, it helps to scale applications and improves performance and reliability. By sharing the same server port, each instance (worker) runs on its process. 

We can use the EventEmitter class to handle events. To listen to an event, we use .on() and to trigger .emit(). This class helps to develop event-driven applications such as servers and streams. The main methods in this class are,

• Listen for an event: .on(event, listener)
• Trigger the event: .emit(event, args)
• Listen only once: .once(event, listener)
• Remove a listener: .off(event, listener)
   

There are different ways to debug Node.js applications.

1. Use the console – Displays variable values, and we can understand the code easily.
   console.log('Value:', variable);
2. Use the built-in debugger in the terminal.
   bash. 
   node inspect app.js
   Use commands like c (continue), n (next), s (step in), o (step out).
3. Use Chrome Dev Tools for visual debugging
   bash
   node --inspect app.js
   Then open Chrome and go to: chrome://inspect. You can set breakpoints and inspect variables.
4. Try VS Code Debugger – Set breakpoints and run with F5.
   Open your project in VS Code and set breakpoints for the necessary code. Run the debugger (F5) with a launch config or use the auto-config.
5. Use the debug module for selective logging.
   bash
   npm install debug
   Javascript
   const debug = require('debug')('app');
debug('This is a debug message');
   Run
   DEBUG=app node app.js
    

We use the package.json file to save necessary project information such as the project name with version, scripts to run tasks(start, test, etc.), and a list of dependencies. This is useful to manage the project, and others can install the project easily with the command npm install

Callback hell happens when callbacks get nested and making the code hard to read and messy. We can avoid it with the help of Promises, async/await, or by breaking the code into smaller sections of reusable code.

Callback hell example

An example to avoid callback hell

To run another script, we can use fork()as it creates a new Node.js process. It helps run tasks in parallel and communicate between processes.

The following code runs a separate Node.js  script (child.js) in a new process, and both the parent and child communicate by sending messages.

Timers, Pending Callbacks, Poll, Check, and Close Callbacks are the three main phases of the Node.js event loop.  To handle asynchronous tasks, the event loop keeps running these phases.

• Timers run scheduled timers (setTimeout, setInterval).
• Pending Callbacks execute callbacks for some system operations.
• Poll waits for new events or I/O.
• Check runs setImmediate() callbacks.
• Close Callbacks handles functions like socket.on('close').
   

To detect memory leaks, use tools like Chrome DevTools or Node.js heap snapshots to find growing memory. Monitor memory usage with process.memoryUsage().

To fix memory leaks, remove unused event listeners. Avoid global variables holding large data. Clean up timers and callbacks properly.
 

To handle CPU-heavy tasks without blocking the main thread, we can use worker threads. Worker threads let Node.js run JavaScript in parallel threads. They help improve performance for heavy computations.

First, create a worker to run the code separately. Then communicate between the main and worker threads with messages.
The code below runs a separate thread (worker.js) to do heavy tasks without blocking the main program, and they communicate by sending messages.

Vertical scaling adds more CPU, RAM to a single server to make it stronger.

Horizontal scaling runs your app on multiple servers or processes to handle more users. In Node.js, horizontal scaling often uses the cluster module or multiple machines behind a load balancer.

spawn() starts a new process to run a command and streams the output. This is useful for long-running tasks or when we need to handle a large data volume.

fork() specifically starts a new Node.js process to run another script and allows easy communication between parent and child. 

exec() runs a command and buffers the entire output. This is best for short commands where you want the complete result at once.

We can use caching to avoid repeated work. Maintain non-blocking code and use async functions. Use a cluster to run on multiple CPU cores. Avoid memory leaks by cleaning up unused objects. Use tools like profilers to find slow sections.

Microservices architecture breaks an app into small, independent services that work together. Because it’s fast, lightweight, and handles many connections, Node.js is great for microservices. We can build each service separately and connect them via APIs.

To secure a Node.js app, use authentication (like JWT or OAuth) to verify users. Use authorisation to control what users can access. Validate and sanitise user input to prevent attacks. Use HTTPS to encrypt data. Keep dependencies updated and handle errors properly.
 

Use logging tools like Winston or Morgan to record app activity. Monitor performance and errors with services like New Relic or Datadog. Use log rotation to manage log files. Set up alerts for critical issues.
 

Node.js is a JavaScript runtime built on Chrome’s engine. It’s fast and great for handling many connections at once.

Python is a general-purpose programming language often used on the server side. It’s easier for complex tasks, but may be slower for handling many simultaneous requests.