Cos’è Node.js

Node.js è un ambiente di esecuzione JavaScript fuori dal browser. Usa il motore V8 e mette a disposizione API lato server: file system, rete, processi e altro. Non è un linguaggio diverso da JavaScript, né un framework web.

• Browser: dispone di DOM, window, interfaccia grafica e Web API.
• Node.js: dispone di process, file system, server HTTP e API di sistema. Non esiste un DOM di default.
• Event loop: permette di coordinare molte operazioni I/O senza bloccare il thread JavaScript mentre si aspetta un risultato. Questo non significa che qualsiasi calcolo sia automaticamente parallelo.

console.log('Ciao da Node.js');
console.log('Versione:', process.version);
console.log('Sistema operativo:', process.platform);

Esempio pratico. Un server può avviare la lettura di un file e nel frattempo continuare a gestire altre richieste. Se invece esegue un ciclo CPU molto pesante sul thread principale, le altre richieste possono rallentare.

// ambiente.cjs — avvio: node ambiente.cjs
console.log('JavaScript:', [1, 2, 3].map(n => n * 2));
console.log('API Node:', process.version);
console.log('DOM disponibile?', typeof document);

Installazione e ambiente

Installa una versione LTS attualmente supportata dal sito ufficiale di Node.js. Il corso originale mostra versioni 14 e 16: sono riferimenti storici, non versioni da installare oggi. Usa un editor come Visual Studio Code; le estensioni sono facoltative.

node --version
npm --version
mkdir corso-node
cd corso-node

Crea index.js e lancialo:

node index.js

Esempio aggiuntivo: per aprire la console interattiva basta eseguire node, scrivere 2 + 2 e uscire con .exit. Controllo: se node non viene riconosciuto, riapri il terminale e verifica l'installazione e il PATH.

# PowerShell: un comando per riga
node --version
npm --version
Get-Location
node -e "console.log('Installazione riuscita')"

Prime righe di codice

Un programma Node.js è un normale file .js eseguito dal terminale. La sintassi JavaScript resta valida, salvo le API specifiche del browser.

// index.js
const numero = 3;
if (numero < 3) console.log('Minore di 3');
else if (numero === 3) console.log('Uguale a 3');
else console.log('Maggiore di 3');
for (let i = 0; i < 3; i++) console.log('Giro', i);

node index.js

Esempio aggiuntivo: console.log(typeof document) stampa undefined in un normale processo Node.js. Prima di avviare il programma ricordati di salvare il file.

// argomenti.cjs — avvio: node argomenti.cjs Anna
const nome = process.argv[2] ?? 'visitatore';
function saluta(persona) {
  return `Ciao, ${persona}!`;
}
console.log(saluta(nome));

Oggetti globali e process

In Node.js trovi globali come console, setTimeout, process e globalThis. Il corso usa anche __dirname, __filename, require e module: sono disponibili nei moduli CommonJS, non allo stesso modo nei moduli ESM.

// index.cjs (CommonJS)
console.log(__dirname);
console.log(__filename);
console.log(process.cwd());
console.log(process.env.NODE_ENV ?? 'non definito');
setTimeout(() => console.log('Dopo 200 ms'), 200);

// index.mjs (ES modules): alternativa moderna
import { fileURLToPath } from 'node:url';
import { dirname } from 'node:path';
const filename = fileURLToPath(import.meta.url);
const directory = dirname(filename);
console.log(directory);

NODE_ENV è una convenzione: non garantisce da sola che il codice sia sicuro o configurato correttamente. Evita di stampare in log l'intero process.env, perché può contenere segreti.

// configurazione.cjs — node configurazione.cjs
const porta = Number(process.env.PORT ?? 3000);
if (!Number.isInteger(porta) || porta < 1 || porta > 65535) {
  console.error('PORT deve essere un intero tra 1 e 65535');
  process.exitCode = 1;
} else {
  console.log('Porta configurata:', porta);
}

Creare moduli

Dividere un programma in moduli rende il codice più leggibile, testabile e riutilizzabile. Nel corso si usa soprattutto CommonJS (require, module.exports).

Esempio CommonJS:

// saluti.cjs
function saluta(nome) { return `Ciao, ${nome}!`; }
module.exports = { saluta };

// main.cjs
const { saluta } = require('./saluti.cjs');
console.log(saluta('Anna'));

