Node JS interview questions with answers for experience upto 8yrs

1.How do you create a simple HTTP server in Node.js?

const http = require(‘http’); const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader(‘Content-Type’, ‘text/plain’); res.end(‘Hello, World!\n’); }); server.listen(3000, () => { console.log(‘Server running at http://localhost:3000/’); });

2.How does Node.js handle asynchronous programming?

Node.js uses an event-driven architecture, allowing it to perform non-blocking operations through callbacks, promises, and async/await. When an asynchronous operation is called, Node.js offloads the task to the system’s thread pool or the operating system, freeing the main thread to continue processing other requests.

3.Explain the concept of streams in Node.js.

Streams are objects that allow reading data from a source or writing data to a destination in a continuous manner. They are used for handling large amounts of data efficiently, as they process data chunk by chunk instead of loading everything into memory at once. There are four types of streams: readable, writable, duplex, and transform.

4.How does Node.js handle error handling?

Node.js uses a callback-based error handling approach, where errors are passed as the first argument to the callback function. For Promises, errors can be caught using .catch() or the try/catch block in async/await syntax. It is important to handle errors properly to prevent the application from crashing.

5. How do you manage environment variables in Node.js?

Environment variables can be managed using the process.env object. For better organization, libraries like dotenv can be used to load environment variables from a .env file into process.env.

6. Explain the use of the cluster module in Node.js.

Answer: The cluster module allows you to create multiple child processes (workers) that share the same server port, enabling better utilization of multi-core systems. It helps improve performance and scalability of Node.js applications.

7. How do you perform asynchronous operations in Node.js?

Asynchronous operations can be performed using callbacks, Promises, or async/await syntax. For example:

async function fetchData() { try { const response = await fetch(‘https://api.example.com/data’); const data = await response.json(); console.log(data); } catch (error) { console.error(error); } }

8. What is the purpose of the exports object in Node.js?

The exports object in Node.js is a shorthand for module.exports and is used to define the public interface of a module. You can assign functions, objects, or variables to exports to make them accessible to other modules.

9. How do you handle CORS in a Node.js application?

CORS (Cross-Origin Resource Sharing) can be handled using the cors middleware in Express.js. To enable it:

const cors = require(‘cors’); app.use(cors());

10. What is the purpose of the body-parser middleware?

The body-parser middleware is used to parse incoming request bodies in a middleware before your handlers, making it available under req.body. It supports various content types, including JSON and URL-encoded data.

11. Explain the difference between module.exports and exports.

module.exports is the object that is returned as the result of a require call, while exports is a shorthand reference to module.exports. If you assign a value to exports, it still points to the same object, but if you reassign exports, it will no longer point to module.exports.

12. How do you implement logging in a Node.js application?

Implement logging using the built-in console object or by using third-party libraries like winston or morgan for more advanced logging capabilities. For example, using winston:

const winston = require(‘winston’); const logger = winston.createLogger({ transports: [ new winston.transports.Console(), new winston.transports.File({ filename: ‘combined.log’ }) ] }); logger.info(‘This is an info message’);

13. What is a JSON Web Token (JWT) and how is it used in Node.js?

JSON Web Tokens (JWT) are a compact, URL-safe means of representing claims to be transferred between two parties. In Node.js, JWTs are often used for authentication and authorization. They can be created and verified using libraries like jsonwebtoken:

const jwt = require(‘jsonwebtoken’); const token = jwt.sign({ userId: 1 }, ‘secret’, { expiresIn: ‘1h’ }); const decoded = jwt.verify(token, ‘secret’);

14.How do you handle asynchronous code in Node.js to avoid callback hell?

In Node.js, callback hell can be avoided by using:

Promises: They allow chaining .then() calls and handling errors via .catch().
Async/Await: Introduced in ES7, it simplifies promise-based code by making it more readable and synchronous-looking. Async functions return a promise, and you can use await to pause execution until a promise resolves.

15.If Node.js is single-threaded, how can it handle concurrent connections?

Node.js operates on a single thread, but uses an event loop to manage multiple connections asynchronously. Long-running operations (like file I/O or database queries) are offloaded to worker threads managed by libuv in the background, allowing Node.js to continue handling other tasks.

16.How would you implement token-based authentication in Node.js?

Implement token-based authentication using JWT (JSON Web Tokens). The jsonwebtoken npm package can be used to sign and verify tokens. Example:

17.How do you enable CORS in a Node.js app?

const cors = require(‘cors’); app.use(cors());

18.How do you scale a Node.js application across multiple CPU cores?

Use the cluster module in Node.js to fork multiple worker processes, each utilizing a separate core:

19.How would you manage user sessions in an Express.js application?

Use the express-session middleware to manage user sessions. Example:

const session = require(‘express-session’); app.use(session({ secret: ‘mysecret’, resave: false, saveUninitialized: true }));

20. How would you identify and fix memory leaks in a Node.js application?

Use the node-inspect or Chrome DevTools to profile memory usage. Tools like heapdump and memwatch can help identify leaks. Common causes include global variables, event listeners, and long-running closures.

21.What are some security best practices in Node.js?

Best practices include:

Validating user input to prevent SQL injection and XSS.
Using helmet middleware for securing HTTP headers.
Ensuring sensitive data (like passwords) is hashed (e.g., using bcrypt).
Enabling HTTPS for secure communication.

22. How would you write unit tests for a Node.js application?

Use Mocha as a test framework and Chai for assertions. Example:

const { expect } = require(‘chai’); describe(‘Array’, () => { it(‘should return -1 when the value is not present’, () => { expect([1, 2, 3].indexOf(4)).to.equal(-1); }); });

23.What is the difference between process.nextTick() and setImmediate() in Node.js?

process.nextTick() schedules a callback to be executed in the current phase of the event loop, before any I/O events. setImmediate() schedules a callback to be executed in the next iteration or phase of the event loop, after I/O events. process.nextTick() is prioritized over setImmediate().

24.What is the role of the worker_threads module, and how does it differ from the cluster module?

The worker_threads module allows Node.js to run JavaScript code in parallel threads that share memory. Unlike the cluster module (which spawns multiple processes), worker_threads run in the same process, enabling more efficient inter-thread communication via SharedArrayBuffer. This is ideal for CPU-intensive tasks that would otherwise block the event loop, such as heavy computations. The cluster module is more suitable for handling network traffic by spawning multiple processes, while worker_threads is for CPU-bound tasks in a single process.

25.How would you manage secure data transmission between a Node.js server and a client?

Secure data transmission between a Node.js server and client can be achieved using several strategies:

SSL/TLS certificates to encrypt data in transit. In Express, this can be configured by creating an HTTPS server with Node’s https module:

const https = require(‘https’); const fs = require(‘fs’); const express = require(‘express’); const app = express(); const options = { key: fs.readFileSync(‘server-key.pem’), cert: fs.readFileSync(‘server-cert.pem’) }; https.createServer(options, app).listen(443);

JWT (JSON Web Tokens):

For secure authentication and session management, use JWTs for stateless, encrypted tokens. Store sensitive data securely on the client side and validate the token on the server.

Data Encryption:

Use encryption libraries (like crypto in Node.js) to encrypt sensitive data before transmission.

26.What are the strategies to avoid memory leaks?

Strategies to avoid memory leaks:

Use weakMap or weakSet for large objects where references might be short-lived.
Remove unused event listeners with removeListener or off().
Monitor memory usage with tools like node –inspect, heapdump, or memory-leak-debugger.

27.What are async hooks in Node.js, and how can they be used for tracking asynchronous operations?

Async Hooks is an experimental module in Node.js that provides an API to track the lifecycle of asynchronous resources.

Example:

28.would you implement error-handling middleware in Express?

Middleware in Node.js (specifically in Express) refers to functions that execute in the request-response cycle and can modify the request (req), response (res), or end the cycle. Error-handling middleware is a special type of middleware designed to catch and process errors. In Express, it has four arguments: err, req, res, and next. This middleware catches errors from other parts of the application and sends an appropriate response.

Example error-handling middleware:

app.use((err, req, res, next) => { console.error(err.stack); res.status(500).send(‘Something went wrong!’); });

29.When would you use Node.js buffers?

Buffers are used to represent binary data that is directly handled outside of JavaScript (e.g., TCP streams or file system operations). Unlike JavaScript strings, which are UTF-16 encoded, buffers allow you to manipulate raw binary data. Buffers are often used when dealing with streams (e.g., file I/O or network protocols) where binary data needs to be processed in chunks rather than as complete files.

Example:

const buffer = Buffer.from(‘Hello World’); console.log(buffer);

30.What is DNS prefetching, and how can it be implemented in Node.js applications?

DNS prefetching is a technique used to resolve domain names before they are required, reducing latency when making network requests. It can be enabled by sending a Link HTTP header from the server:

res.setHeader(‘Link’, ‘<//example.com>; rel=dns-prefetch’);

31.How do you manage logging in a Node.js application?

Logging in Node.js can be managed using libraries like Winston or Morgan. Best practices include:

Log levels:
Use different log levels (e.g., info, warn, error, debug) to categorize logs based on severity.
Log rotation:
Implement log rotation to prevent log files from growing indefinitely (e.g., with logrotate).

32. Explain about structured logging

Use structured logging (e.g., JSON format) to make logs easier to parse and query, especially when using log aggregation tools like ELK Stack or Datadog.

Example of structured logging with Winston:

const winston = require(‘winston’); const logger = winston.createLogger({ level: ‘info’, format: winston.format.json(), transports: [ new winston.transports.File({ filename: ‘error.log’, level: ‘error’ }), new winston.transports.File({ filename: ‘combined.log’ }) ] });

33.How does Node.js handle file uploads ?

In Node.js, file uploads can be handled using middleware like Multer or Busboy, which process multipart/form-data submitted in POST requests.

34.How can you manage large file uploads efficiently?

For large file uploads:

Use streams to process the file in chunks rather than loading the entire file into memory.
Set size limits to prevent oversized file uploads from exhausting server resources.
Use temporary storage (e.g., saving files to disk or using cloud storage services like AWS S3) rather than handling everything in-memory.

35.What are HTTP/2 benefits, and HTTP/2 is a major improvement over HTTP/1.x, offering:

Multiplexing: Multiple requests over a single TCP connection, reducing latency.
Header compression: Reduces overhead by compressing request and response headers.
Server push: Allows servers to push resources to the client before they are requested.

36.how can you implement HTTP/2 in Node.js?

Implement HTTP/2 in Node.js using the http2 module:

37.What is the purpose of Node.js streams’ highWaterMark option, and how does it impact performance?

The highWaterMark option sets the buffer size (in bytes) for a stream before backpressure is applied. In readable streams, it defines how much data to read from the source before pausing. In writable streams, it defines the threshold before the write() method starts returning false, signaling backpressure.

38.How does Node.js streams’ highWaterMark option impact performance?

Impact on performance: A larger highWaterMark increases memory consumption but allows for fewer I/O operations. A smaller highWaterMark can reduce memory usage but may result in more frequent pauses and resumes, potentially affecting throughput. The key is to balance memory usage and performance.

39.What is “tick” in Node.js, and how is process.nextTick() different from setTimeout()?

A “tick” in Node.js refers to a single pass of the event loop. process.nextTick() schedules a callback to be invoked before the next tick of the event loop, giving it higher priority. In contrast, setTimeout() schedules a callback to be executed after a specified delay, which could be at the start of the next event loop phase or later, depending on the timeout.

Use case:

process.nextTick() is useful for deferring the execution of code to the next iteration of the event loop without waiting for any I/O operations or timers.

40.How can you identify and prevent memory leak?

Identifying memory leaks:

Use process.memoryUsage() to monitor memory consumption.
Use tools like Chrome DevTools, Node’s inspector, or heap snapshots to analyze memory allocations.

Preventing memory leaks:

Avoid unnecessary global variables.
Remove event listeners when they are no longer needed.
Carefully manage closures and avoid retaining references to unneeded objects.

41.What is the purpose of the –inspect flag in Node.js, and how do you use it for debugging?

The –inspect flag enables debugging of a Node.js application by exposing a debugging interface over a WebSocket. This allows tools like Chrome DevTools or VS Code to attach to the process and provide a graphical debugging interface. To use it:

node –inspect index.js

The process will output a URL like chrome-devtools://…, which can be opened in Chrome DevTools. From there, you can set breakpoints, inspect variables, and step through the code.

42 What is the difference between soft and hard clustering in Node.js, and when would you use each?

Soft clustering: This technique allows worker processes to share the same network port. Incoming requests are handled by any available worker, but there is no guarantee of balancing work evenly. It is suitable for simple load distribution across CPU cores using the cluster module

Hard clustering: In hard clustering, each worker process listens on its own port, and a load balancer (e.g., Nginx or HAProxy) distributes requests between them. This gives more control over load balancing and is ideal for handling heavy workloads or when deploying in containerized environments.

43.How does Node.js handle uncaught exceptions?

By default, uncaught exceptions will cause a Node.js application to crash. To prevent this, you can listen to the uncaughtException event:?

process.on(‘uncaughtException’, (err) => { console.error(‘Unhandled Exception:’, err); });

44.What are the security considerations when using eval() in Node.js

Using eval() in Node.js is dangerous because it can execute arbitrary code, leading to security vulnerabilities such as remote code execution (RCE) attacks. It allows attackers to inject malicious code if the input is not properly sanitized.

45.State the mitigation strategies

Mitigation strategies:

Avoid using eval() whenever possible.
If necessary, ensure that the input is highly controlled and sanitized.
Use sandboxing libraries like vm2 to run potentially dangerous code in an isolated environment.

46.How would you scale a Node.js application horizontally?

To scale a Node.js application horizontally (i.e., distribute load across multiple processes or servers):

Cluster module: Use Node.js’s cluster module to create worker processes that share the same server port. This allows the application to use all CPU cores.

Load balancing: Use an external load balancer like Nginx or HAProxy to distribute incoming requests across multiple instances of the Node.js app running on different servers or containers.

47.What is the difference between Buffer.alloc() and Buffer.allocUnsafe()?

Buffer.alloc() initializes a new buffer with a specified size and fills it with zeroes. This method is safe to use because it prevents exposing sensitive data left in memory from previous operations.
Buffer.allocUnsafe() allocates a buffer without initializing it. The contents of the memory may contain old data (leftover from previous operations), which can improve performance by avoiding the zero-fill step but introduces security risks if not handled carefully.

48.How can you create a custom REPL (Read-Eval-Print Loop) in Node.js?

Node.js provides a built-in repl module to create a custom interactive shell (REPL). Customize the REPL by defining commands, setting up custom contexts, or modifying the behavior of the shell. Example of creating a basic REPL:

49.What is Domain in Node.js, and why is it deprecated?

Domains were introduced in Node.js to handle multiple I/O operations as a group and manage uncaught exceptions more gracefully. Domains provide a way to capture errors across asynchronous operations. However, they are deprecated because they introduced complexity and did not fit well with Node.js’s event-driven architecture. Instead, developers should use other error-handling mechanisms such as promises, try/catch with async/await, or libraries like express-async-handler for middleware in Express.

50.What is the libuv library in Node.js, and what role does it play?

libuv is a C library that Node.js uses to provide an abstraction layer for handling asynchronous I/O operations across different platforms. It provides the event loop and manages threads, file systems, DNS, networking, child processes, and more. libuv is essential for making Node.js’s non-blocking I/O model possible, allowing it to efficiently handle a large number of concurrent operations.

Request more information

Node JS interview questions with answers for experience upto 8yrs