Svogliati
🟨

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."

↓
01 / 15

Nato in dieci giorni (e si vede)

Doveva essere un linguaggio piccolo per far muovere due bottoni nelle pagine web. È finito ovunque.

1995

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.

1997

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.

2008

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.

2009

Node.js

Ryan Dahl prende V8, lo tira fuori dal browser e gli dà accesso a file e rete. JavaScript arriva sui server.

2012–15

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.

2016–25

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).

02 / 15

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.

📚 Cosa c'è già altroveL'HTML è nella guida HTML, i servizi di sistema nella guida systemd, nginx e i reverse proxy nella guida HTTP. Per gli script di tutti i giorni sul server, meglio Bash o Python.
03 / 15

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
04 / 15

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.

💡 Il cameriere della pizzeria

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.

L'event loop, il cameriere solo
Il tuo codiceun filo solo, una cosa alla voltaIl sistema fa le cose lenterete, disco, timerCoda delle promessepassa per primaCoda dei timer e degli eventi1. chiede e passa oltre2. pronto3. quando il filo è libero, prima le promessepoi timer ed eventiSe il tuo codice non finisce mai, le code aspettano: tutto il server è fermo
REGOLA 1

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.

REGOLA 2

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ì.

REGOLA 3

Usa sempre ===

L'uguale doppio cerca di convertire i tipi e dà risultati assurdi. Il triplo confronta e basta (sezione 6).

05 / 15

Installare Node, quello giusto

Il pacchetto nodejs di Debian funziona, ma spesso è più vecchio di quello che il progetto chiede. Due strade migliori.

StradaPer chiCome si aggiorna
Repository NodeSourceServer: una versione per tutta la macchina, installata con aptCon apt upgrade, come il resto
nvmIl tuo utente o la tua macchina di sviluppo: più versioni, una per progettonvm install della versione nuova
Pacchetto di DebianSe la versione della distribuzione basta al progettoCon la distribuzione, ma resta indietro
bash · Node dal repository NodeSource
# 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
🗓️ Quale versioneLe versioni pari diventano LTS, cioè supportate a lungo: in produzione usa sempre una LTS. Nel 2026 il riferimento è la 24, e la 26 sta prendendo il suo posto. Dalla 27 Node cambia passo: una versione nuova all'anno, e tutte diventano LTS. Il calendario ufficiale è su nodejs.org.
06 / 15

Le basi, e le sue stranezze

La sintassi è quella del C: graffe, punti e virgola, parentesi. Le sorprese stanno nei tipi.

javascript · variabili, funzioni, testo
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 ]
ScriviOttieniPerché
0 == ""trueL'uguale doppio converte i tipi prima di confrontare. Con === è false
"1" == 1trueStessa 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.20.30000000000000004Numeri 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.

07 / 15

Oggetti, array e destrutturazione

Tutto quello che non è un numero o un testo è un oggetto. E il JSON è nato proprio dalla loro sintassi.

javascript · oggetti e array
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 non vuol dire immutabileconst 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).
08 / 15

Asincrono: promesse e async/await

Prima c'erano le callback annidate, la famosa "piramide". Oggi si scrive quasi come codice normale.

javascript · chiedere qualcosa alla rete
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)]);
javascript · in che ordine escono?
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
🕳️ L'await dimenticatoSenza 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.
09 / 15

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.

Stessa lingua, case diverse
JavaScriptlo stesso linguaggio, spesso V8Nel browserla pagina (DOM)window, documentfetchlocalStorageniente file, niente processiIn Nodefile (node:fs)rete (node:http)process, variabilifetchniente pagina, niente DOM

Nel browser il codice parla con la pagina attraverso il DOM, la pagina vista come un albero di oggetti:

javascript · nel browser
const bottone = document.querySelector("#aggiorna");
bottone.addEventListener("click", async () => {
  const r = await fetch("/api/stato");
  document.querySelector("#esito").textContent = (await r.json()).messaggio;
});
⚠️ textContent, non innerHTMLMettere nella pagina un testo che arriva da fuori con innerHTML vuol dire eseguire l'HTML che contiene: è il classico XSS. Per il testo si usa textContent.
10 / 15

Moduli: import contro require

Per anni Node ha avuto il suo sistema, poi è arrivato quello standard. Oggi convivono, e ogni tanto litigano.