Alternativa ES Modules:

// saluti.mjs
export const saluta = nome => `Ciao, ${nome}!`;
// main.mjs
import { saluta } from './saluti.mjs';
console.log(saluta('Marco'));

Nota: l'importazione può eseguire il codice al livello superiore del modulo; evita effetti collaterali inattesi all'import.

// prezzi.mjs
export function conIva(prezzo, aliquota = 0.22) {
  return prezzo * (1 + aliquota);
}

// main.mjs — salva questa parte in un secondo file
import { conIva } from './prezzi.mjs';
console.log(conIva(100).toFixed(2));
// Avvio: node main.mjs

Moduli built-in: OS e PATH

I moduli integrati sono già disponibili e non si installano con npm. node:os fornisce dati sul sistema; node:path gestisce percorsi in modo multipiattaforma.

// os-path.cjs
const os = require('node:os');
const path = require('node:path');
console.log(os.platform(), os.arch());
console.log('RAM totale (GiB):', (os.totalmem() / 1024**3).toFixed(1));
const file = path.join(__dirname, 'dati', 'utenti.json');
console.log(file);
console.log(path.basename(file)); // utenti.json
console.log(path.extname(file));  // .json

Esempio aggiuntivo: path.resolve('dati', 'utenti.json') crea un percorso assoluto a partire dalla directory di lavoro corrente; path.join combina segmenti e normalizza il percorso. Non concatenare a mano separatori per costruire percorsi.

// percorsi.cjs — node percorsi.cjs
const path = require('node:path');
const os = require('node:os');
const destinazione = path.join(os.tmpdir(), 'corso-node', 'log.txt');
console.log(path.parse(destinazione));
console.log('Estensione:', path.extname(destinazione));

File system: sync e async

fs consente di leggere e scrivere file. Le operazioni *Sync bloccano il thread JavaScript fino al termine; per server e attività I/O frequenti preferisci le API asincrone.

// file.cjs
const fs = require('node:fs');
fs.writeFileSync('nota.txt', 'Prima riga\n');
fs.appendFileSync('nota.txt', 'Seconda riga\n');
console.log(fs.readFileSync('nota.txt', 'utf8'));

Stessa operazione con Promise:

// file-async.mjs
import { readFile, writeFile, appendFile } from 'node:fs/promises';
try {
  await writeFile('nota.txt', 'Prima riga\n');
  await appendFile('nota.txt', 'Seconda riga\n');
  const testo = await readFile('nota.txt', 'utf8');
  console.log(testo);
} catch (errore) {
  console.error('Errore file:', errore.message);
}

Precisazione: writeFile sovrascrive per impostazione predefinita; appendFile aggiunge in fondo. Non mischiare letture e scritture concorrenti dello stesso file senza coordinarle.

// lettura.cjs — crea prima nota.txt nella cartella di avvio
const fs = require('node:fs');
console.log('1. Avvio lettura');
fs.readFile('nota.txt', 'utf8', (errore, testo) => {
  if (errore) {
    console.error('Lettura fallita:', errore.code);
    return;
  }
  console.log('3. Contenuto:', testo);
});
console.log('2. Il programma può proseguire');

Creare un server HTTP

Node include node:http, utile per capire il funzionamento di un server senza librerie esterne.

// server.cjs
const http = require('node:http');
const server = http.createServer((req, res) => {
  if (req.url === '/' && req.method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
    return res.end('Benvenuto!');
  }
  res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('Non trovato');
});
server.listen(3000, () => console.log('http://localhost:3000'));

Avvia con node server.cjs, visita http://localhost:3000 e prova /manca per il 404.

Concetto chiave: req contiene i dati della richiesta, res costruisce la risposta. Per il routing complesso, Express riduce il codice ripetitivo.

// ora.cjs — node ora.cjs
const http = require('node:http');
const server = http.createServer((req, res) => {
  const url = new URL(req.url, 'http://localhost');
  if (req.method === 'GET' && url.pathname === '/ora') {
    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
    return res.end(JSON.stringify({ ora: new Date().toISOString() }));
  }
  res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('Percorso non trovato');
});
server.listen(3000, '127.0.0.1', () => console.log('Apri http://127.0.0.1:3000/ora'));

npm: pacchetti e comandi

