Cos'è l'HTML Escaping?
L'HTML escaping è il processo di sostituzione dei caratteri con un significato speciale in HTML con i corrispondenti riferimenti di entità. I cinque caratteri che devono essere escapati sono: la e commerciale (&), il simbolo minore-di (<), il simbolo maggiore-di (>), le virgolette doppie (") e le virgolette singole ('). Senza l'escaping, il browser interpreta questi caratteri come istruzioni di markup anziché come testo visualizzabile, causando errori di rendering e aprendo la porta a injection attack.
La specifica HTML (mantenuta da WHATWG) definisce due forme di riferimenti a caratteri: entità con nome come & ed entità numeriche come & o &. Le entità con nome sono più facili da leggere nel codice sorgente. Le entità numeriche (decimali o esadecimali) possono rappresentare qualsiasi code point Unicode, rendendole utili per caratteri privi di un alias con nome. Entrambe le forme producono un output identico nel browser.
L'unescape (detto anche decoding) è l'operazione inversa: converte i riferimenti di entità nei rispettivi caratteri letterali. È comune quando si estrae testo da sorgenti HTML, si migra contenuto tra sistemi o si effettua il debug di template che codificano le entità più volte. Questo strumento gestisce entrambe le direzioni nel browser, così puoi verificare la tua logica di escaping o recuperare testo normale da una sorgente HTML-heavy in pochi secondi.
Perché usare uno strumento di HTML Escape?
Sostituire manualmente parentesi angolari e e commerciali in grandi blocchi di testo è tedioso e soggetto a errori. Uno strumento dedicato converte il tuo input in un solo passaggio, senza installare nulla.
⚡
Conversione istantanea
Incolla testo o HTML e ottieni subito l'output escapato o unescapato. Nessuna attesa per un round-trip al server, perché tutta l'elaborazione avviene localmente in JavaScript.
🔒
Elaborazione privacy-first
Il tuo input non lascia mai il browser. Nulla viene inviato a un server né memorizzato, quindi puoi escapare in sicurezza markup contenente credenziali, chiavi API o codice interno.
📋
Nessun account o configurazione
Apri la pagina e inizia a incollare. Non c'è nessun login, nessuna verifica e-mail e nessun software da installare. Funziona su qualsiasi dispositivo con un browser moderno.
🌐
Copertura completa delle entità
Gestisce i cinque caratteri speciali HTML obbligatori più le entità numeriche (decimali ed esadecimali). Supporta la conversione bidirezionale: escape seguito da unescape restituisce la stringa originale.
Casi d'uso dell'HTML Escape
Frontend developer: visualizzare input utente
Quando si visualizza testo inviato dagli utenti all'interno di una pagina, è necessario escaparlo prima per impedire al browser di interpretarlo come tag HTML. Questa è la difesa principale contro gli attacchi XSS stored in qualsiasi template che emette stringhe grezze.
Backend engineer: generare risposte HTML
Il codice lato server che concatena stringhe in HTML deve escapare i valori dinamici prima dell'inserimento. Usa questo strumento per verificare che la tua funzione di escaping produca l'output corretto per i casi limite, come le virgolette annidate.
DevOps: incorporare configurazioni in HTML
JSON inline o comandi shell all'interno di una pagina HTML (ad esempio in un tag script o in un attributo data) richiedono l'escaping. Verifica che le parentesi angolari e le e commerciali nei tuoi snippet di configurazione siano correttamente codificati.
QA engineer: testare vettori XSS
Incolla i payload XSS più comuni nello strumento per confermare che l'output della tua applicazione corrisponda alla versione correttamente escapata. Confronta l'output escapato carattere per carattere con quello prodotto dalla tua app.
Technical writer: esempi di codice nella documentazione
Pubblicare snippet di codice in documentazione basata su HTML (Jekyll, Hugo, CMS personalizzati) richiede l'escaping delle parentesi angolari per la sintassi dei tipi generici e i segnaposto dei template. Incolla il tuo campione di codice e ogni carattere speciale viene codificato istantaneamente.
Studente: imparare le entità HTML
Digita o incolla qualsiasi carattere e visualizza le forme di entità con nome e numerica corrispondenti. Sperimenta con i casi limite come gli spazi non divisibili, le lineette em e i simboli Unicode per capire come funziona la codifica dei caratteri in HTML.
Tabella di riferimento delle entità HTML
La tabella seguente elenca le entità HTML più comuni. I cinque caratteri speciali (& < > " ') devono sempre essere escapati nel contenuto HTML e nei valori degli attributi. Le altre entità sono opzionali ma utili per caratteri difficili da digitare o ambigui nel codice sorgente.
| Carattere | Descrizione | Entità con nome | Entità numerica |
|---|---|---|---|
| & | Ampersand | & | & |
| < | Less-than sign | < | < |
| > | Greater-than sign | > | > |
| " | Double quote | " | " |
| ' | Single quote / apostrophe | ' | ' |
| Non-breaking space | |   | |
| © | Copyright sign | © | © |
| ® | Registered sign | ® | ® |
| — | Em dash | — | — |
| ’ | Right single quote | ’ | ’ |
| € | Euro sign | € | € |
Escape vs. Unescape: quando usare ciascuno
Le due operazioni sono inverse. Scegliere la direzione sbagliata produce output doppiamente codificato o non protetto.
Escape (codifica)
Da usare quando si inserisce testo non attendibile o dinamico in HTML. Converte il carattere letterale < in < in modo che il browser mostri il carattere invece di aprire un tag. Applica l'escape prima di visualizzare input utente, log o qualsiasi stringa che potrebbe contenere markup.
Unescape (decodifica)
Da usare quando si estrae testo normale da una sorgente HTML. Converte < nel carattere <. Applica l'unescape quando si migra contenuto da un CMS, si analizza HTML estratto o si correggono stringhe doppiamente codificate come &amp; che mostrano nomi di entità invece dei caratteri.
Esempi di codice
Di seguito trovi esempi funzionanti di HTML escaping e unescaping in quattro linguaggi. Ogni snippet copre entrambe le direzioni e gestisce i casi limite come virgolette annidate ed entità numeriche.
JavaScript (browser / Node.js)
// Escape HTML entities manually
function escapeHtml(str) {
return str
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''')
}
escapeHtml('<img src="x" onerror="alert(1)">')
// → "<img src="x" onerror="alert(1)">"
// Unescape using DOMParser (browser only)
function unescapeHtml(str) {
const doc = new DOMParser().parseFromString(str, 'text/html')
return doc.documentElement.textContent
}
unescapeHtml('<div>Hello</div>')
// → "<div>Hello</div>"Python
import html
# Escape special characters
html.escape('<script>alert("XSS")</script>')
# → '<script>alert("XSS")</script>'
# Escape including single quotes (quote=True is default in Python 3.8+)
html.escape("It's <b>bold</b>", quote=True)
# → 'It's <b>bold</b>'
# Unescape entities back to characters
html.unescape('<p>Price: €10</p>')
# → '<p>Price: €10</p>'
# Unescape numeric entities
html.unescape('<div>&amp;</div>')
# → '<div>&</div>'Go
package main
import (
"fmt"
"html"
)
func main() {
// Escape HTML special characters
escaped := html.EscapeString(`<a href="page?id=1&sort=name">Link</a>`)
fmt.Println(escaped)
// → <a href="page?id=1&sort=name">Link</a>
// Unescape back to original
original := html.UnescapeString("<b>Go & HTML</b>")
fmt.Println(original)
// → <b>Go & HTML</b>
}PHP
<?php
// Escape HTML entities (ENT_QUOTES escapes both " and ')
echo htmlspecialchars('<p class="info">Tom & Jerry's</p>', ENT_QUOTES, 'UTF-8');
// → <p class="info">Tom & Jerry's</p>
// Convert all applicable characters to HTML entities
echo htmlentities('Price: 10€ — 50% off', ENT_QUOTES, 'UTF-8');
// → Price: 10€ — 50% off
// Decode entities back
echo html_entity_decode('<div>&copy; 2026</div>');
// → <div>© 2026</div>Domande frequenti
Qual è la differenza tra HTML escaping e URL encoding?
L'HTML escaping sostituisce i caratteri speciali in HTML (< > & " ') con riferimenti di entità come < in modo che vengano visualizzati come testo. L'URL encoding (percent-encoding) sostituisce i caratteri non sicuri negli URL con sequenze esadecimali %XX. Proteggono contesti diversi: l'HTML escaping previene l'injection di markup, mentre l'URL encoding garantisce query string e segmenti di percorso validi.
Quali caratteri devono essere escapati in HTML?
I cinque caratteri che devono sempre essere escapati sono: & (e commerciale), < (minore-di), > (maggiore-di), " (virgolette doppie negli attributi) e ' (virgolette singole negli attributi). Non escapare uno qualsiasi di questi può interrompere il rendering o creare una vulnerabilità di cross-site scripting.
' è valido in HTML5?
Sì. L'entità con nome ' è definita nella specifica HTML5 ed è supportata da tutti i browser moderni. Non faceva parte di HTML 4, che riconosceva solo &, <, > e ". Se devi supportare parser HTML 4 molto vecchi, usa la forma numerica '.
Come si correggono le entità HTML doppiamente codificate come &amp;?
La doppia codifica avviene quando una stringa già escapata passa nuovamente attraverso la funzione di escaping. La soluzione è applicare l'unescape finché l'output non si stabilizza. Incolla la stringa doppiamente codificata in questo strumento in modalità unescape, poi riesegui se rimangono riferimenti &. Per prevenire la doppia codifica, controlla se l'input è già escapato prima di applicare la funzione di escape.
Posso usare entità HTML all'interno di stringhe JavaScript?
Le entità HTML sono interpretate dal parser HTML, non dal motore JavaScript. All'interno di un blocco script, il codice viene eseguito dopo che il parser HTML ha elaborato la pagina, quindi < in un blocco script diventa < prima che JavaScript lo veda. Per gli handler di eventi inline (onclick, ecc.), il valore dell'attributo viene prima decodificato da HTML, poi eseguito come JavaScript. Nei file .js esterni, le entità non hanno un significato speciale e vengono trattate come testo letterale.
Qual è la differenza tra htmlspecialchars e htmlentities in PHP?
htmlspecialchars() esegue l'escape solo dei cinque caratteri speciali (& < > " ') che influenzano la struttura HTML. htmlentities() esegue l'escape di quei cinque più ogni carattere che ha un'entità HTML con nome, come il simbolo del copyright e le lettere accentate. Per scopi di sicurezza, htmlspecialchars() con ENT_QUOTES è sufficiente. htmlentities() è utile quando hai bisogno di output ASCII-safe per sistemi che non gestiscono UTF-8.
L'HTML escaping è sufficiente per prevenire gli XSS?
L'HTML escaping previene gli XSS nel caso più comune: inserimento di testo non attendibile nel contenuto degli elementi HTML o nei valori degli attributi. Non protegge altri contesti di injection. Inserire dati utente in un blocco script richiede l'escaping delle stringhe JavaScript. Inserirli in un attributo style richiede l'escaping CSS. Inserirli in un attributo URL (href, src) richiede la validazione dell'URL più la codifica. Una difesa completa contro gli XSS applica l'escaping specifico per il contesto a ogni punto di inserimento.