Provided by: manpages-it_4.23.1-1_all 
NOME
UTF-8 - una codifica Unicode multi-byte compatibile con ASCII
DESCRIZIONE
L'insieme di caratteri Unicode 3.0 occupa uno spazio a 16 bit. La codifica più naturale di Unicode (nota
come UCS-2) consta di sequenze di parole a 16 bit. Queste stringhe possono contenere—come parte di molti
caratteri a 16 bit—byte come '\0' o '/', che hanno significato speciale per i nomi di file e per i
parametri di altre funzioni della libreria C. Inoltre, la maggioranza degli strumenti UNIX si aspetta
file in ASCII e non sa leggere parole a 16 bit come caratteri senza grosse modifiche. Per queste ragioni
UCS-2 non è una codifica esterna di Unicode adatta a nomi di file, file di testo, variabili d'ambiente, e
così via. L'Insieme universale di caratteri ISO 10646 (UCS), un'estensione di Unicode, occupa uno spazio
ancora maggiore—a 31 bit—e la sua codifica naturale, UCS-4 (una sequenza di parole a 32 bit), soffre
degli stessi problemi.
La codifica UTF-8 di Unicode e UCS evita questi problemi, ed è il modo comune con cui Unicode è usato nei
sistemi operativi tipo UNIX.
Proprietà
La codifica UTF-8 possiede queste ottime proprietà:
• I caratteri UCS da 0x00000000 a 0x0000007f (i caratteri US-ASCII classici) sono codificati
semplicemente come byte da 0x00 a 0x7f (compatibilità ASCII). In altre parole, file e stringhe
contenenti solamente caratteri ASCII a 7 bit hanno la stessa codifica sia in ASCII che in UTF-8.
• Tutti i caratteri UCS maggiori di 0x7f sono codificati come una sequenza di più byte consistente
esclusivamente di byte nell'intervallo da 0x80 a 0xfd, in modo tale da non trovare nessun byte ASCII
all'interno di un altro carattere, e da non avere problemi con, tra gli altri, [aq]\0' o '/'.
• L'ordinamento lessicografico delle stringhe in UCS-4 viene preservato.
• Tutti i 2^31 possibili codici UCS possono essere codificati con UTF-8.
• I byte 0xc0, 0xc1, 0xfe E 0xff non sono mai usati nella codifica UTF-8.
• Il primo byte di una sequenza multibyte che rappresenta un carattere UCS non ASCII è sempre
nell'intervallo da 0xc0 a 0xfd e indica la lunghezza della sequenza. Tutti i byte seguenti nella
sequenza multibyte sono nell'intervallo da 0x80 a 0xbf, facilitando un'eventuale risincronizzazione e
facendo diventare la codifica senza memoria e resistente a byte mancanti.
• I caratteri UCS codificati con UTF-8 possono arrivare ai sei byte di lunghezza, tuttavia lo standard
Unicode non specifica caratteri oltre 0x10ffff, così i caratteri Unicode possono essere lunghi solo
fino a quattro byte in UTF-8.
Codifica
Le seguenti sequenze di byte vengono usate per rappresentare un carattere. La sequenza da usare dipende
dal numero del codice UCS del carattere:
0x00000000 - 0x0000007F:
0xxxxxxx
0x00000080 - 0x000007FF:
110xxxxx 10xxxxxx
0x00000800 - 0x0000FFFF:
1110xxxx 10xxxxxx 10xxxxxx
0x00010000 - 0x001FFFFF:
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
0x00200000 - 0x03FFFFFF:
111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
0x04000000 - 0x7FFFFFFF:
1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
Le configurazioni di bit xxx sono riempite coi bit del numero del codice carattere rappresentato in
binario, prima il bit più significativo (big-endian). Viene usata solo la più breve delle sequenze
multibyte che possono rappresentare il numero del codice.
I valori del codice UCS 0xd800–0xdfff (surrogati UTF-16), così come 0xfffe e 0xffff (non-caratteri UCS)
non devono apparire nei flussi UTF-8 conformi. Secondo RFC 3629 nessun punto oltre U+10FFFF dovrebbe
essere usato, che limita i caratteri a quattro byte.
Esempio
Il carattere Unicode 0xa9 = 1010 1001 (il simbolo di copyright) si codifica in UTF-8 come
11000010 10101001 = 0xc2 0xa9
e il carattere 0x2260 = 0010 0010 0110 0000 (il simbolo "non uguale") si codifica come:
11100010 10001001 10100000 = 0xe2 0x89 0xa0
Note sull'applicazione
Gli utenti devono selezionare una localizzazione UTF-8, ad esempio con
export LANG=en_GB.UTF-8
per poter attivare il supporto UTF-8 nelle applicazioni.
I software applicativi che devono riconoscere la codifica caratteri usata devono sempre impostare la
localizzazione come
setlocale(LC_CTYPE, "")
e i programmatori possono quindi testare l'espressione
strcmp(nl_langinfo(CODESET), "UTF-8") == 0
per determinare se una localizzazione UTF-8 è stata selezionata e se quindi tutti gli input e output
standard in testo, comunicazioni terminale, contenuto in testo dei file, nomi file e variabili d'ambiente
sono codificati in UTF-8.
I programmatori abituati alle codifiche a singolo byte come US-ASCII o ISO/IEC 8859 devono ricordare che
due assunzioni valide qui non sono più valide nelle localizzazioni UTF-8. Innanzitutto un singolo byte
non corrisponde più necessariamente ad un singolo carattere. In secondo luogo, poiché i moderni emulatori
di terminale in modalità UTF-8 supportano anche caratteri a doppia larghezza cinese, giapponese e coreano
e i caratteri combinanti, non spaziati, l'emissione di un singolo carattere non avanza necessariamente il
cursore di una posizione come avveniva in ASCII. Funzioni di libreria come mbsrtowcs(3) e wcswidth(3)
oggi devono essere usate per contare caratteri e posizionare il cursore.
La sequenza ufficiale ESC per commutare da uno schema di codifica ISO/IEC 2022 (usato ad esempio dai
terminali VT100) a UTF-8 è ESC % G ("\x1b%G"). La corrispondente sequenza di ritorno da UTF-8 a ISO/IEC
2022 è ESC % @ ("\x1b%@"). Altre sequenze ISO/IEC 2022 (come quelle per commutare gli insiemi G0 e G1)
non sono applicabili in modalità UTF-8.
Sicurezza
Gli standard Unicode e UCS richiedono che i produttori di UTF-8 debbano usare la forma più breve
possibile, ad esempio produrre una sequenza a due byte con primo byte 0xc0 non è conforme. Unicode 3.1 ha
aggiunto la richiesta che i programmi conformi non debbano accettare le forme non brevi nel loro input.
Ciò è per ragioni di sicurezza: se l'input utente è verificato per possibili violazioni di sicurezza, un
programma può verificare solo la versione ASCII di "/../" o ";" o NUL e dimenticare che ci sono molti
modi non- ASCII di rappresentare queste cose in una codifica UTF-8 non breve.
Standard
ISO/IEC 10646-1:2000, Unicode 3.1, RFC 3629, Plan 9.
VEDERE ANCHE
locale(1), nl_langinfo(3), setlocale(3), charsets(7), unicode(7)
TRADUZIONE
La traduzione italiana di questa pagina di manuale è stata creata da Ottavio G. Rizzo
<rizzo@pluto.linux.it>, Giulio Daprelà <giulio@pluto.it>, Elisabetta Galli <lab@kkk.it>, Marco Curreli
<marcocurreli@tiscali.it> e Giuseppe Sacco <eppesuig@debian.org>
Questa traduzione è documentazione libera; leggere la GNU General Public License Versione 3
⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o successiva per le condizioni di copyright. Non ci
assumiamo alcuna responsabilità.
Per segnalare errori nella traduzione di questa pagina di manuale inviare un messaggio a ⟨pluto-
ildp@lists.pluto.it⟩.