npm è il gestore dei pacchetti usato normalmente con Node.js. Permette di installare librerie esterne e di eseguire script definiti nel progetto.

npm init -y
npm install express@5
npm install --save-dev nodemon
npm uninstall nodemon
npm ls --depth=0
npm run dev

npm run dev funziona solo se esiste uno script dev nel package.json. Esempio aggiuntivo: per riprodurre installazioni coerenti in progetti dotati di lockfile usa npm ci anziché npm install in CI. Non copiare casualmente dipendenze da tutorial datati.

# Dentro una cartella di esercizio
npm init -y
npm install express@5
npm ls --depth=0
npm explain express

package.json e versioni

package.json è il manifesto del progetto: metadati, script e dipendenze. package-lock.json registra le versioni risolte ed è normalmente da includere nel versionamento.

{
  "name": "laboratorio-node",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "start": "node server.js",
    "dev": "node --watch server.js"
  },
  "dependencies": {
    "express": "^5.0.0"
  }
}

Attenzione: la versione di Express qui è illustrativa, non un vincolo da incollare ciecamente. È meglio usare npm install express, lasciando che npm scriva la versione effettivamente installata.

• ^1.2.3: permette aggiornamenti compatibili secondo SemVer all'interno della major 1.
• ~1.2.3: permette generalmente aggiornamenti patch nella minor 2.
• dependencies: necessarie all'esecuzione; devDependencies: strumenti di sviluppo.

{
  "name": "prima-api",
  "version": "1.0.0",
  "private": true,
  "scripts": {
    "start": "node server.cjs",
    "dev": "node --watch server.cjs",
    "check": "node --check server.cjs"
  }
}

Riavvio automatico: nodemon e watch

Il problema mostrato nelle prime lezioni è dover riavviare manualmente Node dopo ogni modifica. nodemon lo risolve; le versioni moderne di Node offrono anche --watch.

# soluzione senza pacchetto aggiuntivo
node --watch server.js
# alternativa con dipendenza di sviluppo
npm install --save-dev nodemon
npx nodemon server.js

Esempio aggiuntivo: nel package.json imposta "dev": "node --watch server.js", poi esegui npm run dev. Per la produzione usa normalmente uno script di avvio stabile e una gestione appropriata del processo, non un watcher di sviluppo.

// osserva.cjs — avvio: node --watch osserva.cjs
console.log('Nuovo processo:', process.pid);
console.log('Avviato:', new Date().toISOString());
setInterval(() => console.log('Ancora attivo'), 5000);

Event loop e non-blocking

L'event loop orchestra l'esecuzione del codice e dei callback quando le operazioni asincrone terminano. Non confondere asincronia, parallelismo e multithreading: il codice JavaScript di un processo Node normalmente gira su un thread principale, mentre parte del lavoro I/O è delegata al sistema operativo o al thread pool.

console.log('A');
setTimeout(() => console.log('C (timer)'), 0);
Promise.resolve().then(() => console.log('B (microtask)'));
console.log('D');
// A, D, B, C

Esempio aggiuntivo: await readFile(...) lascia spazio ad altre operazioni durante l'attesa; un ciclo while che occupa la CPU per molti secondi blocca comunque l'event loop. Per calcoli pesanti valuta worker thread o processi separati.

// attese.mjs — node attese.mjs
import { setTimeout as pausa } from 'node:timers/promises';
async function lavoro(nome, ms) {
  await pausa(ms);
  return nome;
}
const risultati = await Promise.all([
  lavoro('lento', 80),
  lavoro('veloce', 20)
]);
console.log(risultati);

EventEmitter e programmazione a eventi

EventEmitter fornisce un modello per emettere eventi e registrare ascoltatori. È utile per notifiche interne, strumenti e flussi applicativi.

// eventi.cjs
const { EventEmitter } = require('node:events');
const bus = new EventEmitter();
bus.on('utenteCreato', utente => console.log('Creato:', utente.nome));
bus.once('primoAccesso', () => console.log('Solo una volta'));
bus.emit('utenteCreato', { nome: 'Luca' });
bus.emit('primoAccesso');
bus.emit('primoAccesso'); // nessun secondo log

Attenzione: emit() invoca sincronamente gli ascoltatori registrati. EventEmitter non crea automaticamente code persistenti né rende le funzioni asincrone. Gestisci con cura gli eventi error.

