utf-8

UTF-8(7)                    Linux Programmer's Manual                   UTF-8(7)



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 a multibyte 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\0aq o aq/aq.

       * 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 codica caratteri usata
       devono sempre impostare la localizzazione con, ad esempio,

              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 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 posizioni di caratteri e cursore.

       La sequenza ufficiale ESC per commutare da uno schema di codifica ISO
       2022 (usato ad esempio dai terminali VT100) a UTF-8 è ESC % G ("\x1b%G").
       La corrispondente sequenza di ritorno da UTF-8 a ISO 2022 è ESC % @
       ("\x1b%@").  Altre sequenze ISO 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)

COLOPHON
       Questa pagina fa parte del rilascio 4.08 del progetto Linux man-pages.
       Una descrizione del progetto, le istruzioni per la segnalazione degli
       errori, e l'ultima versione di questa pagina si trovano su
       https://www.kernel.org/doc/man-pages/.

       La versione italiana fa parte del pacchetto man-pages-it v. 4.08, a cura
       di: ILDP "Italian Linux Documentation Project" http://www.pluto.it/ildp
       Per la traduzione in italiano si può fare riferimento a
       http://www.pluto.it/ildp/collaborare/
       Segnalare eventuali errori di traduzione a ildp@pluto.it



GNU                                2016-07-17                           UTF-8(7)