Tabella ASCII
Riferimento completo di tutti i 128 caratteri ASCII con codici decimale, esadecimale, ottale e binario.
128 caratteri visualizzati
Informazioni sull'ASCII
L'ASCII (American Standard Code for Information Interchange) è uno standard di codifica caratteri a 7 bit che definisce 128 caratteri. Pubblicato per la prima volta nel 1963, è alla base della maggior parte delle codifiche moderne, incluso UTF-8.
Intervalli di caratteri
- 0–31 · Caratteri di controllo (non stampabili)
- 32 · Spazio
- 33–47 · Punteggiatura e simboli
- 48–57 · Cifre 0–9
- 65–90 · Maiuscole A–Z
- 97–122 · Minuscole a–z
- 127 · DEL (cancella)
Qual è la differenza tra ASCII e Unicode?
L'ASCII definisce 128 caratteri su 7 bit. L'Unicode è un sovrainsieme che copre oltre 149.000 caratteri di tutti i sistemi di scrittura. I primi 128 code point Unicode sono identici all'ASCII.
Come uso questi codici nella programmazione?
In JavaScript: String.fromCharCode(65) → «A». In Python: chr(65). In C: (char)65. I valori esadecimali funzionano con le sequenze di escape: \x41 = «A».
Come funziona
- Sfoglia la tabella completa: tutti i 128 caratteri ASCII compaiono in una griglia ordinata per code point (da 0 a 127). Ogni cella mostra il carattere visibile (o la sua abbreviazione per i codici di controllo), il codice decimale e gli equivalenti esa / ottale / binario.
- Filtra per categoria: usa il menu a discesa per restringere ai caratteri di controllo (0-31), ai caratteri stampabili (32-126), alle lettere, alle cifre o ai simboli. Utile quando ti interessa solo, ad esempio, il blocco della punteggiatura.
- Cerca: la casella di ricerca trova per nome del carattere («LF»), abbreviazione o valore numerico (decimale o esadecimale). Digitando
0x41,65oAsi salta tutti alla stessa cella. - Clicca una cella per copiare una qualsiasi delle sue rappresentazioni negli appunti. Comodo quando ti serve
\x1Bper un escape ANSI,0x0Aper un a capo Unix, o il decimale32per uno spazio.
Una breve storia dell'ASCII
L'ASCII (American Standard Code for Information Interchange) fu proposto dall'ingegnere IBM Bob Bemer al sottocomitato X3.2 dell'American Standards Association nel maggio 1961, con l'obiettivo di sostituire la dozzina di codici di caratteri incompatibili allora in uso. La prima edizione pubblicata fu ASA X3.4-1963; le lettere minuscole non arrivarono fino alla revisione del 1967. Lo standard è stato riconfermato più volte da allora con il nome ANSI X3.4-1986, e costituisce la base di ogni codifica di caratteri moderna attraverso il suo gemello internazionale, ISO/IEC 646 (e l'europeo ECMA-6).
Per l'uso in rete, l'ASCII fu codificato dalla RFC 20, «ASCII format for Network Interchange,» pubblicata il 16 ottobre 1969 e scritta da Vint Cerf alla UCLA. La raccomandazione della RFC («ASCII a 7 bit incorporato in un byte a 8 bit il cui bit più significativo è sempre 0») è ancora il modo in cui ogni linguaggio di programmazione e protocollo moderno concepisce il testo semplice. Il governo federale degli Stati Uniti, per ordine esecutivo del presidente Lyndon B. Johnson nel 1968, impose il supporto dell'ASCII su tutti i computer federali a partire dal 1 luglio 1969, il che garantì l'adozione in tutto il settore.
Perché sette bit?
Il comitato X3.2 era stretto tra due opzioni poco allettanti. Un codice a 6 bit (usato da alfabeti telegrafici più vecchi come l'ITA2) era inaffidabile: un singolo bit invertito su una linea disturbata poteva decodificare male ogni carattere successivo se capitava su un bit di shift. Un codice a 8 bit sembrava uno spreco in un'epoca di memoria costosa e modem lenti. Il compromesso fu 7 bit = 128 code point, lasciando libero l'ottavo bit per la parità. Impostare il bit di parità in modo che ogni byte avesse un numero totale di bit a 1 pari (o dispari) intercettava il 100% degli errori di trasmissione a singolo bit, esattamente il problema che producevano gli accoppiatori acustici e i cavi seriali degli anni '60.
Man mano che i tassi di errore calavano e i modem diventavano più veloci, l'ottavo bit fu riutilizzato. Varie code page nazionali «ASCII esteso» (Latin-1, Windows-1252, Mac Roman, KOI8-R, …) usavano i codici 128-255 per le lettere accentate e i caratteri di disegno di riquadri, ma quelle mappature erano reciprocamente incompatibili e furono alla fine soppiantate da Unicode e UTF-8.
La disposizione: 128 code point
7 bit = 27 = 128 codici distinti, organizzati come 33 caratteri di controllo (0-31 più DEL a 127) e 95 caratteri stampabili (32-126):
| Intervallo | Hex | Contenuto |
|---|---|---|
| 0-31 | 00-1F | Caratteri di controllo (NUL, BEL, BS, HT, LF, CR, ESC, FS-US, …) |
| 32 | 20 | SPACE, stampabile ma invisibile |
| 33-47 | 21-2F | Punteggiatura: ! " # $ % & ' ( ) * + , - . / |
| 48-57 | 30-39 | Cifre 0-9 |
| 58-64 | 3A-40 | Altra punteggiatura: : ; < = > ? @ |
| 65-90 | 41-5A | Maiuscole A-Z |
| 91-96 | 5B-60 | Parentesi e accenti: [ \ ] ^ _ ` |
| 97-122 | 61-7A | Minuscole a-z |
| 123-126 | 7B-7E | Parentesi graffe e tilde: { | } ~ |
| 127 | 7F | DEL, «rub out» su nastro di carta perforato (binario 1111111) |
Caratteri di controllo che contano ancora
La maggior parte dei 33 caratteri di controllo nacque come comandi per telescriventi e nastro di carta ed è ora una curiosità storica. Una manciata è ancora portante nell'informatica di tutti i giorni:
- NUL (0x00): termina le stringhe in C e in qualsiasi linguaggio derivato dal C. Incollare un null incorporato in un percorso di file è un modo classico per mandare in crash il vecchio codice.
- BEL (0x07,
\a): il bip del terminale. Ancora attivato daprintf '\a'. - BS (0x08,
\b): backspace. Usato dalle librerie per barre di avanzamento per sovrascrivere la riga precedente. - HT (0x09,
\t): tabulazione orizzontale. Definisce il carattere di tabulazione usato nei file TSV e nell'eterno dibattito sull'indentazione dell'interprete Python. - LF (0x0A,
\n): avanzamento riga. L'a capo di Unix. - CR (0x0D,
\r): ritorno a capo. Metà dell'a capo di Windows; usato da solo per «tornare all'inizio della riga» nelle barre di avanzamento. - ESC (0x1B,
\e/\x1B): il carattere di escape. L'invenzione originale di Bemer, ora il prefisso di ogni sequenza di escape dei terminali ANSI (colori, movimento del cursore, pulizia dello schermo). - FS / GS / RS / US (0x1C-0x1F): separatori di File / Group / Record / Unit. Progettati per l'archiviazione su nastro orientata ai record negli anni '60 e in gran parte dimenticati, finché la RFC 7464 «JSON Text Sequences» non ha riportato RS come delimitatore di prefisso per i record JSON in streaming (
application/json-seq). GS compare ancora in alcuni protocolli di codici a barre per la vendita al dettaglio. - DEL (0x7F): «rub out.» Il tasto RUB OUT della Teletype Model 33 inviava il codice 127 perché in binario è
1111111: tutti e sette i bit impostati. Per cancellare un carattere sul nastro di carta, l'operatore arretrava il nastro e premeva RUB OUT, perforando ogni foro esistente. Il ricevitore doveva ignorare qualsiasi byte composto da soli 1.
Le guerre dei fine riga
Tre piattaforme scelsero tre convenzioni diverse, e da allora il software ne paga le conseguenze. L'origine meccanica è la macchina da scrivere e la telescrivente, dove servivano due azioni separate: il ritorno a capo riportava la testina di stampa alla colonna 1, e l'avanzamento riga faceva avanzare la carta di una riga. Sistemi diversi presero decisioni diverse sul codificarlo come uno o due byte:
| OS | A capo | Byte | Escape |
|---|---|---|---|
| Unix / Linux / macOS moderno | LF | 0x0A | \n |
| Mac OS classico (pre-OS X) | CR | 0x0D | \r |
| Windows / DOS | CRLF | 0x0D 0x0A | \r\n |
I protocolli Internet impongono perlopiù il CRLF: HTTP, SMTP, FTP, MIME e lo standard Internet Message Format lo specificano tutti. La RFC 5322 è inequivocabile: «CR e LF DEVONO comparire insieme solo come CRLF; NON DEVONO comparire indipendentemente» nel corpo del messaggio. All'interno del codice sorgente, però, la convenzione varia da team a team, motivo per cui git include core.autocrlf: con true su Windows, git estrae i file come CRLF nell'albero di lavoro ma li memorizza come LF nel repo, così lo stesso file sorgente produce lo stesso hash di blob su ogni piattaforma. Una voce .gitattributes come * text=auto è l'alternativa a livello di progetto.
Le sequenze di escape ANSI per il colore del terminale
Il carattere di escape (ESC, 0x1B) è il prefisso delle sequenze di escape ANSI che colorano l'output del terminale. Lo standard è ECMA-48 (1976), in seguito rispecchiato come ANSI X3.64 e incorporato in ISO/IEC 6429. La grammatica è ESC [ + parametri + una lettera finale; la parte ESC [ è chiamata Control Sequence Introducer (CSI) e viene scritta in vari modi come \e[, \x1b[ o \033[ a seconda del linguaggio. Codici Select Graphic Rendition comuni:
0: reset / normale ·1: grassetto ·4: sottolineato ·7: video inverso30-37: colore di primo piano (nero, rosso, verde, giallo, blu, magenta, ciano, bianco)40-47: colore di sfondo (stesso ordine)90-97/100-107: primo piano / sfondo brillante
Quindi printf '\033[1;31mERROR\033[0m' stampa «ERROR» in rosso grassetto e poi ripristina. Ogni emulatore di terminale moderno (e il Windows Terminal dal 2019) le supporta.
ASCII contro Unicode e UTF-8
L'ASCII definisce 128 code point; Unicode 16.0 (rilasciato nel 2024) ne copre più di 154.000. Il ponte cruciale è UTF-8, la codifica di testo dominante sul web (usata da circa il 98% dei siti web nel 2026): UTF-8 è progettato in modo che qualsiasi byte ASCII a 7 bit (0x00-0x7F) codifichi lo stesso carattere di sempre, con il bit alto a zero. La conseguenza pratica è che ogni file ASCII valido è anche un file UTF-8 valido, identico byte per byte. I code point superiori a 127 sono codificati come sequenze multibyte (da 2 a 4 byte) con il bit alto impostato su ogni byte, il che garantisce che i parser ASCII legacy non li confondano mai con caratteri ASCII.
L'ASCII nei comuni linguaggi di programmazione
| Linguaggio | Codice → carattere | Carattere → codice |
|---|---|---|
| JavaScript | String.fromCharCode(65) | 'A'.charCodeAt(0) |
| Python | chr(65) | ord('A') |
| C / C++ | (char)65 | (int)'A' |
| Java | (char) 65 | (int) 'A' |
| Rust | char::from(65) | 'A' as u32 |
| Go | string(rune(65)) | int('A') |
| Bash / sh | printf '\x41' | printf '%d' "'A" |
| HTML | A o A | - |
| Codifica URL | %41 = «A», %20 = spazio | - |
Il trucco del bit di maiuscola/minuscola
Una proprietà piccola ma elegante della disposizione ASCII: una lettera maiuscola e la sua controparte minuscola differiscono di esattamente un bit. A è 65 = 0100 0001; a è 97 = 0110 0001. Differisce solo il bit 5. Questo rende il confronto senza distinzione tra maiuscole e minuscole una singola operazione bit a bit: x | 0x20 forza il minuscolo, x & 0xDF forza il maiuscolo, entrambi più veloci di una tabella di lookup. Questa fu una scelta progettuale deliberata nella revisione del 1967 ed è uno dei motivi per cui la disposizione sembra «casuale» in alcuni punti: codifica proprietà adatte all'hardware, non solo l'ordine alfabetico.
Insidie comuni
- Confondere la cifra 0 con il carattere di controllo NUL. NUL è il codice 0; il carattere «0» è il codice 48. I due non sono intercambiabili in nessun linguaggio di programmazione.
- Presumere che un byte sia un carattere. Vero solo per il testo ASCII. Il testo UTF-8 ha caratteri a larghezza variabile, quindi la lunghezza in byte e il conteggio dei caratteri possono differire enormemente per le scritture non latine.
- Mischiare i fine riga in un solo file. CR / LF / CRLF mischiati nello stesso file confondono molti parser e producono righe vuote fantasma o a capo mancanti a seconda del sistema operativo che lo apre.
- Errore di sfasamento di uno nella terminazione delle stringhe in C. Dimenticare che le stringhe hanno bisogno di un byte in più per il NUL finale è la vulnerabilità di buffer overflow originale.
- Si presume che l'«ASCII esteso» sia portabile. I codici 128-255 significano caratteri diversi sotto Latin-1, Windows-1252, KOI8-R, Mac Roman, ecc. UTF-8 è l'unica scelta moderna sicura.
- ESC incorporato in input non attendibile. Se registri dati forniti dall'utente su un terminale senza sanificarli, un attaccante può iniettare sequenze di escape ANSI che cambiano colore, spostano il cursore o puliscono lo schermo, a volte nascondendo contenuto malevolo.
Domande frequenti
Perché DEL ha il codice 127 invece di 0?
Perché 127 in binario è 1111111: tutti e sette i bit impostati. Per cancellare un carattere sul nastro di carta perforato, l'operatore arretrava il nastro e premeva RUB OUT, che perforava ogni foro esistente. Il ricevitore doveva ignorare qualsiasi byte composto da soli 1, così il carattere «cancellato» diventava invisibile alle letture successive. La convenzione fu ereditata dai precedenti codici delle telescriventi.
Cos'è l'«ASCII esteso» ed è sicuro usarlo?
L'ASCII standard copre i code point 0-127 (7 bit). «ASCII esteso» si riferisce in modo approssimativo alle codifiche a 8 bit che riempiono i code point 128-255 con caratteri aggiuntivi: Latin-1, Windows-1252, KOI8-R, Mac Roman e molti altri. Il problema: i caratteri extra significano cose diverse in ogni codifica. Il nome è tecnicamente improprio (quelle code page non sono estensioni dello standard ASCII), e non sono sicure tra sistemi diversi. UTF-8 è il sostituto moderno e portabile ed è retrocompatibile con l'intervallo originale 0-127.
Perché lo spazio (32) è considerato «stampabile» se non mostra nulla?
Perché occupa spazio orizzontale su una riga stampata: fa avanzare la testina di stampa esattamente come fa una lettera. I caratteri di controllo, al contrario, cambiano lo stato del dispositivo senza produrre output visibile (BEL emette un bip, BS sposta la testina all'indietro, LF fa avanzare la carta). La classificazione si basa su ciò che il carattere fa su una stampante, non sul fatto che abbia un glifo.
CR e LF sono la stessa cosa di Invio sulla mia tastiera?
Perlopiù sì, ma il byte che la tua tastiera genera dipende dal sistema operativo. Su Windows, premere Invio di solito produce CRLF (0x0D 0x0A); su Linux e macOS moderno, solo LF (0x0A); sul Mac OS classico pre-X, solo CR (0x0D). Molti editor lo normalizzano al salvataggio in base ai fine riga esistenti del file o alla convenzione di progetto configurata.
Perché i separatori di file/gruppo/record/unità sono qui?
Furono progettati per l'archiviazione su nastro orientata ai record negli anni '60: File > Group > Record > Unit. In gran parte caddero in disuso, ma sono tornati in due posti sorprendenti: la RFC 7464 «JSON Text Sequences» (tipo di media application/json-seq) usa RS (0x1E) come prefisso per delimitare i record JSON in streaming, e il separatore GS1 Application Identifier nei protocolli di codici a barre per la vendita al dettaglio usa GS (0x1D).
L'ASCII è ancora rilevante nel 2026?
Moltissimo. Ogni protocollo moderno che è «basato su testo» (header HTTP, JSON, YAML, codice sorgente, argomenti da riga di comando, variabili d'ambiente, hostname DNS) opera all'interno dell'intervallo ASCII. UTF-8 è la codifica dominante per il testo arbitrario, ma i primi 128 valori di byte di UTF-8 sono esattamente ASCII, byte per byte. Conoscere la tabella è ancora necessario per qualsiasi cosa, dalla codifica URL al colore del terminale al debug dei bug di codifica del testo.