// ascoltatori.cjs — node ascoltatori.cjs
const { EventEmitter } = require('node:events');
const eventi = new EventEmitter();
function registra(id, totale) {
  console.log(`Ordine ${id}: ${totale} euro`);
}
eventi.on('ordine', registra);
eventi.emit('ordine', 7, 25);
eventi.off('ordine', registra);
eventi.emit('ordine', 8, 30);

Stream: dati a pezzi

Uno stream gestisce dati in modo incrementale, senza necessariamente caricare l'intero contenuto in memoria. È utile per file grandi, download e trasferimenti HTTP.

// copia.cjs
const fs = require('node:fs');
const { pipeline } = require('node:stream/promises');
(async () => {
  try {
    await pipeline(
      fs.createReadStream('origine.txt'),
      fs.createWriteStream('copia.txt')
    );
    console.log('Copia completata');
  } catch (errore) { console.error(errore.message); }
})();

Esempio aggiuntivo: con gli stream si può inviare al client un file di grandi dimensioni mentre lo si legge. pipeline() propaga in modo più affidabile errori e chiusura delle risorse rispetto a un semplice pipe() usato senza gestione degli errori.

// dimensione.mjs — crea prima origine.txt; node dimensione.mjs
import { createReadStream } from 'node:fs';
let byte = 0;
try {
  for await (const chunk of createReadStream('origine.txt')) {
    byte += chunk.length;
  }
  console.log('Byte letti:', byte);
} catch (errore) {
  console.error('Lettura fallita:', errore.message);
}

Richieste HTTP: struttura e metodi

Una richiesta HTTP include metodo, percorso, header e opzionalmente un body. Una risposta include codice di stato, header e body. HTTP è un protocollo richiesta-risposta; HTTPS aggiunge la protezione TLS.

Codici frequenti: 200 OK, 201 creato, 204 riuscito senza contenuto, 400 richiesta errata, 404 non trovato, 500 errore del server.

curl -i http://localhost:3000/

Esempio aggiuntivo: un browser che apre un URL invia normalmente una GET; per inviare JSON e scegliere altri metodi puoi usare curl, Postman o il fetch() del frontend.

GET /api/persone?limite=2 HTTP/1.1
Host: localhost:3000
Accept: application/json

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8

{"dati":[{"id":1,"nome":"Anna"}]}

Introduzione a Express

Express è un framework web che semplifica server, middleware e routing. Non sostituisce Node: vi gira sopra.

mkdir mini-express
cd mini-express
npm init -y
npm install express@5

// server.cjs
const express = require('express');
const app = express();
app.get('/', (req, res) => res.send('Home Express'));
app.get('/saluti/:nome', (req, res) => {
  res.json({ messaggio: `Ciao ${req.params.nome}` });
});
app.listen(3000, () => console.log('http://localhost:3000'));

Esegui node server.cjs. Esempio aggiuntivo: visita /saluti/Anna. Il callback della route riceve req (richiesta) e res (risposta).

// mini.cjs — npm install express@5; poi node mini.cjs
const express = require('express');
const app = express();
app.get('/salute', (req, res) => {
  return res.status(200).json({ servizio: 'attivo' });
});
app.use((req, res) => {
  res.status(404).json({ errore: 'Percorso non trovato' });
});
app.listen(3000, '127.0.0.1', () => console.log('Server pronto sulla porta 3000'));

Servire file statici

I file statici (HTML, CSS, immagini e JavaScript client) possono essere serviti direttamente da una directory con express.static.

// server.cjs
const express = require('express');
const path = require('node:path');
const app = express();
app.use(express.static(path.join(__dirname, 'public')));
app.listen(3000);

<!-- public/index.html -->
<!doctype html><html lang="it"><meta charset="utf-8">
<title>Demo</title><h1>Benvenuto nel sito statico</h1></html>

Esempio aggiuntivo: creando public/stile.css il file diventa recuperabile con /stile.css. Nota: l'esempio usa CommonJS e quindi __dirname. Evita di mettere nella cartella pubblica credenziali o file sensibili.

// Dentro l'app Express CommonJS, prima della 404 finale
const path = require('node:path');
const cartella = path.join(__dirname, 'public');
app.use('/assets', express.static(cartella));
app.get('/about', (req, res, next) => {
  res.sendFile(path.join(cartella, 'about.html'), errore => {
    if (errore) next(errore);
  });
});

