Tutorial di Node.js per principianti: da zero alla tua prima app

Casa » Python » Tutorial di Node.js per principianti: da zero alla tua prima app

Se sei il primo contatto con Node.js, ecco una guida pensata per iniziare con buona torta: ci sono le cose più basilari in un flusso di lavoro reale, con esempi pratici e spiegazioni chiare. Ti accompagneremo dal mitico Hola Mundo fino a sfruttare un'app web con Express, passando per i moduli di sistema, npm e l'avvio automatico che ha reso così speciale l'ecosistema di Node.

Además de orientarte con requisiti precedenti, configurazione in Visual Studio Code e primi progetti, sarà come organizzare un server HTTP, inviare petizioni, gestire controller, lavorare con dati POST senza bloccare il file e comprendere la filosofia event-driven. Tutto con un linguaggio cercano, senza rodeo, e con il tocco necessario per non farti perdere.

Requisiti precedenti e cosa aspettarsi da Node.js

Avrai bisogno di alcune conoscenze di base di JavaScript (tipi, variabili, funzioni, oggetti) e ganas de probar cosas con la consola. Node.js è un ambiente di esecuzione JavaScript fuori dal browser, basato su V8, con una libreria standard potente e un modello di esecuzione rigido per eventi e non bloccato. Questo ti permette di gestire molte connessioni concorrenti senza creare un hilo per ogni petizione.

Con Node puedes construir server web, API REST, strumenti della linea di comando, app in tempo reale (chat, notifiche), integrazioni con basi di dati e tutti i progetti IoT. La tua forza è nel manejo di E/S simultaneo, che lo rende ideale per il traffico elevato e le esperienze interattive.

Scarica e installa

Scarica Node.js dal sito web ufficiale su nodejs.org e installalo per il tuo sistema operativo. In Windows, macOS o Linux avrai installatori e pacchetti adeguati. Dopo l'installazione, conferma sul terminale con: node -v y npm -v. npm è il gestore dei pacchetti di Node e ti consentirà di installare librerie di terze parti in forma semplice.

Il tuo primo contatto: Hola Mundo con VS Code

Si usa Visual Studio Code, puoi aprire la cartella del progetto e lanciare il terminale integrato in totale comodità. Crea una cartella di lavoro ed entra in essa: mkdir HelloNode && cd HelloNode.

Ora apri questa cartella su VS Code con codice .. Crea un file chiamato app.js e introdurre algo sencillo para arrancar: un mensaje por consola.

var msg = 'Hello World';
console.log(msg);

