30+ NodeJS Interview Questions And Answers

Node.js can create child processes using the 'child_process' module, to execute other scripts or programs.

const { exec } = require('child_process');
exec('node -v', (error, stdout, stderr) => {
  if (error) {
    console.error(`exec error: ${error}`);
    return;
  }
  console.log(`Node.js version: ${stdout}`);
});

The module.exports is used to expose functions, objects, or variables for use in other files.

Node.js uses worker threads to achieve multi-threading. Below is an example of creating a worker thread.

const { Worker, isMainThread, parentPort } = require('worker_threads');
if (isMainThread) {
  const worker = new Worker(__filename);
  worker.once('message', (message) => {
    console.log(message);
  });
} else {
  parentPort.postMessage('Hello from the worker thread');
}

Streams in Node.js are objects that let you read data from a source or write data to a destination continuously. The four types are Readable, Writable, Duplex, and Transform streams.

To avoid blocking the event loop, you can use asynchronous functions or create child processes. An example using async/await:

async function fetchData() {
  let data = await someAsyncOperation();
  return data;
}

Microservices in Node.js are small, independent services that work together in an application, each running in its own process and communicating via APIs.

The cluster module allows you to create child processes that all share server ports, enhancing performance by load balancing incoming connections across multiple worker processes.

The event emitter is a module in Node.js that allows objects to publish events to be consumed by other objects. See the example below:

const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('an event occurred!');
});
myEmitter.emit('event');

The 'net' module is used for creating TCP or IPC servers and clients.

Garbage collection in Node.js is a memory management process for deallocating objects that are no longer needed. To trigger it manually, use '--expose-gc' flag and 'global.gc()'.

You can debug Node.js applications using the built-in 'debugger' keyword, Node.js Inspector or debugging tools in IDEs such as VSCode.

Uncaught exceptions can be handled with the 'process.on('uncaughtException', handler)' listener, which catches exceptions not caught by any try/catch.

process.nextTick() defers the execution of a callback until the next iteration of the event loop, which is before any I/O events. setImmediate() executes a callback after the current event loop cycle and after any I/O events.

You can monitor performance using tools like PM2, Node.js Application Metrics or the built-in 'perf_hooks' module.

V8 native bindings allow Node.js to call C++ functions from JavaScript code. They are useful for performing tasks that are computationally intensive or not possible in pure JavaScript.