Node Interview Questions

​Node.js is an open-source, cross-platform JavaScript runtime environment that allows developers to execute JavaScript code outside the browser, on the server-side. It uses an event-driven, non-blocking I/O model, making it highly efficient and scalable for building real-time applications, server-side APIs, and web services. Node.js leverages Google's V8 engine to achieve high performance and provides access to a vast ecosystem of libraries through the Node Package Manager (NPM), enabling developers to build powerful and feature-rich applications using JavaScript.

​In JavaScript and Node.js, a callback is a function that is passed as an argument to another function and is executed once the operation of that function is complete. It allows asynchronous operations, such as reading files, making network requests, or querying databases, to handle responses efficiently without blocking the program's execution. Callbacks enable developers to manage non-blocking operations and execute code only when the desired data or task is available, making Node.js applications performant and responsive.

These are the following purposes of Node.js:

• Real-time web applications
• Network applications
• Distributed systems
• General purpose applications

The term I/O stands for input and output. It is used to access anything outside of your application. The I/O describes any program, operation, or device that transfers data to or from a medium or another medium. This medium can be a physical device, network, or files within a system.

I/O is loaded into the machine memory to run the program once the application starts. 

In Node.js, there are two ways to read and execute files: readFile and CreateStream.

• The readFile() process is a fully buffered process that returns the response only when the complete file is pushed into the buffer and is read. This process is called a memory-intensive process, and in the case of large files, the processing can be very slow. 
• On the other hand, the createReadStream() is a partially buffered process that treats the entire process as an event series. The entire file is split into chunks and then processed and sent back as a response one by one. After completing this step, they are finally removed from the buffer. Unlike the readFile process, the createReadStream process is effective for the processing of large files.

​Punycode is a character encoding scheme used in Node.js and other web technologies to represent non-ASCII characters (Unicode) in domain names. It converts Unicode domain names into ASCII-compatible format (ACE), allowing internationalized domain names (IDNs) to be used with the existing DNS infrastructure, which traditionally only supports ASCII characters. This enables domain names with special characters, like accented letters or non-Latin scripts, to be represented in a standardized and compatible way, ensuring smooth functioning of websites with internationalized domain names.

The most crucial difference between operational and programmer errors is that the operational errors are not bugs but problems with the system such as to request timeout or hardware failure. On the other hand, the programmer errors are actual bugs in the application.

In Node.js, Punycode is a character encoding mechanism used to convert Unicode domain names into ASCII-compatible format (ACE). It enables domain names with non-ASCII characters, like accented letters or non-Latin scripts, to be represented in a standardized and compatible way, allowing internationalized domain names (IDNs) to work seamlessly with the existing DNS infrastructure, which traditionally only supports ASCII characters. Punycode ensures smooth functioning of websites with IDNs, making them accessible across different systems and browsers.

Although, Events and Callbacks look similar the differences lies in the fact that callback functions are called when an asynchronous function returns its result whereas event handling works on the observer pattern. Whenever an event gets fired, its listener function starts executing. Node.js has multiple in-built events available through the events module and EventEmitter class which is used to bind events and event listeners.

The Streams are the objects that facilitate you to read data from a source and write data to a destination. There are four types of streams in Node.js:

• Readable: This stream is used for reading operations
• Writable: This stream is used for write operations. 
• Duplex: This stream can be used for both reading and write operations. 
• Transform: It is a type of duplex stream where the output computes according to input.

The Node.js provides Buffer class to store raw data similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. It is a global class and can be accessed in an application without importing a buffer module. Buffer class is used because pure JavaScript is not compatible with binary data. So, when dealing with TCP streams or the file system, it's necessary to handle octet streams.

Operational errors are not bugs, but create problems with the system like request timeout or hardware failure. On the other hand, programmer errors are actual bugs.