Per eseguirlo, apri il terminale integrato in VS Code (Ver > Terminal, o seleziona Ctrl+`), e lancia node app.js. Verás el clásico output “Hello World” nella consolazione; Sì, sento, ma confermo che tutto va bene.

Decidere il server: un server HTTP minimo

Il nodo contiene un modulo nativo chiamato 'http' con ciò che puoi creare un server su poche linee. Il cuore è http.createServer, che riceve una funzione di callback che viene eseguita ogni volta che raccogli una petizione.

var http = require('http');

http.createServer(function (request, response) {
  response.writeHead(200, {'Content-Type': 'text/html'});
  response.write('Hola Mundo');
  response.end();
}).listen(8888);

Arráncalo con node server.js e visita http://localhost:8888/. La magia di Node è sul modello orientato agli eventi: passa una funzione e il runtime la “llama de vuelta” (richiamata) quando succede l'evento (una petición entrante).

Comprendendo callback, sincronizzazione e flusso di esecuzione

In JavaScript las funciones son ciudadanos de primera: puoi passare come argomenti, devolver e archiviare variabili. Questo modello si collega al riquadro degli eventi di Node: il tuo codice registra le funzioni che vengono eseguite quando si verificano i successivi (ad esempio, collega una petizione HTTP).

È fondamentale capire la differenza tra operazioni bloccate e non bloccate. Se si introduce qualcosa che occupa la CPU per secondi (ad esempio, un buco di speranza), il processo intero si arresta e tutte le richieste vengono sollevate. Nel nodo, lavorare sempre con E/S asincrona e richiami o promesse per evitare di bloccare il cappello.

Design modulare: server, router e gestori

Separar responsabilidades ti aiuterà a scalare il progetto: un modulo per il server HTTP, altro per il router e altri per i controllori (gestori di richieste). Puoi esporre le funzioni con exports e richiedi moduli locali con require('./miModulo').

Una struttura tipica potrebbe essere: index.js como punto de entrada, server.js con il server HTTP, router.js per decidere quale funzione mandare ogni percorso e requestHandlers.js con la logica di ogni endpoint. Questa organizzazione mantiene il codice leggibile e facile da verificare.

Extrayendo la ruta y enrutando

L'oggetto richiesto ha l'URL richiesto. El módulo nativo url permitte extraer el pathname sì, si hace falta, la query. In questo modo, il router potrà decidere quale controller eseguire.

var url = require('url');

function onRequest(request, response) {
  var pathname = url.parse(request.url).pathname;
  // route(pathname) ...
}

El router recibe el mapa de rutas a funciones (un oggetto in cui ogni chiave è una rotta, e il valore, il gestore), insieme al percorso, e controlla se c'è una funzione associata. Si esiste, la ejecuta; sì no, devolve un 404.

Facendo sì che il gestore risponda (il patrono corretto)

Una tentación habitual è fare in modo che il controller restituisca una stringa e che il server lo scriva. Ma questo falla quando il gestore ha bisogno di fare qualcosa in automatico (come leggere il disco o eseguire un comando). La soluzione efficace è inyectar el objeto response hasta el handler y que el propio handler escriba la respuesta quando la tenga (ad esempio, all'interno del callback di una funzione asincrona).

// router.js
function route(handle, pathname, response) {
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response);
  } else {
    response.writeHead(404, {'Content-Type': 'text/html'});
    response.write('404 No Encontrado');
    response.end();
  }
}

Questo approccio consente il risponditore si limita a quando la E/S asíncrona concluye, sin bloquear el proceso ni forzar a devolver datas antes de time.

Express: crea un'app web in pochi minuti

Express è un framework minimalista per Node.js che facilita la gestione di percorsi, panorami, middleware e utilità HTTP. Con il tuo generatore puoi creare la struttura di un progetto in pochi secondi, con tappeti per percorsi, viste e risorse statistiche.

1. Crea una cartella per i tuoi progetti: mkdir ExpressProjects && cd ExpressProjects.
2. Genera una plantilla: npx express-generator HelloWorld --view=pug crea l'app con motore di viste Pug.
3. Aprire VS Code con code . y revisa la estructura: bidone (arranque), la percezione (JS/CSS/immagini), percorsi (controladores de rutas), visualizzazioni (plantille), app.js (configurazione), pacchetto.json (scripts y dependencias).
4. Installare le dipendenze con npm install en la carpeta del proyecto.
5. Avvia l'app. Ad esempio, con depurazione: npx cross-env DEBUG=HelloWorld:* npm start.
6. apre http://localhost:3000. Prova a cambiare la vista principale: In views/index.pug, sustituye el título por h1 "Hello World!" e ricaricarsi.

Express incorpora lo necessario para gestire GET, POST, PUT e DELETE, utilizzare middleware, servire statistici, visualizzare visualizzazioni e strutturare un'app di varie pagine con meno attrito.

npm e moduli incorporati in Node

npm è il gestore dei pacchetti di Node e ti permette di installare librerie di terzi. Ad esempio, per aggiungere Express: npm install express. Allora puoi require('express') e utilizzalo nel tuo codice. Questa flessibilità è la chiave per crescere con il tuo progetto.

Además, Node incluye moduli nativi para tareas comunes: fs (archivi), http/https (servitori), path (percorsi), os (datos del sistema), url (analisi dell'URL) e molto altro ancora. Puoi importarlo con require() senza installare nulla.

Provando un modulo nativo: informazioni sul sistema

Il modulo "os" fornisce i dati del sistema operativo. Apri la console ed entra nel REPL del Node con node per provare rapidamente le funzioni senza creare file.

1. Scrivere os.platform() per scoprire la piattaforma (win32, linux, darwin…). Confirmarás el SO activo direttamente.
2. Con os.arch() otterrai l'architettura (x64, arm64…). Útil para binarios o builds.
3. Stati Uniti d'America os.cpus() per vedere i nuclei disponibili. Ideal para equilibrar carga con cluster o processi hijos.
4. Sal del REPL con .exit o pulsando Ctrl+C dos veces. Rápido y sin residuos.

Biblioteca de terceros útil en el día a día

El ecosistema npm es enorme. Alcuni usi popolari: affilato (trattamento di immagini e compressione), PDFKit (generazione di PDF), validatore.js (validazione delle catene), immagine min y UglifyJS (minificazione), fabbro di spiriti (spiriti), winston (registrazione) y comandante.js (CLI). Installate con npm install <paquete> quando ne hai bisogno.

Come eseguire il codice Node.js dal file

Guarda il tuo codice in un file, ad esempio app.js, y ejecútalo con node app.js al terminale. Questo avvia il tuo programma e vedrai i risultati sulla console o, se leva un server, sul tuo navigatore.

Del REPL all'applicazione reale: flusso completo

Provare REPL è perfetto per le piccole funzioni, ma quando crei il tuo codice, ti conviene passare i file, organizzare i moduli e aggiungere script di npm. De esta forma podrás automatizzare le attività con npm run e documentare i comandi di avvio su package.json.

Manejando datos POST sin bloquear

Quando un utente invia un formulario, il corpo della petizione può arrivare in vari trozos. Nel server (callback de createServer) ascoltatori di añade data y end per accumulare il contenuto e procedere alla fine. Indicare anche la codifica, ad esempio UTF-8, per manipolarla correttamente.

request.setEncoding('utf8');
var postBody = '';
request.addListener('data', function(chunk) {
  postBody += chunk;
});
request.addListener('end', function() {
  // route(handle, pathname, response, postBody)
});

Se sono necessari campi individuali aggiuntivi, usa el módulo 'querystring' para parsear el cuerpo cuando llega como application/x-www-form-urlencoded: querystring.parse(postBody).text, Per esempio.

Operazioni costose ed esecutive senza blocco

Per eseguire i comandi di sistema sin detener el servidor, utiliza child_process.exec Rispondi alla richiamata. Puoi aggiungere opzioni come questa timeout o maxBuffer per controllare comandi pesanti. Il patrono è sempre lo stesso: nada de bloquear, e il risponditore quando haya datos.

var exec = require('child_process').exec;

function handler(response) {
  exec('ls -lah', function(error, stdout, stderr) {
    response.writeHead(200, {'Content-Type': 'text/plain'});
    response.write(stdout);
    response.end();
  });
}

Se si cambia il comando per qualcosa di più impegnativo, il resto del percorso continuerà a rispondere normalmente, sempre che non ho svolto un lavoro sincrono e costoso nel capitolo principale.

Subidas de ficheros: enfoque y herramientas

Para manejar carica multiparte (immagini su altri file) la cosa più pratica è ricorrere a un pacchetto specializzato. Moduli come formidabile facilitare parsear formularios multipart/form-data, acceder a los archivos temporales y moverlos a su destino. L'idea è la misma: richiami/promesse e lavorare in modo sicuro con flussi.

Sebbene l'implementazione completa sfugga ai primi passaggi, l'importante è che il caricamento sia integro nel tuo flusso: server que recibe el formulario, router que dirige a la ruta de subida, y Handler que valido, guarda e rispondi con il risultato (por ejemplo, mostrando la immagine).

Struttura della vista e contenuto dinamico

Si opta per Express con Pug u otro motor, il controller passa i dati alla vista ed esta los rendering. Per un formulario sencillo con un'area di testo inviata tramite POST e un percorso che lo mostra, basta con due gestori: uno che serve il formulario e altro che procesa e distribuisci il contenuto ricevuto.

Buone pratiche organizzative

Evita archivos monolíticos. Dividere in moduli, nessuna funzione con verbi che esprimono azioni (ad esempio, Inizio, Subir, lista), y desacopla con inyección de dependencias cuando tenga sentido (passando funciones o mapas de rutas al server y al router). Mantener las capas ligeras te permitirá crecer sin dolores.

Cosa puoi costruire con Node.js

Il suo modello è basato sugli eventi e non bloccante lo fa particolarmente bene per: server web, API REST, app in tempo reale (chat, dashboard), bot e CLI, integrazioni con basi di dati, codici di lavoro e controllo dell'hardware. La facilità di gestione dei websocket e dello streaming lo convertono in una scelta naturale per esperienze interattive.

• Servidores y sitios web con plantillas o SSR.
• API REST preparati per l'alto traffico.
• Tempo reale con prese per chat, notifiche o giochi.
• strumenti da riga di comando per automatizzare le attività.
• Processi con file e basi dati, colas y pipelines.
• IoT e hardware con librerías específicas.

Strumenti di apprendimento e pratica

Esistono ambienti interattivi che mostrano codice e uscita lado a lado, ideales para entender ejemplos rápidos. Così potrai procedere senza creare dati: documentarte, copia esempi ed esegui in locale con il tuo terminale è più che sufficiente all'inizio.

Codice di Visual Studio: produttività senza uscita dall'editor

Il terminale integrato, il depuratore e le estensioni de VS Code hacen que trabajar con Node sea muy cómodo. Da "Versione > Terminale" è possibile aprire le shell, modificare il valore predefinito ed eseguirle node o npm run peccato abbandonare l'editore. Además, configurare launch.json ti permetterà di depurar paso a paso.

Punti di versione e stabilità

Molte guide classiche vengono provate con versioni antiche di Node, ma i concetti si mantengono vigenti: callback, moduli nativi, asincronía, enrutado e separación de responsabilidades. Hoy lavorerà con versioni attuali, più rapide e sicure, e con un ecosistema npm ancora più ricco.

Scarica e risorse aggiuntive

Puoi ampliare lo studio con documentazione, PDF e tutorial. Consulta sempre il sito web ufficiale di Node per novità e scaricamenti e identifica le fonti didattiche incluse ejercicios, quizzes y retos para afianzar conocimientos a medida que avances.

Se cerchi materiale complementare, troverai guide introduttive e riferimenti pratici con esempi, così come i collegamenti da scaricare quando è necessario. Mantén tu foco en practicar: leer está bien; ejecutar, romper cosas y arreglarlas, mejor.

Esempio completo: mini app con router e gestori

Juntando piezas. Imagina un proyecto con index.js que arranca el servidor, server.js con HTTP y parsing de POST, router.js decidere quale funzione eseguire e requestHandlers.js con dos rutas: una che mostra un formulario e un'altra che capisce il testo inviato.

// index.js
var server = require('./server');
var router = require('./router');
var handlers = require('./requestHandlers');

var handle = {};
handle['/'] = handlers.iniciar;
handle['/iniciar'] = handlers.iniciar;
handle['/subir'] = handlers.subir;

server.iniciar(router.route, handle);

// server.js
var http = require('http');
var url = require('url');

function iniciar(route, handle) {
  function onRequest(request, response) {
    var postData = '';
    var pathname = url.parse(request.url).pathname;

    request.setEncoding('utf8');
    request.addListener('data', function(chunk) { postData += chunk; });
    request.addListener('end', function() {
      route(handle, pathname, response, postData);
    });
  }

  http.createServer(onRequest).listen(8888);
}

exports.iniciar = iniciar;

// router.js
function route(handle, pathname, response, postData) {
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response, postData);
  } else {
    response.writeHead(404, {'Content-Type': 'text/html'});
    response.end('404 No Encontrado');
  }
}

exports.route = route;

// requestHandlers.js
var querystring = require('querystring');

function iniciar(response) {
  var body = '<html>'+
    '<head><meta charset=\'UTF-8\' /></head>'+
    '<body>'+
    '<form action=\'/subir\' method=\'post\'>'+
    '<textarea name=\'text\' rows=\'10\' cols=\'40\'></textarea>'+
    '<input type=\'submit\' value=\'Enviar\' />'+
    '</form>'+
    '</body></html>';

  response.writeHead(200, {'Content-Type': 'text/html'});
  response.end(body);
}

function subir(response, postData) {
  var text = querystring.parse(postData).text || '';
  response.writeHead(200, {'Content-Type': 'text/html'});
  response.end('Tu enviaste: ' + text);
}

exports.iniciar = iniciar;
exports.subir = subir;

Con questo escheleto minimo già ce l'hai un servitore funzionante e non bloccato, con percorsi e controller separati, preparato per crescere verso panorami, caricamenti o integrazione con basi di dati.

La chiave del nodo è in pensiero su “acciones”: passare le funzioni, inserire le dipendenze quando si riunisce e mantenere piccoli i blocchi di responsabilità. Così, la tua applicazione sarà più facile per mantenere e adattarsi adeguatamente alla tua complessità.

Tutto quello che ti ho visto da una base solida: installa Node ed esegui il tuo script principale, passando per VS Code, un server HTTP nativo, registrato proprio, Express, npm, moduli nativi, REPL, sincronizzazione senza blocchi e manejo de formularios POST. Con pratiche e piccole iterazioni, potrai costruire progetti ogni volta più completi senza perdere la chiarezza nel codice.