Node.js is a powerful, event-driven runtime environment that allows you to run JavaScript code outside the browser, primarily on the server side. Unlike traditional server-side technologies like PHP and Django (Python), Node.js offers non-blocking, asynchronous processing, making it highly efficient and scalable for real-time applications. Its lightweight architecture and single-threaded event loop give it a performance edge in handling concurrent requests.
The Birth of Node.js: Taking JavaScript Beyond the Browser
JavaScript is a scripting language that usually runs inside web browsers. Each browser has its own JavaScript engine to run the code—for example, Chrome uses V8, Firefox uses SpiderMonkey, and Safari uses Apple’s JavaScript engine. That’s why JavaScript can only run inside the browser.
But Ryan Dahl, a software engineer, created something called Node.js. He took the V8 engine and combined it with C++ so that JavaScript could run outside the browser. This made it possible to do things like file handling with JavaScript, which wasn’t possible before.
Note: Node.js is not a library or framework. It’s a JavaScript Runtime Environment.
The Benefits of Node.js are as follows:
- You can run JavaScript outside the browser.
- JavaScript can now interact with the computer's system.
- You can create web servers using JavaScript.
Npm in Node.JS
NPM stands for Node Package Manager. When we install Node.js, it automatically installs NPM. When we are making any new project, we have to make a command in the terminal, such as
npm init // init stands for initialization
It will create a package.json File. It records important metadata about a project, which is required before publishing to NPM, and also defines functional attributes of a project that NPM uses to install dependencies, run scripts, and identify the entry point to our package.
How Node.js Handles Client Requests (Based on Event Loop & Thread Pool)
In a Node.js environment, handling client requests efficiently is Important for building fast and scalable web applications. When a client interacts with a web application, it sends a request to the web server. This request can either be blocking (synchronous) or non-blocking (asynchronous). Node.js uses an Event-Driven Architecture where all incoming requests are first placed into an Event Queue. An Event Loop continuously monitors this queue and processes each request accordingly. Understanding how Node.js handles these requests using the Event Queue, Event Loop, and Thread Pool is essential to optimizing performance and avoiding delays caused by blocking operations.
Follow Step-by-Step to send Request to Node.js Server
- The client sends a request to the Node.js web server to interact with the web application.
- The request can be either blocking (synchronous) or non-blocking (asynchronous). Node.js receives the request and adds it to the Event Queue. Requests from different users (User 1, 2, 3, etc.) are added to the Event Queue.
- Requests are picked in (FIFO – First In, First Out) order. If the request is non-blocking, it is processed immediately, and the response is sent back to the client. If the request is a blocking operation, it is passed to the Thread Pool.
- The Thread Pool has a limited number of threads. If a thread is free, the blocking task is assigned to it.
- Once the task is completed, the thread returns the result back to the Event Loop, which then sends the response to the client.
- If all threads are busy, any new blocking requests must wait in a queue until a thread becomes free.
- This waiting increases the response time for the client. Therefore, it is always better to avoid blocking operations and use non-blocking alternatives whenever possible to maintain performance and scalability.
Note: A Thread is a worker who is working for us. Thread is responsible for working on our Blocking Request.
Blocking or Synchronous Operation
In a blocking or synchronous operation, tasks are executed one at a time in a specific sequence. The program waits for the current task to complete before moving on to the next one. This means if a task takes time—like reading a file or making a network request—the entire program waits until that task finishes. While this approach is simple and easy to understand, it can slow down performance, especially when handling multiple requests or time-consuming operations.
Here's an example to understand synchronous operations:
The script uses fs.readFileSync() which blocks the execution which blocks the execution until the file (sync.txt) is completely read.It reads the file content in UTF-8 encoding and prints it using console.log(result);.
Blocking or synchronous
This shows the output of the synchronous file read from sync.txt. The content eisha: +91 1111111111 and ruhi : +91 2222222222 is printed, which means the file read was completed before moving forward.
Additional logs are added ("1", "2", "3") to demonstrate the blocking nature of fs.readFileSync. Code will pause at fs.readFileSync until the file is read
This output demonstrates synchronous behaviour . First "1" is printed , Then File Content is printed , Then "2" and "3" is printed after the file is read.
Synchronous BehaviourNon-Blocking or Asynchronous Operation
In a non-blocking or asynchronous operation, tasks are executed without waiting for the previous one to finish. Instead of pausing the program, long-running operations like file reading or API calls are handled in the background. Once the task is complete, a callback or promise is used to handle the result. This approach allows the program to stay responsive and handle multiple tasks at the same time, making it ideal for high-performance and real-time applications like web servers.
Non-Blocking RequestIn the above output of Non-Blocking or Asynchronous operation we can see that sequence of execution is Asynchronous as 2 and 3 executed before result can be executed . it means Asynchronous operation Cannot blocked the execution of other till the readFileExecution can take place.
Conclusion
Node.js has extended the power of JavaScript beyond the browser by allowing it to run on the server side using the V8 engine and C++. With features like the Event Loop, Event Queue, and Thread Pool, Node.js efficiently handles both blocking and non-blocking operations, making it ideal for building fast and scalable web applications. By using non-blocking (asynchronous) operations, developers can avoid performance slowdown and ensure smooth execution. Combined with tools like NPM for managing dependencies, Node.js has become a powerful runtime environment for modern full-stack development.