API JSON e server-side rendering

Il corso distingue due modalità: API, che restituiscono normalmente dati come JSON, e SSR, in cui il server genera HTML per il browser. Sono approcci combinabili.

app.get('/api/profilo', (req, res) => {
  res.json({ id: 1, nome: 'Sara' });
});
app.get('/pagina', (req, res) => {
  res.type('html').send('<h1>Pagina generata dal server</h1>');
});

Esempio aggiuntivo: un frontend React può chiamare /api/profilo e costruire la vista nel browser; un'app SSR potrebbe invece renderizzare lato server un template con lo stesso profilo. In entrambi i casi serve gestire correttamente errori e dati in ingresso.

<!-- demo-client.html: servilo dalla cartella public dell'app -->
<p id="nome">Caricamento...</p>
<script>
async function carica() {
  const risposta = await fetch('/api/profilo');
  if (!risposta.ok) throw new Error(`HTTP ${risposta.status}`);
  const profilo = await risposta.json();
  document.querySelector('#nome').textContent = profilo.nome;
}
carica().catch(() => {
  document.querySelector('#nome').textContent = 'Impossibile caricare';
});
</script>

JSON come formato di scambio

JSON è un formato testuale con oggetti, array, stringhe, numeri, booleani e null. In Express res.json() serializza un oggetto JavaScript e imposta la risposta JSON.

app.use(express.json()); // interpreta richieste con body JSON
app.get('/api/prodotti', (req, res) => {
  res.json([{ id: 1, nome: 'Tastiera', prezzo: 45 }]);
});
app.post('/api/eco', (req, res) => {
  res.status(201).json({ ricevuto: req.body });
});

Esempio aggiuntivo: invia {"nome":"Mouse"} con header Content-Type: application/json. Sicurezza: il fatto che req.body sia stato interpretato come JSON non significa che i dati siano validi: controlla tipi, lunghezze e valori.

// conversioni.cjs — node conversioni.cjs
const persona = { nome: 'Anna', attiva: true, ruoli: ['editor'] };
const testo = JSON.stringify(persona);
const ricostruita = JSON.parse(testo);
console.log(typeof testo);       // string
console.log(ricostruita.nome);   // Anna
console.log(persona === ricostruita); // false

Parametri della route

I parametri della route identificano una risorsa all'interno dell'URL. Nel percorso /api/persone/:id, il segmento :id è letto da req.params.id.

const persone = [{ id: 1, nome: 'Anna' }, { id: 2, nome: 'Luca' }];
app.get('/api/persone/:id', (req, res) => {
  const id = Number(req.params.id);
  if (!Number.isInteger(id)) return res.status(400).json({ errore: 'ID non valido' });
  const persona = persone.find(p => p.id === id);
  if (!persona) return res.status(404).json({ errore: 'Non trovata' });
  res.json(persona);
});

Esempio aggiuntivo: /api/persone/2 restituisce Luca; /api/persone/abc restituisce 400, mentre /api/persone/999 restituisce 404.

// Frammento da inserire in un'app Express
app.get('/articoli/:categoria/:id', (req, res) => {
  const { categoria, id: testoId } = req.params;
  const id = Number(testoId);
  if (!/^[1-9]\d*$/.test(testoId) || !Number.isSafeInteger(id)) {
    return res.status(400).json({ errore: 'ID numerico positivo richiesto' });
  }
  res.json({ categoria, id });
});

Query string e filtri

I parametri query seguono ? nell'URL: /api/persone?cerca=an&limite=5. In Express sono in req.query, che contiene input da considerare non attendibile.

app.get('/api/persone', (req, res) => {
  const cerca = String(req.query.cerca ?? '').toLowerCase();
  const limiteRaw = Number(req.query.limite ?? 10);
  const limite = Number.isInteger(limiteRaw)
    ? Math.min(Math.max(limiteRaw, 1), 100) : 10;
  const risultato = persone
    .filter(p => p.nome.toLowerCase().includes(cerca))
    .slice(0, limite);
  res.json(risultato);
});

Esempio aggiuntivo: la ricerca ?cerca=lu&limite=1 restituisce al massimo una persona il cui nome contiene lu. Per grandi dataset filtri e paginazione andrebbero applicati nel database, non all'array intero.

