09 set 2025·8 min
Che cos'è Node.js? Spiegazione per principianti
Scopri cos'è Node.js, come esegue JavaScript sui server, perché l'event loop è importante e quando Node.js è la scelta giusta per la tua app.
Scopri cos'è Node.js, come esegue JavaScript sui server, perché l'event loop è importante e quando Node.js è la scelta giusta per la tua app.
Node.js è un programma che ti permette di eseguire JavaScript sul tuo computer (o su un server), non solo dentro un browser web.
È facile confondere i termini, quindi ecco la versione chiara:
Pensa a Node.js come alla “sala macchine” che può eseguire codice JavaScript fuori da Chrome, Firefox, Safari, ecc.
Normalmente, JavaScript gestisce ciò su cui clicchi e ciò che vedi in una pagina web: menu, form, interfaccia interattiva. Il browser fornisce l'ambiente (accesso alla pagina, bottoni, finestre e così via).
Node.js fornisce un ambiente diverso. Invece di lavorare con la pagina web, il tuo JavaScript può lavorare con il computer e la rete: leggere file, parlare con database, gestire richieste web ed eseguire attività programmate.
Una volta che JavaScript può girare fuori dal browser, ne derivano alcuni risultati pratici:
Quindi, quando qualcuno dice “il nostro backend è Node.js”, di solito intende: “Il codice server-side è scritto in JavaScript e gira su Node.js.”
Node.js è nato perché i primi server web faticavano con un compito molto specifico e comune: gestire molte piccole richieste contemporaneamente — specialmente quando quelle richieste implicavano attese su cose lente come database, file system o API esterne.
Prima di Node.js, molte architetture server gestivano ogni connessione in uno stile “una richiesta, un thread/processo”. Questo funzionava, ma diventava costoso ed inefficiente quando migliaia di utenti erano connessi contemporaneamente.
Un esempio classico è una chat o una dashboard in tempo reale: il server passa gran parte del tempo in attesa (risposte di rete, letture disco, query al database). Se ogni utente "occupa" un thread pesante mentre il server aspetta, consumi memoria e CPU solo per star fermi.
Node.js è stato creato nel 2009 da Ryan Dahl. L'idea era semplice:
Questo design ha reso Node.js particolarmente adatto per applicazioni di rete che devono restare reattive sotto carico concorrente.
Node.js è cresciuto rapidamente perché si adattava al modo in cui gli sviluppatori web pensavano già: JavaScript ovunque. Poco dopo, npm (il gestore di pacchetti Node) ha reso facile condividere e riutilizzare codice. Questa combinazione — linguaggio familiare + vasto ecosistema di librerie — ha portato Node dalla “sperimentazione interessante” a strumento mainstream.
Oggi, Node.js spesso alimenta:
Può stare dietro a un'app web o mobile, agire come “backend for frontend” o eseguire il rendering server-side per framework che ne hanno bisogno.
Node.js è spesso descritto come un “runtime JavaScript”. Un runtime è semplicemente un ambiente che può eseguire codice JavaScript e fornire capacità aggiuntive che il JavaScript puro non ha da solo — come leggere file, aprire connessioni di rete o avviare altri programmi.
Al centro di Node.js c'è V8, il motore JavaScript usato anche da Google Chrome. V8 prende il tuo JavaScript e lo esegue in modo efficiente compilando il codice in istruzioni a basso livello che il computer può eseguire rapidamente.
Dettaglio importante: V8 non è Node.js. V8 si concentra sull'esecuzione del linguaggio JavaScript. Node.js è il pacchetto più ampio: V8 più la “colla” che connette JavaScript al sistema operativo.
Ciò che rende Node.js uno strumento lato server è la sua collezione di moduli integrati (API) che espongono funzionalità del sistema operativo in modo adatto a JavaScript. Per esempio:
Quando chiami qualcosa come fs.readFile(...) o avvii un server HTTP, Node smista quel lavoro al sistema sottostante (e alle librerie native) e poi restituisce il risultato al tuo JavaScript.
JavaScript è il linguaggio di programmazione: sintassi, variabili, funzioni e così via.
Node.js è un luogo in cui puoi eseguire quel linguaggio — specificamente un ambiente pensato per creare strumenti da linea di comando e servizi backend, con accesso alla macchina su cui gira. In un browser, JavaScript ha API del browser (DOM, window). In Node, ha API di sistema (file system, rete, processi).
Quando si dice che Node.js è “asincrono”, si intende soprattutto che è bravo a mettere in attesa senza sprecare tempo.
Immagina di preparare la cena e di mettere una pentola d'acqua sul fuoco. Non stai lì a fissarla finché non bolle — tagli le verdure, sistemi la tavola e controlli la salsa. Quando l'acqua è pronta, reagisci.
Molto del lavoro su un server è simile: il programma richiede qualcosa che richiede tempo (leggere un file, interrogare un database, chiamare un'API) e poi aspetta il risultato. In molti sistemi, l'attesa può “bloccare” l'intero programma. Node.js cerca di non farlo.
L'event loop è come un controllore del traffico per i task. Richieste e callback si mettono in fila, e l'event loop decide cosa eseguire dopo. Se un task può essere avviato e poi aspettato (come un'operazione di I/O), Node lo affida al sistema, passa ad altro lavoro e viene notificato più tardi quando il risultato è pronto.
Ecco perché un server Node.js può gestire molte connessioni in modo efficiente: non tiene un thread bloccato in attesa di ogni lettura disco o risposta di rete.
“I/O non bloccante” significa semplicemente: avvia l'operazione lenta, poi continua a fare altro mentre si completa. Quando è finita, Node esegue il pezzo di codice successivo che hai fornito (spesso un callback, la risoluzione di una promise o una continuazione async/await).
Questo stile è ottimo per carichi I/O-heavy, ma non è magico per tutto. Se esegui un calcolo pesante in CPU (come elaborazione di immagini, grandi operazioni di crittografia o analisi dati complesse) nel thread principale, può comunque rallentare tutto — perché l'event loop non può “saltare” un task che sta usando attivamente la CPU.
Node.js è usato principalmente per costruire software server-side con JavaScript: API con cui un sito o un'app mobile comunica, servizi che processano job in background e web server che servono pagine e dati.
Poiché Node.js è bravo a gestire molte richieste senza stare in attesa, è una scelta comune quando la tua app esegue molti piccoli compiti di I/O (letture da database, chiamate a servizi esterni, invio di messaggi) piuttosto che pesanti calcoli matematici.
Alcuni ambiti in cui Node.js è molto usato:
Node.js è adatto per:
Node.js è anche ampiamente usato per strumenti per sviluppatori, come script di build, task runner e CLI (comandi da terminale). Molti workflow moderni di frontend si basano su tool Node anche se l'app finale gira nel browser.
Node.js generalmente non è la scelta migliore per calcoli intensivi in CPU (come rendering video complessi o grandi calcoli scientifici) perché questi task possono bloccare il processo. In questi casi, i team spesso delegano il lavoro a servizi separati, worker in background o linguaggi più adatti al calcolo pesante.
JavaScript è il linguaggio. Node.js e il browser sono due ambienti diversi che possono eseguire quel linguaggio.
Se conosci le basi di JavaScript — variabili, funzioni, oggetti, async/await, promise — quei concetti si trasferiscono direttamente. Ciò che cambia è ciò a cui il tuo codice può accedere.
JavaScript nel browser è progettato per costruire interfacce utente. Ha accesso integrato al DOM (la pagina), eventi da click e digitazione, e API browser come localStorage, cookie e le Web API basate su permessi.
È anche fortemente sandboxato per sicurezza: le pagine web non possono leggere liberamente i file sul tuo computer o aprire connessioni di rete raw quando vogliono. I browser applicano confini di sicurezza per proteggere gli utenti.
Node.js è pensato per eseguire JavaScript fuori dal browser — spesso su server. Dà al tuo codice capacità a livello di sistema, come:
process.env (conservare segreti e configurazioni)Questo potere extra implica anche diverse aspettative di sicurezza. Le app Node non sono sandboxate come i browser. Se il processo Node ha permessi per leggere un file o connettersi in rete, in genere può farlo — quindi bisogna proteggerlo con pratiche di sicurezza server (controllo accessi, gestione dei segreti, igiene delle dipendenze).
Il JS del browser ti aiuta a costruire il frontend (ciò che gli utenti vedono). Node.js ti aiuta a costruire il backend (ciò che gira dietro le quinte). Stesso linguaggio — strumenti e responsabilità diverse.
Uno dei motivi per cui Node.js è esploso è npm, il package manager che viene con Node. Pensa a npm come a un modo comodo per scaricare, aggiornare e condividere mattoncini già pronti per la tua app.
In Node.js, un pacchetto (o modulo) è un pezzo di codice riutilizzabile che risolve un problema specifico — di tutto, dal parsing delle date alla creazione di un server web.
Invece di scrivere tutto da zero, puoi installare un pacchetto e usarlo subito. Questo accelera lo sviluppo e ti permette di affidarti a codice che molte persone hanno già testato in progetti reali.
La maggior parte dei progetti Node ha un file package.json nella radice. È la “lista della spesa” e la scheda informativa del progetto.
Contiene tipicamente:
npm run start o npm testQuando esegui npm install, npm legge package.json, scarica le versioni corrette e le mette nella cartella node_modules.
Il registro npm è enorme, il che è fantastico — ma significa anche che devi essere selettivo.
Preferisci pacchetti attivamente mantenuti (aggiornamenti recenti, documentazione chiara, tracker issue sano). Evita di installare alla cieca ciò che trovi in uno snippet casuale e fai attenzione ai comandi di installazione che copi e incolli. Se un pacchetto è eccessivo per un piccolo compito, una soluzione più piccola o integrata potrebbe essere più sicura.
Node.js ti dà i blocchi di base per creare un server: gestire richieste, inviare risposte, leggere file, parlare con database e altro. Un framework è un insieme di pattern e helper già pronti che si piazzano sopra Node.js per organizzare quei blocchi in una struttura più chiara — così non devi reinventare la stessa configurazione per ogni progetto.
Express è spesso il primo framework Node che la gente impara perché è piccolo, flessibile e molto usato.
Con Express puoi:
/products, esegui questo codice”Non impone una struttura rigida, il che è ottimo per l'apprendimento e per app più piccole.
Se ti piace la semplicità di Express ma vuoi prestazioni e default moderni, Fastify è una alternativa popolare.
Se preferisci un approccio più opinionato e “batteries-included”, soprattutto per team grandi, NestJS è comune. Incoraggia un'architettura strutturata (controller, service, module), che può rendere i grandi codebase più manutenibili.
Usa solo Node.js quando costruisci qualcosa di molto piccolo (un webhook veloce, un tool interno) o vuoi massimo controllo e dipendenze minime.
Scegli un framework quando prevedi molte rotte, logica ripetuta per la gestione delle richieste o un progetto che crescerà nel tempo. La struttura del framework ti fa risparmiare tempo e aiuta a mantenere la complessità sotto controllo.
Node.js è popolare perché rende JavaScript una scelta pratica per il lavoro lato server — specialmente quando la tua app passa la maggior parte del tempo in attesa di risposte di rete o database.
Un grande vantaggio è usare un unico linguaggio su frontend e backend. I team possono condividere conoscenze, riutilizzare la validazione e mantenere un toolset coerente.
Node.js eccelle anche nell'I/O veloce. Se la tua app gestisce molte richieste concorrenti — API, aggiornamenti in tempo reale, chat, streaming — l'approccio non bloccante di Node può essere efficiente e conveniente.
Infine, l'ecosistema è enorme. Ci sono pacchetti npm per quasi tutto: server web, autenticazione, upload file, pagamenti, testing e altro. Questo può accelerare le consegne se scegli con cura.
Le dipendenze possono complicare le cose. I progetti moderni Node possono tirare dentro centinaia (o migliaia) di pacchetti transitivi. Questo aumenta il lavoro di aggiornamento, le revisioni di sicurezza e il rischio di conflitti.
C'è anche una curva di apprendimento sull'asincronia. Lo stile asincrono di JavaScript (Promises, async/await, callback nel codice più vecchio) è potente, ma può portare a flussi difficili da seguire se il codebase non è ben strutturato.
Node.js non è la scelta migliore per compiti pesanti in CPU. Può gestirli, ma spesso avrai bisogno di worker, code o servizi in altri linguaggi per mantenere l'app reattiva.
Molti team usano TypeScript per rendere i progetti Node più facili da mantenere. I tipi catturano errori prima, migliorano l'autocompletamento e rendono i refactor più sicuri — utile man mano che il codice e il team crescono.
In sintesi: i pro e i contro di Node.js dipendono dal carico di lavoro del progetto, dall'esperienza del team e da quanto siete disciplinati con dipendenze e architettura.
Iniziare con Node.js significa principalmente installare il runtime sul tuo computer in modo che possa eseguire JavaScript fuori dal browser.
Quando installi Node.js, stai installando:
Su un server, vale lo stesso: installi Node per far girare la tua app JavaScript — di solito come processo a lunga durata.
Le release di Node seguono generalmente due tracce:
Se sei indeciso, scegli LTS.
Crea un file chiamato hello.js:
console.log("Hello from Node!");
Eseguilo:
node hello.js
import http from "node:http";
http.createServer((req, res) => {
res.writeHead(200, { "Content-Type": "text/plain" });
res.end("It works!\n");
}).listen(3000);
console.log("Server running on http://localhost:3000");
Inizializza un progetto e installa un pacchetto:
npm init -y
npm install express
Se il tuo obiettivo è imparare i concetti di Node.js ma arrivare rapidamente a qualcosa di reale, una piattaforma vibe-coding come Koder.ai può essere un pratico aiuto: descrivi l'app in chat (rotte, modello dati, auth, UI), iteri in Planning Mode e poi esporti il codice sorgente quando sei pronto per studiarlo o personalizzarlo. Non è un sostituto della comprensione di Node — ma può ridurre l'attrito di setup mentre ti concentri su API e flussi asincroni.
Prima di distribuire, assicurati di aver pensato a:
console.log).Node.js attira molte opinioni forti — spesso basate su mezze verità. Ecco alcuni miti comuni, spiegati in modo semplice.
Sono correlati, ma non uguali. Node.js è il programma che esegue JavaScript sul tuo computer/server (un runtime JavaScript). npm è il package manager che ti aiuta a scaricare e gestire librerie di terze parti (spesso chiamate pacchetti npm).
Node è usato sia da team piccoli che da grandi aziende. È una scelta pratica per API, funzionalità in tempo reale (chat, notifiche), strumenti per sviluppatori e backend web dove JavaScript sul server è comodo.
L'esecuzione principale di JavaScript in Node avviene su un solo thread, ma questo non significa che non possa essere performante. L'idea chiave è I/O non bloccante: mentre Node aspetta lavoro di rete o disco, può continuare a gestire altre richieste.
I compiti pesanti in CPU possono comunque essere poco adatti a un singolo thread JS — ma per molti carichi web, Node è veloce ed efficiente.
Node scala con metodi consolidati: eseguire più processi/istanze e distribuire il traffico (ad esempio dietro a un load balancer). Molti sistemi Node in produzione seguono questa strada per gestire grandi volumi di traffico.
Nessuno strumento è universale. Node è ottimo quando vuoi JavaScript end-to-end, ampia disponibilità di pacchetti ed elevate prestazioni per applicazioni I/O-heavy. Se il progetto è soprattutto CPU-bound o richiede latenze prevedibili sotto carico computazionale, un altro stack potrebbe essere più adatto.
Node.js è un modo per eseguire JavaScript sul server, il che significa che puoi costruire backend, strumenti e servizi usando lo stesso linguaggio che spesso usi sul frontend. Brilla quando la tua app passa la maggior parte del tempo ad aspettare richieste di rete, database, upload di file o API di terze parti.
Scegli Node.js se stai costruendo:
Una regola pratica: se il progetto è perlopiù “gestire molte richieste e coordinare I/O”, Node.js è spesso una scelta solida.
Valuta alternative (o pianifica lavoro extra) se:
Node.js può comunque gestire molti di questi casi, ma potresti usare thread di lavoro, servizi esterni o un runtime diverso per la parte critica.
Un buon primo progetto: una piccola API per aggiungere e elencare note.
POST /notes e GET /notesSe vuoi accelerare quell'esperimento, puoi anche prototipare la stessa idea in Koder.ai descrivendo gli endpoint e i campi dati in chat, poi iterando finché il comportamento non corrisponde a quanto costruiresti a mano.
Se vuoi proseguire, questi argomenti si sposano naturalmente con Node.js:
Node.js è un runtime che ti permette di eseguire JavaScript sulla tua macchina o su un server (non solo nel browser).
È comunemente usato per costruire API, web server, script e strumenti per sviluppatori.
No. JavaScript è il linguaggio.
Node.js è un ambiente che esegue JavaScript e fornisce API orientate al server/OS (file, rete, processi).
No. Node.js è la base.
Framework come Express, Fastify o NestJS girano sopra Node.js per aiutarti a strutturare server e rotte più facilmente.
Nel browser, JavaScript interagisce principalmente con la pagina (DOM, click, interfaccia).
In Node.js, JavaScript può svolgere compiti lato server e di sistema come:
L'event loop è il meccanismo che mantiene l'app reattiva.
Avvia operazioni lente (come I/O di rete o disco), poi continua a gestire altro lavoro mentre attende. Quando i risultati sono pronti, esegue il passo successivo del tuo codice (callback, risoluzione di promise o continuazione async/await).
Se sei nuovo o distribuisci in produzione, scegli LTS (Long-Term Support).
Le versioni LTS sono più stabili e ricevono patch di sicurezza più a lungo. Usa “Current” solo se ti servono funzionalità nuove e puoi aggiornare frequentemente.
Crea un file chiamato hello.js:
console.log("Hello from Node!");
Poi esegui:
node hello.js
Node.js è solitamente eccellente per lavori I/O-heavy, ma i compiti CPU-heavy possono bloccare il thread principale.
Se hai encoding video, grandi elaborazioni dati o calcoli intensivi, considera:
Node può scalare eseguendo più istanze e distribuendo il traffico (di solito dietro un bilanciatore di carico).
Un approccio pratico è distribuire più processi/contenitori Node invece di aspettarsi che un singolo processo gestisca tutto.
Usa npm per installare pacchetti, ma sii selettivo:
Il file package.json registra ciò da cui dipendi, e npm install scarica quelle versioni in node_modules.