Node.js is a virtual machine that uses JavaScript as its scripting language and runs Chrome’s V8 JavaScript engine. Basically, Node.js is based on an event-driven architecture where I/O runs asynchronously making it lightweight and efficient. It is being used in developing desktop applications as well with a popular framework called electron as it provides API to access OS-level features such as file system, network, etc.

• setTimeout/clearTimeout – This is used to implement delays in code execution.
• setInterval/clearInterval – This is used to run a code block multiple times.
• setImmediate/clearImmediate – Any function passed as the setImmediate() argument is a callback that's executed in the next iteration of the event loop.
• process.nextTick – Both setImmediate and process.nextTick appear to be doing the same thing; however, you may prefer one over the other depending on your callback’s urgency. 

A fork in general is used to spawn child processes. In node it is used to create a new instance of v8 engine to run multiple workers to execute the code.

Node.js was created explicitly as an experiment in async processing. This was to try a new theory of doing async processing on a single thread over the existing thread-based implementation of scaling via different frameworks.

The Event Loop in Node.js is a fundamental mechanism that manages and processes asynchronous operations. It continuously checks for pending events and executes the associated callback functions. When an asynchronous task, like reading a file or making a network request, is initiated, Node.js doesn't wait for the result and continues executing other tasks. Once the operation is complete, its callback is added to the event queue. The event loop picks up these callbacks and processes them one by one, allowing Node.js to handle multiple concurrent operations efficiently and maintain non-blocking behavior. This enables Node.js to be highly scalable, responsive, and suitable for real-time applications.

• Task Function
• Concurrency Value

In general, buffers is a temporary memory that is mainly used by stream to hold on to some data until consumed. Buffers are introduced with additional use cases than JavaScript’s Unit8Array and are mainly used to represent a fixed-length sequence of bytes. This also supports legacy encodings like ASCII, utf-8, etc. It is a fixed(non-resizable) allocated memory outside the v8.

Middleware comes in between your request and business logic. It is mainly used to capture logs and enable rate limit, routing, authentication, basically whatever that is not a part of business logic. There are third-party middleware also such as body-parser and you can write your own middleware for a specific use case.

The server is responsible for initializing the routes, middleware, and other application logic whereas the app has all the business logic which will be served by the routes initiated by the server. This ensures that the business logic is encapsulated and decoupled from the application logic which makes the project more readable and maintainable.

It can be managed by a number of package installers and their configuration file accordingly. Out of them mostly use npm or yarn. Both provide almost all libraries of javascript with extended features of controlling environment-specific configurations. To maintain versions of libs being installed in a project we use package.json and package-lock.json so that there is no issue in porting that app to a different environment.

Event Emitters are a mechanism in programming used to handle and propagate events. They are commonly used in event-driven architectures and are prevalent in languages like JavaScript. In simple terms:

Event Emitters are objects or components that can emit or raise events. These events can be subscribed to by other parts of the program (listeners). When an event occurs, the Event Emitter notifies all the registered listeners, allowing them to respond or take appropriate actions based on the event.

In JavaScript, Node.js, and many front-end libraries, Event Emitters are used extensively to implement asynchronous, non-blocking behavior, and to facilitate communication between different parts of an application.

The main advantage of using promise is you get an object to decide the action that needs to be taken after the async task completes. This gives more manageable code and avoids callback hell.

REPL stands for Read-Eval-Print Loop. It is an interactive programming environment that allows developers to interactively run and test code snippets in real-time. REPL is commonly used in interpreted languages like JavaScript, Python, and Ruby.

In the context of Node.js, the Node.js REPL is an interactive command-line interface that enables users to enter JavaScript code, which is then read, evaluated, and the result is printed back to the console. Developers can use the Node.js REPL to experiment with code, test functions, and quickly prototype ideas without the need to write full scripts or create separate files. It's a valuable tool for learning and exploring JavaScript, debugging code, and experimenting with language features or libraries.

ESLint can be used with any IDE to ensure a consistent coding style which further helps in maintaining the codebase. 