// Costruire una query senza concatenare a mano i valori
const query = new URLSearchParams({ cerca: 'Anna Maria', limite: '2' });
console.log(`/api/persone?${query}`);
// /api/persone?cerca=Anna+Maria&limite=2

// Esempio di paginazione su un array già filtrato
const risultati = ['Anna', 'Luca', 'Sara', 'Marta'];
const offset = 2;
const limite = 2;
console.log(risultati.slice(offset, offset + limite));

Middleware: ordine e next

Un middleware è una funzione che opera tra richiesta e risposta. Può leggere/modificare req, rispondere o passare il controllo con next(); l'ordine di registrazione conta.

app.use((req, res, next) => {
  console.log(req.method, req.path);
  next();
});
app.use(express.json());
app.get('/salute', (req, res) => res.json({ ok: true }));
app.use((req, res) => res.status(404).json({ errore: 'Route inesistente' }));

Esempio aggiuntivo: un middleware di autenticazione può controllare una sessione prima delle route private. Attenzione: se non invii una risposta e non chiami next(), la richiesta resta in sospeso. Un middleware di errore ha firma (err, req, res, next).

// Frammento: middleware specifico per una route
function richiediFormatoJson(req, res, next) {
  if (!req.is('application/json')) {
    return res.status(415).json({ errore: 'Invia application/json' });
  }
  return next();
}
app.post('/api/eco', richiediFormatoJson, express.json(), (req, res) => {
  res.json({ ricevuto: req.body });
});
// Evita di registrare anche un'altra POST /api/eco prima di questa.

Testare le API con Postman

Postman è un client HTTP grafico, comodo per provare GET/POST/PUT/DELETE, header e JSON. Non è obbligatorio: puoi ottenere test riproducibili anche con curl.

# recuperare tutte le persone
curl -i http://localhost:3000/api/persone
# inviare dati JSON
curl -i -X POST http://localhost:3000/api/persone \
  -H "Content-Type: application/json" \
  -d '{"nome":"Giulia"}'

Esempio aggiuntivo: verifica non solo il contenuto ma anche lo status HTTP. Se la creazione riesce, il server dovrebbe restituire 201; se manca nome, 400. Nota: su Windows PowerShell curl può avere comportamenti diversi in base alla versione e agli alias; usa curl.exe se necessario.

# PowerShell: dopo aver avviato l'API del laboratorio
$base = 'http://localhost:3000/api/persone'
$body = @{ nome = 'Giulia'; ruolo = 'analista' } | ConvertTo-Json
$creata = Invoke-RestMethod -Method Post -Uri $base -ContentType 'application/json' -Body $body
$creata.id
Invoke-RestMethod -Method Get -Uri "$base/$($creata.id)"

API GET: elenco e dettaglio

GET recupera risorse e non dovrebbe modificarle. Spesso un'API espone due route: elenco e dettaglio.

const persone = [{ id: 1, nome: 'Anna' }, { id: 2, nome: 'Luca' }];
app.get('/api/persone', (req, res) => res.json(persone));
app.get('/api/persone/:id', (req, res) => {
  const persona = persone.find(p => p.id === Number(req.params.id));
  if (!persona) return res.status(404).json({ errore: 'Non trovata' });
  res.json(persona);
});

Esempio aggiuntivo: GET /api/persone restituisce un array; GET /api/persone/1 un singolo oggetto. Gli esempi usano un array in memoria, quindi i dati scompaiono al riavvio.

// Frammento: app Express e array persone già definiti
app.get('/api/rubrica', (req, res) => {
  const dati = persone.map(({ id, nome }) => ({ id, nome }));
  res.json({ totale: dati.length, dati });
});

API POST: creare risorse

POST inserisce una nuova risorsa. I dati arrivano spesso nel body JSON, da validare prima dell'inserimento.

app.use(express.json());
let prossimoId = 3;
app.post('/api/persone', (req, res) => {
  const nome = req.body?.nome;
  if (typeof nome !== 'string' || !nome.trim()) {
    return res.status(400).json({ errore: 'Nome obbligatorio' });
  }
  const persona = { id: prossimoId++, nome: nome.trim() };
  persone.push(persona);
  res.status(201).json(persona);
});

Esempio aggiuntivo: due POST con lo stesso nome generano due record con ID distinti. In un'app reale occorrono regole di unicità e un database se sono richiesti.

