JavaScriptper Svogliati
Il linguaggio scritto in dieci giorni che oggi gira in ogni browser, in mezzi server e nei pannelli che amministri. Quanto basta per leggerlo, farlo girare in produzione con systemd e nginx, e non farsi installare un worm da npm.
[10, 9, 1].sort() → [1, 10, 9]. "È un bug?" — "No, è JavaScript."
Nato in dieci giorni (e si vede)
Doveva essere un linguaggio piccolo per far muovere due bottoni nelle pagine web. È finito ovunque.
Dieci giorni da Netscape
Brendan Eich, in Netscape, scrive il primo prototipo in una decina di giorni. Si chiama Mocha, poi LiveScript, poi JavaScript: con Java non c'entra niente, ma Java andava di moda e il nome vendeva.
ECMAScript
Per non lasciarlo in mano a un'azienda sola, lo standard viene affidato all'ente ECMA. Da allora il nome ufficiale della lingua è ECMAScript; JavaScript è il nome che usano tutti.
V8 e Chrome
Google esce con Chrome e con V8, un motore che compila JavaScript al volo. Di colpo è veloce, e si può pensare di farci applicazioni vere.
Node.js
Ryan Dahl prende V8, lo tira fuori dal browser e gli dà accesso a file e rete. JavaScript arriva sui server.
TypeScript ed ES2015
Microsoft pubblica TypeScript, JavaScript con i tipi. Nel 2015 arriva la revisione che cambia la lingua: let, const, classi, moduli, funzioni freccia, promesse. Da lì una versione nuova all'anno.
npm e i suoi guai
Il registro di pacchetti npm diventa il più grande del mondo, e anche il più attaccato: da left-pad nel 2016 al worm Shai-Hulud nel 2025 (sezione 13).
Perché ti serve, anche se fai il sistemista
Non devi diventare uno sviluppatore web. Ma JavaScript te lo trovi davanti comunque, e prima o poi qualcosa si rompe.
🖥️ I pannelli
Quasi ogni pannello web che amministri è JavaScript nel browser. Quando "il bottone non fa niente", la risposta è nella console degli strumenti per sviluppatori, F12.
⚙️ Node sui server
Prima o poi qualcuno ti chiede di mettere in produzione un'applicazione Node. Va installata bene, fatta partire come servizio e messa dietro un reverse proxy (sezioni 5 e 12).
📦 npm ovunque
Anche progetti che non sono Node usano npm per costruire il frontend. Capire package-lock.json e npm ci ti evita build che cambiano da sole.
🔐 La sicurezza
Gli attacchi alla catena dei pacchetti npm sono fra i più frequenti. Un npm install sul server sbagliato può costare caro.
Quando sì, quando no
Nel browser non hai scelta. Fuori, sì.
Quando sì
- Tutto quello che succede nella pagina web: non c'è alternativa
- Servizi web con tante connessioni aperte e poco calcolo: API, chat, WebSocket
- Quando frontend e backend li scrive la stessa persona, nella stessa lingua
- Strumenti di build dei siti, che sono quasi tutti in Node
Quando no
- Script di sistema: Bash o Python sono già installati, Node no
- Calcoli pesanti: un thread solo, e si blocca tutto (sezione 4)
- Programmi che devono durare dieci anni senza toccarli: l'ecosistema cambia in fretta
- Quando "basterebbe un HTML statico": spesso è vero
Il concetto: un cameriere solo, velocissimo
JavaScript esegue il tuo codice su un solo filo. Non aspetta mai: chiede, passa oltre, e torna quando la risposta è pronta.
C'è un cameriere solo. Prende l'ordine del tavolo 1, lo passa al pizzaiolo e non resta ad aspettare la pizza: va al tavolo 2. Quando una pizza è pronta, il pizzaiolo la mette sul bancone e il cameriere la porta appena ha le mani libere. Il pizzaiolo è il sistema operativo che fa le cose lente, rete e disco; il bancone è la coda dei lavori pronti. Se il cameriere si mette a impastare lui, si ferma tutta la sala.
Non bloccare il filo
Un ciclo lungo o un calcolo pesante ferma tutte le richieste del server, non solo quella. Le cose lente si fanno in modo asincrono, o in un worker a parte.
Le risposte arrivano dopo
Quello che chiedi alla rete o al disco non è pronto alla riga successiva. Si aspetta con await, non sperando che sia già lì.
Usa sempre ===
L'uguale doppio cerca di convertire i tipi e dà risultati assurdi. Il triplo confronta e basta (sezione 6).
Installare Node, quello giusto
Il pacchetto nodejs di Debian funziona, ma spesso è più vecchio di quello che il progetto chiede. Due strade migliori.
| Strada | Per chi | Come si aggiorna |
|---|---|---|
| Repository NodeSource | Server: una versione per tutta la macchina, installata con apt | Con apt upgrade, come il resto |
| nvm | Il tuo utente o la tua macchina di sviluppo: più versioni, una per progetto | nvm install della versione nuova |
| Pacchetto di Debian | Se la versione della distribuzione basta al progetto | Con la distribuzione, ma resta indietro |
# scarica lo script, leggilo, poi lancialo: aggiunge il repository a apt
curl -fsSL https://deb.nodesource.com/setup_24.x -o nodesource_setup.sh
less nodesource_setup.sh
sudo bash nodesource_setup.sh
sudo apt install -y nodejs
node --version
Le basi, e le sue stranezze
La sintassi è quella del C: graffe, punti e virgola, parentesi. Le sorprese stanno nei tipi.
const nome = "Mario"; // const: non la riassegni. Usala di default
let conta = 0; // let: la cambierai. var è il modo vecchio, evitalo
conta += 1;
console.log(`ciao ${nome}, sei il numero ${conta}`); // template string, con i backtick
function somma(a, b) { return a + b; }
const doppio = x => x * 2; // funzione freccia
console.log([1, 2, 3].map(doppio).filter(n => n > 2)); // [ 4, 6 ]
| Scrivi | Ottieni | Perché |
|---|---|---|
0 == "" | true | L'uguale doppio converte i tipi prima di confrontare. Con === è false |
"1" == 1 | true | Stessa cosa. "1" === 1 è false |
typeof null | "object" | Un errore del 1995 mai corretto, per non rompere il web |
typeof [] | "object" | Per sapere se è un array: Array.isArray() |
0.1 + 0.2 | 0.30000000000000004 | Numeri in virgola mobile, come in quasi tutti i linguaggi. Per i soldi si lavora in centesimi |
[10, 9, 1].sort() | [1, 10, 9] | Ordina come testo. Per i numeri: .sort((a, b) => a - b) |
null vuol dire "vuoto apposta", undefined "mai assegnato". Nella pratica si trattano insieme: valore ?? "predefinito" usa il predefinito se il valore è l'uno o l'altro.
Oggetti, array e destrutturazione
Tutto quello che non è un numero o un testo è un oggetto. E il JSON è nato proprio dalla loro sintassi.
const server = { host: "web1", porta: 443, tag: ["prod", "eu"] };
// destrutturazione: tiri fuori i pezzi in una riga, con valori predefiniti
const { host, porta = 80 } = server;
const [primo] = server.tag; // "prod"
// copia con una proprietà cambiata, senza toccare l'originale
const test = { ...server, porta: 8443 };
// ?. non si rompe se un pezzo manca; ?? dà il predefinito
console.log(server.disco?.libero ?? "sconosciuto");
// da e verso JSON
const testo = JSON.stringify(server);
const diNuovo = JSON.parse(testo);
const impedisce di riassegnare la variabile, non di cambiare l'oggetto: server.porta = 22 funziona benissimo. Due variabili che puntano allo stesso oggetto vedono le stesse modifiche: per una copia vera usa lo spread { ...obj } o structuredClone(obj).
Asincrono: promesse e async/await
Prima c'erano le callback annidate, la famosa "piramide". Oggi si scrive quasi come codice normale.
async function stato(url) {
const r = await fetch(url, { signal: AbortSignal.timeout(5000) }); // mai senza timeout
if (!r.ok) throw new Error(`HTTP ${r.status}`); // fetch NON fallisce sui 404 e 500
return r.json();
}
try {
const dati = await stato("https://esempio.it/api/stato");
console.log(dati);
} catch (e) {
console.error("errore:", e.message);
}
// più richieste insieme: allSettled non si ferma al primo errore
const esiti = await Promise.allSettled([stato(a), stato(b), stato(c)]);
console.log("prima");
setTimeout(() => console.log("timeout"), 0);
Promise.resolve().then(() => console.log("promise"));
console.log("dopo");
// prima, dopo, promise, timeout: le promesse passano davanti ai timer
await non hai il risultato: hai una promessa, cioè "arriverà". Il codice va avanti con un oggetto che non è quello che pensi, e spesso nessun errore te lo dice. Se una funzione è async, chi la chiama deve aspettarla.
Browser e Node: stessa lingua, case diverse
Il linguaggio è lo stesso. Cambia quello che ha intorno: la pagina in un caso, il sistema operativo nell'altro.
Nel browser il codice parla con la pagina attraverso il DOM, la pagina vista come un albero di oggetti:
const bottone = document.querySelector("#aggiorna");
bottone.addEventListener("click", async () => {
const r = await fetch("/api/stato");
document.querySelector("#esito").textContent = (await r.json()).messaggio;
});
innerHTML vuol dire eseguire l'HTML che contiene: è il classico XSS. Per il testo si usa textContent.
Moduli: import contro require
Per anni Node ha avuto il suo sistema, poi è arrivato quello standard. Oggi convivono, e ogni tanto litigano.
| Voce | CommonJS (il vecchio) | Moduli ES (lo standard) |
|---|---|---|
| Importare | const fs = require("node:fs") | import fs from "node:fs" |
| Esportare | module.exports = … | export function … |
| Quando | File .cjs, o .js nei progetti vecchi | File .mjs, o .js con "type": "module" nel package.json |
| await in cima al file | No | Sì |
| Nel browser | No | Sì, con <script type="module"> |
Per il codice nuovo usa i moduli ES. Il prefisso node: davanti ai moduli di sistema, come node:fs e node:http, chiarisce che non sono pacchetti scaricati da npm.
npm, il lockfile e npx
Due file contano: package.json dice cosa vuoi, package-lock.json dice cosa hai avuto. In produzione conta il secondo.
| Comando | Fa | Quando |
|---|---|---|
npm install | Installa e può aggiornare il lockfile | Sul tuo computer, mentre sviluppi |
npm ci | Installa esattamente il lockfile, da zero, e si ferma se non combacia | Sui server e nelle build: sempre questo |
npm ci --omit=dev | Come sopra, senza gli strumenti di sviluppo | In produzione |
npm outdated | Cosa c'è di nuovo | Prima di aggiornare |
npm audit | Vulnerabilità note nelle dipendenze | Spesso, ma con giudizio: molte sono in strumenti che non girano in produzione |
npx pacchetto | Scarica ed esegue un pacchetto al volo | Con prudenza: esegue codice di altri sul tuo computer |
npm ci, quello che hai provato è quello che va in produzione.
In produzione: systemd e nginx
Node ascolta in locale, systemd lo tiene acceso, nginx sta davanti con il certificato. Non servono pm2 né altri gestori.
import http from "node:http";
const PORTA = Number(process.env.PORT ?? 3000);
http.createServer((req, res) => {
res.writeHead(200, { "content-type": "application/json" });
res.end(JSON.stringify({ ok: true, url: req.url }));
}).listen(PORTA, "127.0.0.1", () => console.log(`in ascolto su 127.0.0.1:${PORTA}`));
[Unit]
Description=La mia app Node
After=network.target
[Service]
WorkingDirectory=/srv/miaapp
ExecStart=/usr/bin/node server.mjs
Environment=NODE_ENV=production PORT=3000
DynamicUser=yes
Restart=on-failure
NoNewPrivileges=yes
ProtectSystem=strict
[Install]
WantedBy=multi-user.target
location / {
proxy_pass http://127.0.0.1:3000;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# per i WebSocket
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
I log li trovi con journalctl -u miaapp. Le opzioni di sicurezza del servizio sono spiegate nella guida systemd, il resto di nginx nella guida HTTP. Se l'app scrive file, con ProtectSystem=strict le serve una cartella apposta: StateDirectory=miaapp.
La supply chain: chi c'è nel tuo node_modules?
Installi un pacchetto, ne arrivano cento. Basta che uno solo, in fondo alla catena, cada in mani sbagliate.
left-pad
Un autore, arrabbiato per una disputa sul nome di un altro pacchetto, ritira i suoi da npm. Fra questi c'è left-pad, undici righe per aggiungere spazi a sinistra di un testo. Mezzo internet non riesce più a fare le build. Nessun attacco: solo la scoperta di quanto tutto fosse appeso a fili sottili.
event-stream
Il manutentore, stanco, passa il pacchetto a uno sconosciuto che si offre di aiutare. Il nuovo arrivato aggiunge una dipendenza con codice nascosto, mirato a rubare criptovalute da un wallet preciso. Scoperto dopo settimane.
Shai-Hulud, il verme
A settembre compare un malware che si diffonde da solo: ruba i token npm degli sviluppatori e li usa per pubblicare versioni infette degli altri loro pacchetti, e così via. A fine novembre torna più aggressivo, con centinaia di pacchetti e decine di migliaia di repository coinvolti, e il codice che parte già durante l'installazione.
Difese che costano poco
- Lockfile nel repository e
npm ciovunque - Aggiornare con calma, non nel giorno in cui esce una versione: molti attacchi vengono scoperti nei primi giorni
npm ci --ignore-scriptsquando puoi: gli script di installazione sono la via d'ingresso preferita- Pochi pacchetti, e scelti: un pacchetto per sommare due numeri non serve
- Token npm e GitHub con il minimo dei permessi, e la verifica in due passaggi
Da evitare
npm installcome root sul server di produzione- Build e chiavi di produzione sulla stessa macchina dove scarichi pacchetti a caso
- Copiare il comando
npxtrovato in un forum senza sapere cosa installa - Ignorare un pacchetto che di colpo cambia proprietario
La storia del manutentore stanco non è solo di npm: è la stessa della backdoor di xz. Ne parla la guida Storia di Unix e dell'Open Source, e per le vulnerabilità in generale c'è Vulnerabilità ed Enti Cyber.
Errori tradotti
Quello che dice il messaggio, e quello che vuole dire davvero.
| Messaggio | Vuol dire | Cosa fare |
|---|---|---|
x.f is not a function (nei browser vecchi: undefined is not a function) | Stai chiamando qualcosa che non esiste: nome sbagliato, oggetto vuoto, import sbagliato | console.log(x) subito prima, e guarda cosa contiene davvero |
Cannot read properties of undefined | Un pezzo della catena manca: a.b.c con b vuoto | a.b?.c se può mancare, altrimenti trova perché manca |
Nella console del browser: blocked by CORS policy | La pagina chiede dati a un altro dominio, e quel server non dice che può farlo | Si sistema sul server, con l'intestazione Access-Control-Allow-Origin, non nel JavaScript |
Cannot use import statement outside a module | Usi import dove il sistema si aspetta il vecchio require | "type": "module" nel package.json, file .mjs, o type="module" nel tag script. I Node recenti spesso lo capiscono da soli |
EADDRINUSE | La porta è già occupata, spesso da una copia vecchia della tua app | sudo ss -tlpn | grep 3000 e ferma quello che c'è |
EACCES su una porta sotto la 1024 | Le porte basse sono per root | Ascolta su 3000 e metti nginx davanti |
Unhandled promise rejection | Una promessa è fallita e nessuno ha gestito l'errore | Un try/catch intorno all'await, o un .catch() |
npm ERR! ERESOLVE | Due dipendenze vogliono versioni incompatibili di una terza | Leggi chi vuole cosa; --legacy-peer-deps è un cerotto, non una cura |
TypeScript, Deno, Bun e da dove continuare
Tre nomi che sentirai, e dove imparare il resto.
TypeScript
JavaScript con i tipi, di Microsoft. Gli errori del tipo "non è una funzione" li trova prima di eseguire. Nei progetti grandi è ormai la norma.
Deno
Dello stesso autore di Node, per rimediare ai suoi errori: permessi espliciti per rete e file, TypeScript senza configurare niente.
Bun
Un altro motore, punta tutto sulla velocità: installa i pacchetti in un lampo e fa partire i programmi più in fretta. Compatibile con buona parte di Node.
| Cosa | Dove |
|---|---|
| Il riferimento | MDN Web Docs, di Mozilla: la documentazione migliore del web, anche in italiano in parte |
| Node | La documentazione ufficiale su nodejs.org, e il calendario delle versioni |
| Provare al volo | La console del browser, F12, o node senza argomenti nel terminale |
🧘 I cinque comandamenti
- Sempre
===, mai== constdi default,letse serve,varmai- Ogni
asyncva aspettato, ognifetchha un timeout - Lockfile nel repository,
npm cisui server - Node in locale dietro nginx, acceso da systemd
📖 Da leggere dopo
- HTML: la pagina su cui gira
- HTTP e Web Server: nginx e reverse proxy
- systemd: il servizio
- Algoritmi: con un visualizzatore scritto proprio in JavaScript