1. What is the event loop in Node.js, and how does it work?

   • Answer: The event loop is a core part of Node.js's runtime that handles asynchronous operations. Node.js is single-threaded, and the event loop allows non-blocking I/O operations by offloading tasks to the operating system whenever possible. It continuously checks for pending callbacks, I/O events, timers, and handles them in a loop, which makes Node.js highly efficient for I/O-bound tasks.

2. Explain the difference between setImmediate and process.nextTick in Node.js.

   • Answer: setImmediate schedules a callback to execute on the next iteration of the event loop, after I/O events. process.nextTick adds a callback to the next tick queue, which gets executed before the event loop continues. process.nextTick has a higher priority than setImmediate.

3. How does Node.js handle concurrency?

   • Answer: Node.js handles concurrency using the event loop and a thread pool provided by the libuv library. While JavaScript runs on a single thread, I/O operations, file system tasks, and other long-running operations are offloaded to the thread pool. This allows Node.js to handle multiple operations concurrently without blocking the main thread.

4. What are streams in Node.js, and how do they work?

   • Answer: Streams in Node.js are objects that let you read data from a source or write data to a destination in a continuous fashion. There are four types of streams: Readable, Writable, Duplex, and Transform. Streams are efficient because they handle data chunk by chunk, which is ideal for working with large files.

5. What is a buffer in Node.js, and when would you use it?

   • Answer: A buffer in Node.js is a temporary storage area for binary data. Buffers are used when dealing with raw binary data, such as reading files or handling streams of data over a network connection. Buffers are necessary because JavaScript strings are UTF-16 encoded and do not support binary data directly.

6. How do you manage uncaught exceptions in Node.js?

   • Answer: Uncaught exceptions can be managed using the process.on('uncaughtException', handler) event. However, relying on this should be a last resort, as it is better to handle errors appropriately in your code. For better control, using domains or try-catch blocks for synchronous code and promise.catch or error callbacks for asynchronous code is recommended.

7. Explain the role of the package.json file in a Node.js project.

   • Answer: The package.json file is the heart of a Node.js project. It contains metadata about the project, such as the name, version, and dependencies. It also includes scripts, author details, and configuration options. The package.json file is essential for managing dependencies, scripts, and project information.

8. What is the difference between require and import in Node.js?

   • Answer: require is used in Node.js to load modules using CommonJS, while import is used for ES6 module syntax. require is synchronous and can be used anywhere in the code, while import is asynchronous and must be at the top of the file. ES6 modules provide features like static analysis, tree shaking, and improved performance.

9. How does Node.js handle file system operations?

   • Answer: Node.js provides the fs module to handle file system operations. It offers both synchronous and asynchronous methods for reading, writing, updating, and deleting files. The asynchronous methods are non-blocking and are preferred in most cases to avoid blocking the event loop.

10. What are worker threads in Node.js, and when would you use them?

    • Answer: Worker threads allow you to run JavaScript code in parallel. They are useful for CPU-bound tasks that would otherwise block the event loop. Worker threads are not typically needed for I/O-bound tasks, as Node.js handles them efficiently with the event loop and libuv.

Asynchronous Programming

11. Explain the concept of callbacks in Node.js. What are callback hell and how can you avoid it?

    • Answer: A callback is a function passed as an argument to another function, which is then invoked after an asynchronous operation completes. Callback hell refers to the situation where callbacks are nested within callbacks, making the code hard to read and maintain. It can be avoided using Promises, async/await, or modularizing the code.

12. What are Promises in Node.js, and how do they improve code readability?

    • Answer: Promises represent the eventual completion (or failure) of an asynchronous operation and its resulting value. They improve code readability by flattening the nested callback structure into a more linear and manageable sequence of .then() calls, and they can be further improved using async/await syntax.

13. How does async/await work in Node.js, and what are its benefits?

    • Answer: async and await are syntactic sugar on top of Promises, allowing asynchronous code to be written in a synchronous style. An async function returns a Promise, and await pauses the execution until the Promise is resolved. This makes the code easier to read and maintain, reducing the chances of callback hell.

14. What is the purpose of the util.promisify method in Node.js?

    • Answer: util.promisify converts a callback-based function into a Promise-based function, making it easier to work with async/await. This is particularly useful for older Node.js APIs that do not return Promises.

    • const fs = require('fs');
      const util = require('util');
      const readFile = util.promisify(fs.readFile);

      async function readFileAsync() {
          const data = await readFile('example.txt', 'utf8');
          console.log(data);
      }

15. What are async iterators and generators in Node.js, and how do they differ from regular iterators?
    Answer: Async iterators and generators allow you to iterate over data asynchronously. A regular iterator returns a value synchronously with each iteration, while an async iterator returns a Promise, allowing you to await the resolution of each value. Async generators are functions that can yield values asynchronously, pausing and resuming execution as needed.

    async function* asyncGenerator() {
        yield await Promise.resolve(1);
        yield await Promise.resolve(2);
        yield await Promise.resolve(3);
    }

    (async () => {
        for await (let value of asyncGenerator()) {
            console.log(value);
        }
    })();
     

16. What is the difference between Promise.all and Promise.race?
    Answer: Promise.all waits for all Promises to resolve (or any to reject) and returns an array of results. Promise.race, on the other hand, returns the result of the first Promise to settle (either resolve or reject).

    const p1 = new Promise((resolve) => setTimeout(resolve, 100, 'one'));
    const p2 = new Promise((resolve) => setTimeout(resolve, 200, 'two'));

    Promise.all([p1, p2]).then((values) => {
        console.log(values); // ['one', 'two']
    });

    Promise.race([p1, p2]).then((value) => {
        console.log(value); // 'one'
    });
     

17. How do you handle errors in async/await?
    Answer: Errors in async/await can be handled using try-catch blocks. You wrap the await expression in a try block, and handle any errors in the catch block.
    
    async function fetchData() {
        try {
            const data = await getData();
            console.log(data);
        } catch (error) {
            console.error('Error fetching data:', error);
        }
    }

18. What is an event emitter in Node.js?

    • Answer: An event emitter is a pattern in Node.js that allows objects to emit events and handle those events through listeners. The EventEmitter class in the events module is used to create, fire, and listen to events. This pattern is useful for decoupling code, where different parts of the application can respond to events asynchronously.

19. How does the async module help in handling asynchronous operations in Node.js?

    • Answer: The async module provides utility functions for working with asynchronous JavaScript. It offers a variety of methods to handle tasks such as parallel execution, series execution, and controlling the concurrency level, making it easier to manage complex asynchronous workflows.

20. What are the common pitfalls of asynchronous programming in Node.js, and how can you avoid them?

    • Answer: Common pitfalls include callback hell, unhandled Promise rejections, race conditions, and memory leaks due to improperly handled callbacks. These can be avoided by using Promises, async/await, proper error handling, avoiding shared mutable state, and using tools like Node.js’s built-in memory leak detectors.