// Frammento per l'API: persone e prossimoId già definiti
app.post('/api/iscritti', (req, res) => {
  const nome = req.body?.nome;
  if (typeof nome !== 'string' || nome.trim().length < 2) {
    return res.status(400).json({ errore: 'Nome di almeno 2 caratteri' });
  }
  const persona = { id: prossimoId++, nome: nome.trim() };
  persone.push(persona);
  return res.status(201).location(`/api/persone/${persona.id}`).json(persona);
});

API PUT: aggiornare

PUT serve convenzionalmente a sostituire la rappresentazione della risorsa; il corso lo usa per aggiornare un elemento di un array. Per modifiche parziali si usa spesso PATCH.

app.put('/api/persone/:id', (req, res) => {
  const id = Number(req.params.id);
  const persona = persone.find(p => p.id === id);
  if (!persona) return res.status(404).json({ errore: 'Non trovata' });
  const nome = req.body?.nome;
  if (typeof nome !== 'string' || !nome.trim())
    return res.status(400).json({ errore: 'Nome non valido' });
  persona.nome = nome.trim();
  res.json(persona);
});

Esempio aggiuntivo: con PUT /api/persone/2 e body {"nome":"Marco"}, l'oggetto con ID 2 viene aggiornato senza cambiare ID.

// Frammento: aggiunta all'API persone con campo ruolo
app.patch('/api/persone/:id', (req, res) => {
  const id = Number(req.params.id);
  if (!Number.isSafeInteger(id) || id <= 0)
    return res.status(400).json({ errore: 'ID non valido' });
  const persona = persone.find(p => p.id === id);
  if (!persona) return res.status(404).json({ errore: 'Non trovata' });
  const ruolo = req.body?.ruolo;
  if (typeof ruolo !== 'string' || !ruolo.trim() || ruolo.trim().length > 80)
    return res.status(400).json({ errore: 'Ruolo non valido' });
  persona.ruolo = ruolo.trim();
  res.json(persona);
});

API DELETE: eliminare

DELETE rimuove una risorsa individuata normalmente da un ID. Evita di confondere l'ID pubblico con l'indice dell'array: possono essere diversi.

app.delete('/api/persone/:id', (req, res) => {
  const id = Number(req.params.id);
  const posizione = persone.findIndex(p => p.id === id);
  if (posizione === -1)
    return res.status(404).json({ errore: 'Non trovata' });
  persone.splice(posizione, 1);
  res.status(204).end();
});

Esempio aggiuntivo: dopo aver eliminato l'ID 1, gli altri ID non dovrebbero essere ricalcolati. 204 non ha body; 200 con una conferma JSON è un'alternativa.

// elimina.mjs — client Node per l'API del laboratorio attiva
const risposta = await fetch('http://localhost:3000/api/persone/1', {
  method: 'DELETE'
});
if (risposta.status === 204) {
  console.log('Eliminazione riuscita, nessun body da leggere');
} else {
  console.log('Status:', risposta.status, 'Risposta:', await risposta.text());
}

Express Router e organizzazione

Con l'aumentare delle route conviene separarle dal file principale. express.Router() consente di raggruppare endpoint e middleware.

// routes/persone.cjs
const express = require('express');
const router = express.Router();
router.get('/', (req, res) => res.json([{ id: 1, nome: 'Anna' }]));
router.get('/:id', (req, res) => res.json({ id: Number(req.params.id) }));
module.exports = router;

// server.cjs
const express = require('express');
const personeRouter = require('./routes/persone.cjs');
const app = express();
app.use('/api/persone', personeRouter);
app.listen(3000);

Esempio aggiuntivo: un futuro progetto può dividere codice in routes/, controllers/, services/ e repositories/. Il video finale accenna a sviluppi successivi (MVC e database), ma queste parti non sono spiegate nel materiale introduttivo fornito.

// controllers/salute.cjs
function leggiSalute(req, res) {
  res.json({ ok: true });
}
module.exports = { leggiSalute };

// routes/salute.cjs — secondo file
const router = require('express').Router();
const { leggiSalute } = require('../controllers/salute.cjs');
router.get('/', leggiSalute);
module.exports = router;

// server.cjs — aggiunta prima di listen e della 404
// app.use('/api/salute', require('./routes/salute.cjs'));