Cos'è Node.js e a cosa serve?

Question

Accepted Answer

**Node.js** è un runtime che ti permette di eseguire JavaScript **al di fuori del browser** — su server, CLI e tooling. È costruito sul motore **V8** di Chrome e aggiunge un modello I/O non-blocking, event-driven progettato per applicazioni di rete scalabili.

## L'idea fondamentale: single-threaded, non-blocking I/O

```js
const fs = require("fs");

// non-blocking: the read happens in the background; the callback fires when done
fs.readFile("big.txt", "utf8", (err, data) => {
  console.log("file read complete");
});
console.log("this prints FIRST — the read didn't block");
```

Node esegue il tuo JS su un singolo thread principale ma delega l'I/O (file, rete, DB) al sistema e continua l'esecuzione. Quando l'I/O termina, viene eseguito un callback. Questo è il motivo per cui un singolo processo Node può gestire **migliaia di connessioni simultanee** senza un thread per richiesta.

## Per cosa è utile Node

```text
✓ APIs & web servers (REST, GraphQL) — I/O-bound, many concurrent requests
✓ Real-time apps (chat, live updates) — WebSockets, event-driven model fits well
✓ Microservices — lightweight, fast startup
✓ CLIs & build tools (the entire npm/Vite/webpack ecosystem)
✓ Streaming (video, large files) via streams
```

## Per cosa NON è ideale

```text
✗ CPU-heavy work (image processing, big computations) — blocks the single thread
  → offload to worker threads, a queue, or another service
```

Poiché è single-threaded per il tuo JS, il lavoro pesante della CPU blocca tutto — Node brilla per i carichi di lavoro **I/O-bound**, non per quelli CPU-bound.

## Perché JavaScript ovunque è importante

```text
Same language front-end and back-end → shared code/types, one skill set,
huge npm ecosystem (the largest package registry).
```

## Perché è importante

Node.js ha portato JavaScript al server e ha reso popolare il modello non-blocking, event-driven che lo rende eccellente per applicazioni **I/O-heavy, high-concurrency** (API, real-time, microservizi).

Comprendere *perché* si scala (I/O asincrono su un singolo thread) e *dove fatica* (lavoro CPU-bound) è la base per usarlo bene — è la spina dorsale della maggior parte dei backend JavaScript moderni e del tooling.