NOME

       UTF-8 - una codifica Unicode multi-byte compatibile con ASCII

DESCRIZIONE

       The  Unicode  3.0  character  set  occupies a 16-bit code space.  The most obvious Unicode
       encoding (known as UCS-2)  consists of a sequence  of  16-bit  words.   Such  strings  can
       contain—as  part of many 16-bit characters—bytes such as '\0' or '/', which have a special
       meaning in filenames and other C library function arguments.  In addition, the majority of
       UNIX  tools  expect  ASCII  files  and can't read 16-bit words as characters without major
       modifications.  For these reasons, UCS-2 is not a suitable external encoding of Unicode in
       filenames,  text  files,  environment  variables,  and  so  on.   The  ISO 10646 Universal
       Character Set (UCS), a superset of Unicode, occupies an even larger code space—31 bits—and
       the obvious UCS-4 encoding for it (a sequence of 32-bit words) has the same problems.

       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.

       * All UCS characters greater than 0x7f are encoded as a multibyte sequence consisting only
         of bytes in the range 0x80 to 0xfd, so no ASCII byte  can  appear  as  part  of  another
         character and there are no problems with, for example, '\0' or '/'.

       * L'ordinamento lessicografico delle stringhe in UCS-4 viene preservato.

       * All possible 2^31 UCS codes can be encoded using 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.

       The UCS code values 0xd800–0xdfff (UTF-16 surrogates) as well as 0xfffe  and  0xffff  (UCS
       noncharacters)  should  not  appear in conforming UTF-8 streams.  According to RFC 3629 no
       point above U+10FFFF should be used, which limits characters to four bytes.

   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)

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>  e
       Marco Curreli <marcocurreli@tiscali.it>

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