VoceCommonJS (il vecchio)Moduli ES (lo standard)
Importareconst fs = require("node:fs")import fs from "node:fs"
Esportaremodule.exports = …export function …
QuandoFile .cjs, o .js nei progetti vecchiFile .mjs, o .js con "type": "module" nel package.json
await in cima al fileNoSì
Nel browserNoSì, 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.

11 / 15

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.

ComandoFaQuando
npm installInstalla e può aggiornare il lockfileSul tuo computer, mentre sviluppi
npm ciInstalla esattamente il lockfile, da zero, e si ferma se non combaciaSui server e nelle build: sempre questo
npm ci --omit=devCome sopra, senza gli strumenti di sviluppoIn produzione
npm outdatedCosa c'è di nuovoPrima di aggiornare
npm auditVulnerabilità note nelle dipendenzeSpesso, ma con giudizio: molte sono in strumenti che non girano in produzione
npx pacchettoScarica ed esegue un pacchetto al voloCon prudenza: esegue codice di altri sul tuo computer
🔒 Il lockfile va nel repositorySenza, due installazioni a un'ora di distanza possono prendere versioni diverse delle stesse dipendenze. Con il lockfile e npm ci, quello che hai provato è quello che va in produzione.
12 / 15

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.

Node in produzione
Internetnginx :443certificato, compressionenode 127.0.0.1:3000la tua appsystemdla avvia e la riavviajournaldi logNode non è mai esposto direttamente: ascolta solo in locale
javascript · server.mjs, il minimo
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}`));
/etc/systemd/system/miaapp.service
[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
nginx · davanti a Node
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.

13 / 15

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.

Chi c'è nel tuo node_modules
La tua appdipendenzadipendenzadipendenzaun pacchetto piccolo,una persona sola, stanca3 pacchetti scelti da te,decine arrivati con loro
2016

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.

2018

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.

2025

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 ci ovunque
  • Aggiornare con calma, non nel giorno in cui esce una versione: molti attacchi vengono scoperti nei primi giorni
  • npm ci --ignore-scripts quando 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 install come root sul server di produzione
  • Build e chiavi di produzione sulla stessa macchina dove scarichi pacchetti a caso
  • Copiare il comando npx trovato 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.

14 / 15

Errori tradotti

Quello che dice il messaggio, e quello che vuole dire davvero.

MessaggioVuol direCosa 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 sbagliatoconsole.log(x) subito prima, e guarda cosa contiene davvero
Cannot read properties of undefinedUn pezzo della catena manca: a.b.c con b vuotoa.b?.c se può mancare, altrimenti trova perché manca
Nella console del browser: blocked by CORS policyLa pagina chiede dati a un altro dominio, e quel server non dice che può farloSi sistema sul server, con l'intestazione Access-Control-Allow-Origin, non nel JavaScript
Cannot use import statement outside a moduleUsi 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
EADDRINUSELa porta è già occupata, spesso da una copia vecchia della tua appsudo ss -tlpn | grep 3000 e ferma quello che c'è
EACCES su una porta sotto la 1024Le porte basse sono per rootAscolta su 3000 e metti nginx davanti
Unhandled promise rejectionUna promessa è fallita e nessuno ha gestito l'erroreUn try/catch intorno all'await, o un .catch()
npm ERR! ERESOLVEDue dipendenze vogliono versioni incompatibili di una terzaLeggi chi vuole cosa; --legacy-peer-deps è un cerotto, non una cura
15 / 15

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.

CosaDove
Il riferimentoMDN Web Docs, di Mozilla: la documentazione migliore del web, anche in italiano in parte
NodeLa documentazione ufficiale su nodejs.org, e il calendario delle versioni
Provare al voloLa console del browser, F12, o node senza argomenti nel terminale

🧘 I cinque comandamenti

  • Sempre ===, mai ==
  • const di default, let se serve, var mai
  • Ogni async va aspettato, ogni fetch ha un timeout
  • Lockfile nel repository, npm ci sui server
  • Node in locale dietro nginx, acceso da systemd

📖 Da leggere dopo

🧭 La risposta per il collega"JavaScript è nato in dieci giorni e ha le sue stranezze: usa sempre il triplo uguale e aspetta ogni cosa asincrona. Sui server Node va installato da NodeSource, fatto partire da systemd in locale e messo dietro nginx. E il vero pericolo non è il linguaggio: è quello che scarichi con npm."