How is JavaScript code executed in Node.js?

Node.js uses the V8 engine from Google, which compiles JavaScript into machine code directly on the server side.

The execution process looks like this:

1. Parsing: V8 parses the JS code and builds an Abstract Syntax Tree (AST).
2. Compilation: TurboFan, the compiler in V8, compiles the AST into machine code. It first uses a faster compiler (Ignition), then, during optimization, a more efficient one (TurboFan).
3. Execution: The compiled code is executed. Thanks to Node.js's asynchronous architecture and the event loop, I/O operations (like file reading, network requests) do not block the main code execution.
4. Optimization/Deoptimization: V8 constantly profiles code during execution. Frequently executed parts (hot spots) can be optimized for speed. If assumptions for optimization become invalid, deoptimization occurs, reverting to less optimized code.

Main components:

• V8 Engine: Core for parsing, compiling, executing JS.
• libuv: Cross-platform library providing asynchronous support for I/O operations and implementing the event loop.
• Node.js core modules: Built-in modules written in C++ and JavaScript providing basic APIs (http, fs, path, etc.).

Event Loop:

Node.js uses non-blocking I/O via the event loop. When an asynchronous operation is performed, it is handed over to the system kernel (via libuv), and the JS execution thread continues. When the operation completes, the result is queued, and the event loop processes the callback.

// Example of asynchronous operation
const fs = require('fs');

console.log('Start');

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Read error:', err);
    return;
  }
  console.log('File content:', data);
});

console.log('End (will execute before file read completes)');

The fs.readFile call is asynchronous. Libuv handles the file read in a separate thread, and the callback is invoked when done, allowing the main thread to continue executing other code.

Main phases of the event loop (simplified):

• timers: Executes callbacks of setTimeout() and setInterval().
• pending callbacks: Executes system-level callbacks.
• idle, prepare: Internal Node.js operations.
• poll: Waits for new I/O events; executes I/O callbacks.
• check: Executes setImmediate() callbacks.
• close callbacks: Executes close event callbacks.

Node.js's architecture with the event loop allows it to efficiently handle many concurrent requests, making it suitable for high-performance network applications.