​Mocha is a popular testing framework in the Node.js userland. It provides a simple and flexible structure for writing test suites and test cases in JavaScript. Mocha supports various testing styles, including BDD (Behavior-Driven Development) and TDD (Test-Driven Development), and offers useful features like async support and assertion libraries. With Mocha, developers can efficiently test their Node.js applications and ensure code reliability and correctness by automating the testing process and generating informative test reports.

1. Asynchronous and Non-Blocking I /O: Efficiently handles multiple tasks concurrently, improving performance.
   
2. JavaScript on both client and server-side: Same language used throughout the development stack, enhancing productivity.
3. Vast NPM ecosystem for easy code reuse: Access to a wide range of ready-to-use packages and libraries.
4. Fast execution with Google's V8 engine: Ensures rapid execution of code for better performance.
5. Efficient for real-time applications: Suitable for applications requiring continuous data exchange.
6. Easy scalability and horizontal scaling: Simple handling of increased traffic and user demand.
7. Active community support: Abundance of resources, tutorials, and help available from a thriving community.
8. Cross-platform compatibility: Runs on multiple operating systems for versatility.
9. Ideal for microservices architecture: Well-suited for building modular and distributed systems.
10. Enables real-time web applications with WebSockets: Facilitates continuous bidirectional communication between clients and servers.

V8 is an open-source JavaScript engine developed by Google, used to execute JavaScript code in web browsers (like Google Chrome) and server-side environments (like Node.js). It optimizes JavaScript execution for high performance, using Just-In-Time (JIT) compilation and efficient memory management.

1. console: Provides methods to write to the console, useful for debugging and logging.
2. process: Represents the current Node.js process and provides information about it.
3. module: Represents the current module and its exports.
4. require: Used to include modules and files in Node.js applications.
5. __filename: Returns the absolute path of the current module file.
6. __dirname: Returns the absolute path of the current module's directory.
7. global: Provides a global scope for variables and functions, similar to the window object in browsers (Note: It's recommended to avoid using this as much as possible).

The preferred method of resolving unhandled exceptions in Node.js is by using the process.on('uncaughtException') event. This event allows developers to catch unhandled exceptions globally and take appropriate actions, such as logging the error and gracefully shutting down the application to prevent unexpected behavior or crashes. However, it's essential to fix the root cause of the exceptions rather than relying solely on this event handler.

​Libuv is a multi-platform, open-source library in Node.js that provides the foundation for handling asynchronous I/O operations and event-driven programming. It abstracts the underlying operating system's asynchronous I/O capabilities, allowing Node.js to be efficient and non-blocking. Libuv manages tasks like file I/O, network I/O, timers, and threading, making it a critical component of Node.js for achieving high performance and scalability in handling concurrent operations.

​npm (Node Package Manager) is used in Node.js and JavaScript-based projects to manage and install external libraries, packages, and dependencies. It simplifies the process of sharing, reusing, and updating code components. With npm, developers can easily access thousands of open-source packages from the npm registry, speeding up development and improving code quality by leveraging existing solutions for various tasks, such as adding functionalities, connecting to databases, or integrating third-party APIs.

​Stream chaining in Node.js refers to the process of connecting multiple streams together to process data in a series of sequential steps. It involves piping the output of one stream to the input of another stream, forming a chain of streams. This approach is used to efficiently process large amounts of data without loading the entire data set into memory at once. Stream chaining enables a smooth and continuous flow of data, making Node.js applications more scalable and memory-efficient, especially when dealing with files, network communications, or data transformation tasks.

​The package.json file is a crucial file in Node.js projects. It serves as a manifest for the project, containing metadata and configuration details such as the project name, version, author, dependencies, scripts, and more. It also lists all the Node.js packages (dependencies) required for the project to function correctly. This file allows developers to manage and share their projects efficiently, making it easier for others to recreate the project environment accurately using the information provided in package.json.

​In Node.js, concurrency is achieved through its event-driven, non-blocking architecture. It operates on a single-threaded event loop, allowing it to efficiently handle multiple I/O operations concurrently. When an I/O operation is initiated, Node.js continues executing other tasks instead of waiting for the operation to complete. Once the I/O operation is finished, a callback function is triggered, allowing the corresponding code to be executed. This non-blocking approach enables Node.js to handle numerous concurrent connections, making it well-suited for scalable and high-performance applications, especially in scenarios involving real-time interactions and asynchronous tasks.

• I/O operations
• Heavy computation
• Anything requiring blocking

When functions can be treated like any other variable then those functions are first-class functions. There are many other programming languages, for example, scala, Haskell, etc which follow this including JS. Now because of this function can be passed as a param to another function(callback) or a function can return another function(higher-order function). map() and filter() are higher-order functions that are popularly used.

With this question, the interviewer is trying to assess if you’ve had any previous work experience or internship experience where you dealt with similar working environments or technologies. This line of questioning can be easily answered based on your previous experiences. Make sure to keep it concise and detailed as required when answering this question.

This question is common among Node.js interviews. Make sure to answer it to the best of your abilities, and do not bloat but give your honest experiences and explain how you’ve used Node.js before. This is used as a measure to see if you have had any hands-on experience with the language in a working environment before.

Here, the interviewer wants to know your understanding of the job role and the company architecture and your knowledge on the topic. While answering this question, it would add immensely if you knew the job description in detail and the basic usage of the technology in the company. The answer can be further elaborated on how your interests align with the technology, job, and company.

The module.exports function is used to expose two functions and bring them to a usable context. A module is an entity that is used to store relative code in a single snippet. This can be considered as an operation of moving all of the functions into one single file.

he setImmediate() function is meant to execute a single script once the current event loop is complete.

The setTimeout() function is used to hold a script and schedule it to be run after a certain time threshold is over.

The order of execution will solely depend on the context in which the functions are called. If called from the main module, the timing will be based on the performance of the process.

Every single object in Node.js that emits is nothing but an instance of the EventEmitter class. These objects have a function that is used to allow the attachment between the objects and the named events.

Synchronous attachments of the functions are done when the EventEmitter object emits an event.

​In Node.js, the DNS (Domain Name System) lookup function is provided by the dns module. It allows developers to translate domain names to their corresponding IP addresses or vice versa. When a DNS lookup is requested, Node.js queries the operating system's DNS resolver to resolve the domain name. The lookup can be either a simple hostname lookup or a reverse IP address lookup. The DNS lookup function can be used synchronously or asynchronously with callbacks or Promises, enabling developers to handle DNS resolutions efficiently and non-blocking, making network-related operations smoother in Node.js applications.

The control flow function is a common code snippet, which executes whenever there are any asynchronous function calls made, and they are used to evaluate the order in which these functions are executed in Node.js.

Following are the important implementations for security:

• Error handling protocols
• Authentication pipelines

A test pyramid is a methodology that is used to denote the number of test cases executed in unit testing, integration testing, and combined testing (in that order). This is maintained to ensure that an ample number of test cases are executed for the end-to-end development of a project.

Google uses the V8 engine for Node.js because it offers exceptional performance and efficiency in executing JavaScript code. V8 is a high-performance JavaScript engine developed by Google, known for its fast Just-In-Time (JIT) compilation and efficient memory management. By utilizing V8 in Node.js, Google ensures that Node.js applications can handle large-scale, real-time operations and deliver superior performance for server-side scripting. This makes Node.js an excellent choice for building scalable, non-blocking, and high-performance applications, aligning with Google's commitment to providing cutting-edge technology and enhancing developer productivity.

Global objects are objects with a scope that is accessible across all of the modules of the Node.js application. There will not be any need to include the objects in every module. One of the objects is declared as global. So, this is done to provide any functions, strings, or objects access across the application.

Next among the Node JS coding questions, you need to take a look at the usage of assets in Node JS.