NOME

NOME

perlunicode - Supporto Unicode in Perl

DESCRIZIONE

Avvertenze Importanti

Un supporto completo Unicode richiede una gran quantità di lavoro. Sebbene Perl non implementi lo standard Unicode e i rapporti tecnici allegati da parte a parte, Perl fornisce comunque una gran quantità di funzionalità Unicode.

Strati di Input e Output
Perl sa che un filehandle usa la codifica Unicode interna (UTF-8, o UTF-EBCDIC su piattaforme EBCDIC) se il filehandle viene aperto con lo strato :utf8. Altre codifiche possono essere convertite alla codifica interna Perl in lettura (o viceversa in scrittura) usando lo strato :encoding(...). Leggete the open manpage.

Per indicare che il sorgente stesso dello script è in una particolare codifica, usate the encoding manpage.

Espressioni Regolari
Il compilatore delle espressioni regolari produce istruzioni polimorfiche. Ovvero, l'espressione si adatta ai dati e commuta automaticamente allo schema di caratteri Unicode quando viene usata su dati Unicode -- o viceversa usa lo schema tradizionale a byte quando viene usata su dati a byte.

use utf8 è ancora necessario per usare UTF-8/UTF-EBCDIC negli script
Per compatibilità, la direttiva use utf8 deve essere inclusa esplicitamente per attivare il riconoscimento di stringhe in UTF-8 nei sorgenti degli script (nelle costanti stringa e espressioni regolari, o nei nomi degli identificatori) sulle macchine ASCII, ovvero il riconoscimento di UTF-EBCDIC sulle macchine EBCDIC. < Questi sono i soli casi in cui è necessario un esplicito use utf8 >. Cfr. the utf8 manpage.

Potete anche usare la direttiva encoding per cambiare la codifica di default per i dati nei vostri script; cfr. the encoding manpage.

gli script marcati con BOM o codificati in UTF-16 sono riconosciuti automaticamente
Se uno script Perl comincia con il BOM Unicode (codificato in UTF-16LE, UTF16-BE, o UTF-8), oppure sembra essere codificato in UTF-16 (con i byte in qualunque ordine) senza BOM, perl interpreterà correttamente lo script in Unicode. (UTF-8 senza BOM non è efficacemente distinguibile da ISO 8859-1 o altre codifiche a 8 bit).

use encoding è necessario per interpretare correttamente le stringhe di byte non Latin-1
Per default, c'è una asimmetria fondamentale nel modello Unicode di Perl: la conversione implicita da stringhe di byte a stringhe di caratteri Unicode assume che la codifica di partenza sia ISO 8859-1 (Latin-1), ma le stringhe di caratteri Unicode vengono convertite in stringhe di byte usando UTF-8. Questo succede perché i primi 256 code point di Unicode concordano (quasi per caso) con Latin-1.

Se volete che le stringhe di byte siano interpretate come UTF-8, usate la direttiva encoding:

    use encoding 'utf8';

Cfr. Semantica a byte e a caratteri per ulteriori dettagli.

Semantica a byte e a caratteri

A partire dalla versione 5.6, la rappresentazione interna delle stringhe in Perl è basata su caratteri ``larghi'' (nel senso che possono occupare più di un byte).

Nel futuro, si potrà supporre che le operazioni a livello di Perl lavorino su caratteri anziché byte.

Comunque, come misura di compatiblità temporanea, Perl cerca di fornire un percorso sicuro di migrazione per i vostri programmi da semantica a byte a semantica a caratteri. Nel caso di operazioni per le quali Perl può decidere senza ambiguità che i dati in ingresso sono caratteri, viene usata la semantica a caratteri. Nel caso di operazioni per le quali questa decisione non può essere effettuata senza ulteriori informazioni da parte dell'utente, Perl decide per la compatibilità e sceglie la semantica a byte.

Questo comportamento mantiene la compatiblità con versioni precedenti del Perl, che usavano la semantica a byte solo nel caso in cui nessuno degli input del programma erano indicati come sorgenti di caratteri Unicode. Questi dati possono provenire da filehandle, da chiamate a programmi esterni, da informazioni fornite dal sistema (ad esempio %ENV), o da costanti nel sorgente.

La direttiva bytes forzerà sempre, indipendentemente dalla piattaforma, la semantica a byte in un particolare scope lessicale. Cfr. the bytes manpage.

La direttiva utf8 è principalmente un sistema di compatibilità che attiva il riconoscimenti di costanti UTF-(8|EBCDIC) da parte del parser. Notate che questa direttiva è necessaria solo finché Perl assume una semantica a byte; quando la semantica a caratteri diventerà quella predefinita, questa direttiva potrà non avere più effetto. Cfr. the utf8 manpage.

Tranne dove viene detto esplicitamente, gli operatori Perl usano la semantica a carattere per i dati Unicode e la semantica a byte per i dati non Unicode. La decisione di usare la semantica a carattere è fatta in modo trasparente. Se i dati provengono da una sorgente Unicode -- ad esempio, da un filehandle cui è stato applicato uno strato di codifica, o da una costante Unicode nel sorgente -- si applica la semantica a carattere. Altrimenti, si applica la semantica a byte. La direttiva bytes è usata per forzare la semantica a byte sui dati Unicode.

Se si concatenano stringe con semantica a byte e stringhe Unicode, la nuova stringa verrà creata decodificando la stringa di byte usando ISO 8859-1 (Latin-1), anche se le stringhe Unicode usavano EBCDIC. Questa trasformazione avviene senza considerare quale sia la codifica nativa a 8 bit del sistema; per cambiare questo comportamento in sistemi la cui codifica nativa non è né Latin-1 né EBCDIC usate la direttiva encoding. Cfr. the encoding manpage.

Secondo la semantica a carattere, molte operazioni che prima lavoravano sui byte ora lavorano sui caratteri. Un carattere in Perl è, a livello logico, un numero tra 0 e circa 2**31. I caratteri con valore più alto potrebbero essere codificati internamente con sequenze di byte più lunghe, ma questi dettagli sono quasi del tutto nascosti al codice Perl. Leggete the perluniintro manpage per ulteriori informazioni.

Effetti della semantica a carattere

La semantica a carattere ha gli effetti seguenti:

Script

I nomi degli script che possono essere usati con \p{...} e \P{...}, come ad esempio \p{Latin} o \p{Cyrillic}, sono i seguenti:

    Arabic
    Armenian
    Bengali
    Bopomofo
    Buhid
    CanadianAboriginal
    Cherokee
    Cyrillic
    Deseret
    Devanagari
    Ethiopic
    Georgian
    Gothic
    Greek
    Gujarati
    Gurmukhi
    Han
    Hangul
    Hanunoo
    Hebrew
    Hiragana
    Inherited
    Kannada
    Katakana
    Khmer
    Lao
    Latin
    Malayalam
    Mongolian
    Myanmar
    Ogham
    OldItalic
    Oriya
    Runic
    Sinhala
    Syriac
    Tagalog
    Tagbanwa
    Tamil
    Telugu
    Thaana
    Thai
    Tibetan
    Yi

Classi di proprietà estese possono aggiungersi a quelle base, definite nel database Unicode PropList (con spiegazione in italiano, NdT):

    ASCIIHexDigit                   cifra esadecimale ASCII
    BidiControl                     controllo bidirezionalita`
    Dash                            trattino
    Deprecated                      deprecato
    Diacritic                       diacritico (accenti etc.)
    Extender                        estensore
    GraphemeLink                    collegamento tra grafemi
    HexDigit                        cifra esadecimale
    Hyphen                          trattino di sillabazione
    Ideographic                     ideografico
    IDSBinaryOperator               operatore binario IDS
    IDSTrinaryOperator              operatore ternario IDS
    JoinControl                     controllo di legatura
    LogicalOrderException           eccezione di ordine logico
    NoncharacterCodePoint           code point non carattere
    OtherAlphabetic                 altri alfabetici
    OtherDefaultIgnorableCodePoint  altro code point normalmente
                                    ignorabile
    OtherGraphemeExtend             altra estensione di grafema
    OtherLowercase                  altra minuscola
    OtherMath                       altro carattere matematico
    OtherUppercase                  altra maiuscola
    QuotationMark                   virgoletta
    Radical                         radicale
    SoftDotted                      con puntino eliminabile
    TerminalPunctuation             punteggiatura terminale
    UnifiedIdeograph                ideogramma unificato
    WhiteSpace                      spazio

e ci sono ancora proprietà derivate:

    Alphabetic      Lu + Ll + Lt + Lm + Lo + OtherAlphabetic
    Lowercase       Ll + OtherLowercase
    Uppercase       Lu + OtherUppercase
    Math            Sm + OtherMath
    ID_Start        Lu + Ll + Lt + Lm + Lo + Nl
    ID_Continue     ID_Start + Mn + Mc + Nd + Pc
    Any             Ogni carattere
    Assigned        Ogni carattere non in Cn (sinonimo di \P{Cn})
    Unassigned      Sinonimo di \p{Cn}
    Common          Ogni carattere (o code point non assegnato)
                    non esplicitamente assegnato a uno script

Per compatibilità con Perl 5.6, tutte le proprietà menzionate finora possono essere indicate anche preponendo Is al loro nome, per cui as esempio \P{IsLu} è uguale a \P{Lu}.

Blocchi

Oltre agli script, Unicode definisce anche dei blocchi di caratteri. La differenza tra script e blocchi è che il concetto di script è più vicino ai linguaggi naturali, mentre il concetto di blocco è più un raggruppamento artificioso basato su gruppi di 256 caratteri. Ad esempio, lo script Latin contiene lettere da svariati blocchi, ma non contiene ciascun carattere da tutti quei blocchi. Ad esempio, non contiene le cifre, essendo queste condivise tra molti script. Cifre e altri caratteri condivisi, come ad esempio la punteggiatura, appartengono alla categoria chiamata Common.

Per maggiori informazioni sugli script, leggete UTR #24:

   http://www.unicode.org/unicode/reports/tr24/

Per maggiori informazioni sui blocchi, leggete:

   http://www.unicode.org/Public/UNIDATA/Blocks.txt

I nomi dei blocchi si indicano con il prefisso In. Ad esempio, per far match sui caratteri del blocco Katakana si usa \p{InKatakana}. Il prefisso In può essere omesso se non ci sono conflitti con il nome di uno script o di un'altra proprietà, ma si raccomanda di usare sempre In per indicare i blocchi, per evitare confusione.

Sono supportati i seguenti nomi di blocco:

    InAlphabeticPresentationForms
    InArabic
    InArabicPresentationFormsA
    InArabicPresentationFormsB
    InArmenian
    InArrows
    InBasicLatin
    InBengali
    InBlockElements
    InBopomofo
    InBopomofoExtended
    InBoxDrawing
    InBraillePatterns
    InBuhid
    InByzantineMusicalSymbols
    InCJKCompatibility
    InCJKCompatibilityForms
    InCJKCompatibilityIdeographs
    InCJKCompatibilityIdeographsSupplement
    InCJKRadicalsSupplement
    InCJKSymbolsAndPunctuation
    InCJKUnifiedIdeographs
    InCJKUnifiedIdeographsExtensionA
    InCJKUnifiedIdeographsExtensionB
    InCherokee
    InCombiningDiacriticalMarks
    InCombiningDiacriticalMarksforSymbols
    InCombiningHalfMarks
    InControlPictures
    InCurrencySymbols
    InCyrillic
    InCyrillicSupplementary
    InDeseret
    InDevanagari
    InDingbats
    InEnclosedAlphanumerics
    InEnclosedCJKLettersAndMonths
    InEthiopic
    InGeneralPunctuation
    InGeometricShapes
    InGeorgian
    InGothic
    InGreekExtended
    InGreekAndCoptic
    InGujarati
    InGurmukhi
    InHalfwidthAndFullwidthForms
    InHangulCompatibilityJamo
    InHangulJamo
    InHangulSyllables
    InHanunoo
    InHebrew
    InHighPrivateUseSurrogates
    InHighSurrogates
    InHiragana
    InIPAExtensions
    InIdeographicDescriptionCharacters
    InKanbun
    InKangxiRadicals
    InKannada
    InKatakana
    InKatakanaPhoneticExtensions
    InKhmer
    InLao
    InLatin1Supplement
    InLatinExtendedA
    InLatinExtendedAdditional
    InLatinExtendedB
    InLetterlikeSymbols
    InLowSurrogates
    InMalayalam
    InMathematicalAlphanumericSymbols
    InMathematicalOperators
    InMiscellaneousMathematicalSymbolsA
    InMiscellaneousMathematicalSymbolsB
    InMiscellaneousSymbols
    InMiscellaneousTechnical
    InMongolian
    InMusicalSymbols
    InMyanmar
    InNumberForms
    InOgham
    InOldItalic
    InOpticalCharacterRecognition
    InOriya
    InPrivateUseArea
    InRunic
    InSinhala
    InSmallFormVariants
    InSpacingModifierLetters
    InSpecials
    InSuperscriptsAndSubscripts
    InSupplementalArrowsA
    InSupplementalArrowsB
    InSupplementalMathematicalOperators
    InSupplementaryPrivateUseAreaA
    InSupplementaryPrivateUseAreaB
    InSyriac
    InTagalog
    InTagbanwa
    InTags
    InTamil
    InTelugu
    InThaana
    InThai
    InTibetan
    InUnifiedCanadianAboriginalSyllabics
    InVariationSelectors
    InYiRadicals
    InYiSyllables

Proprietà dei caratteri definite dall'utente

Potete definire le vostre proprietà di carattere definendo delle subroutine con nomi che cominciano con In o Is. Queste subroutine possono essere definite in un qualsiasi package. Le proprietà definite dall'utente possono essere usate nei costrutti \p e \P nelle espressioni regolari; se usate una proprietà definite dall'utente in un package diverso da quello in cui è definita, dovete specificare quest'ultimo package all'interno di \p o \P:

    # la proprieta` IsStraniero e` definita in Lang::
    package main;  # altro package: serve il nome completo
    if ($txt =~ /\p{Lang::IsStraniero}+/) { ... }
    package Lang;  # stesso package: basta il nome corto
    if ($txt =~ /\p{IsStraniero}+/) { ... }

Notare che l'effetto è a tempo di compilazione, ed è immutabile una volta definito.

Le subroutine devono restituire una stringa in formato speciale, contenente una o più linee separate da a-capo. Ciascuna linea deve avere uno dei formati seguenti:

Ad esempio, per definire una proprietà che copra entrambi i sistemi sillabici giapponesi (hiragana e katakana) potete definire

    sub InKana {
        return <<END;
    3040\t309F
    30A0\t30FF
    END
    }

(immaginando che il terminatore del documento immediato sia all'inizio della riga). Ora potete usare \p{InKana} e \P{InKana}.

Avremmo anche potuto usare i nomi di blocchi esistenti:

    sub InKana {
        return <<'END';
    +utf8::InHiragana
    +utf8::InKatakana
    END
    }

Supponiamo che vogliate indicare solo i caratteri allocati, e non i semplici intervalli dei blocchi: in altre parole, volete rimuovere i non-caratteri:

    sub InKana {
        return <<'END';
    +utf8::InHiragana
    +utf8::InKatakana
    -utf8::IsCn
    END
    }

La negazione è utile per definire (sorpresa!) negazioni di classi:

    sub InNotKana {
        return <<'END';
    !utf8::InHiragana
    -utf8::InKatakana
    +utf8::IsCn
    END
    }

L'intersezione è utile per indicare i caratteri presenti in due (o più) classi.

    sub InFooAndBar {
        return <<'END';
    +main::Foo
    &main::Bar
    END
    }

È importante ricordare di non usare & per il primo insieme: vorrebbe dire fare l'intersezione col niente, e otterreste un insieme vuoto.

Potete anche definire le vostre mappature da far usare a lc(), lcfirst(), uc() e ucfirst() (o i loro equivalenti per le stringhe interpolate). Il principio è lo stesso: definite delle subroutine nel package main con nome ToLower (per lc() e lcfirst()), ToTitle (per il primo carattere in ucfirst), e ToUpper (per uc(), e i caratteri successivi in ucfirst())).

La stringa restituita dalla subroutine ora deve contenere, per ciascuna riga, tre numeri esadecimali separati da tabulazioni: inizio dell'intervallo di partenza, fine dell'intervallo di partenza, inizio dell'intervallo di arrivo. Per esempio:

    sub ToUpper {
        return <<END;
    0061\t0063\t0041
    END
    }

definisce una mappatura per uc() che trasforma i soli caratteri "a", "b" e "c" in "A", "B" e "C", lasciando inalterati tutti gli altri caratteri.

Se non ha senso parlare di intervallo di partenza, ovvero, se la mappatura interessa un solo carattere, lasciate vuota la fine dell'intervallo di partenza, ma dovete lasciare le due tabulazioni. Per esempio:

    sub ToLower {
        return <<END;
    0041\t\t0061
    END
    }

definisce una mappatura per lc() che trasforma il solo carattere "A" in "a", lasciando inalterati tutti gli altri caratteri.

(Per hacker più che abili) Se volete esaminare le mappature di default, potete trovarne le definizioni nella directory $Config{privlib}/unicore/To/. I dati delle mappature vengono restituiti dal documento immediato, e i vari utf::ToSpecQualcosa sono eccezioni speciali ricavate da $Config{privlib}/unicore/SpecialCasing.txt. Le mappature Digit e Fold presenti nella directory non sono direttamente accessibili dall'utente: potete usare il modulo Unicode::UCD, o fare i match senza distinguere maiuscole da minuscole (è in questo caso che viene usata la mappatura Fold).

Una nota finale sulle proprietà e mappature definite dall'utente: vengono usate soltanto se lo scalare su cui si opera è stato marcato come contente caratteri Unicode. Il funzionamento sulle stringhe di byte non viene modificato.

Codifica dei caratteri per l'input e l'output

Leggete the Encode manpage.

Livello di supporto Unicode nelle espressioni regolari

La seguente lista descrive tutte le funzionalità Unicode per espressioni regolari supportate al momento. I riferimenti a ``Livello N'' e i numeri di sezione si riferiscono al rapporto tecnico Unicode #18, ``Linee guida per le espressioni regolari Unicode'' (``Unicode Regular Expression Guidelines''), versione 6 (Unicode 3.2.0, Perl 5.8.0).

Codifiche Unicode

I caratteri Unicode sono associati a code point, che sono numeri astratti. Per usare questi numeri, sono necessarie varie codifiche.

Implicazioni di sicurezza di Unicode

Unicode in Perl su piattaforme EBCDIC

La gestione di Unicode su piattaforme EBCDIC è ancora sperimentale. Su tali piattaforme, i rifermenti alla codifica UTF-8 in questo e altri documenti dovrebbero essere intesi come a indicare UTF-EBCDIC, specificato dal rapporto tecnico Unicode 16, tranne nel caso in cui si stiano proprio discutendo le differenze tra ASCII e EBCDIC. Non esiste né una direttiva utfebcdic né uno strato :utfebcdic; al loro posto, utf8 e :utf8 vengono usati per indicare la codifica a 8 bit ``nativa'' della piattaforma per Unicode. Leggete the perlebcdic manpage per una discussione più approfondita della questione.

``Locale''

Normalmente le impostazione di ``locale'' e Unicode non si influenzano a vicenda, ma ci sono un paio di eccezioni:

Quando Unicode non viene usato

Sebbene Perl abbia molti modi per gestire l'input e l'output in Unicode, e i vari altri ``punti di ingresso dati'' come @ARGV che possono essere interpretati come Unicode (UTF-8), restano comunque molti casi in cui Unicode (in una qualche codifica) potrebbe essere fornito come parametro o ricevuto come risultato, ma non viene usato.

L'elenco seguente contiene tali interfacce. Per ciascuna di esse Perl al momento (versione 5.8.3) si limita ad assumere che sia i parametri che i risultati siano stringhe di byte, o stringhe UTF-8 se è stata usata la direttiva encoding.

Una delle ragioni per cui Perl non tenta di risolvere il ruolo di Unicode in questi casi è che le risposte dipendono fortemente dal sistema operativo e dal file system. Ad esempio, il fatto che i nomi di file possano essere Unicode, e in quale particolare codifica, non è un concetto proprio portabile. Allo stesso modo per qx e system: come viene gestito Unicode dall'``interfaccia a riga di comando''? (e di quale interfaccia si tratta?).

Forzare Unicode in Perl (o forzare non-Unicode)

In alcuni casi (vedi Quando Unicode non viene usato) dovete proprio convincere Perl che una stringa di byte è in UTF-8, o viceversa. Le chiamate di basso livello utf8::upgrade($bytestring) e utf8::downgrade($utf8string) sono la risposta.

Non usatele senza pensarci, però: Perl può confondersi, arabbiarsi o dare errori fatali se cambiate al volo la ``natura'' degli scalari a quel modo. Dovete stare particolarmente attenti se usate utf8::upgrade(): una stringa di byte a caso non è, in generale, UTF-8 valido.

Uso di Unicode con XS

Se volete maneggiare dati Perl in Unicode nelle vostre estensioni XS, potreste trovare utili le seguenti funzioni della API C. Leggete Supporto Unicode in the perlguts manpage per una spiegazione di Unicode a livello XS, e the perlapi manpage per i dettagli della API.

Per ulteriori informazioni, leggete the perlapi manpage, e utf8.c e utf8.h nella distribuzione del codice sorgente di Perl.

BUGS

Interazione con i ``locale''

L'uso dei ``locale'' con dati Unicode può portare a strani risultati. Al momento, Perl cerca di associare le informazioni di ``locale'' a 8 bit ai caratteri tra 0 e 255, ma questa tecnica è dimostrabilmente sbagliata per i ``locale'' che usano caratteri fuori da quell'intervallo quando vengono mappati su Unicode. Inoltre, il supporto Unicode di Perl funzionerà un po' più lentamente. L'uso dei ``locale'' con Unicode è scoraggiato.

Interazione con le estensioni

Quando Perl scambia dati con un estensione, l'estensione dovrebbe essere in grado di capire il flag UTF8 e agire di conseguenza. Se l'estensione non sa come usare il flag, è probabile che restituisca dati con il flag impostato in maniera scorretta.

Perciò se state lavorando con dati Unicode, consultate la documentazione di ciascun modulo che state usando se ci sono problemi con lo scambio di dati Unicode. Se la documentazione non parla di Unicode, sospettate il peggio, e magari guardate il sorgente per capire come è implementato il modulo. I moduli scritti interamente in Perl non dovrebbero causare problemi. Moduli che accedono, direttamente o indirettamente, codice scritto in altri linguaggi, sono a rischio.

Per le funzioni affette, la strategia semplice per evitare corruzione dei dati consiste nel rendere sempre esplicita la codifica dei dati scambiati. Scegliete una codifica che sapete che l'estensione sa gestire. Convertite gli argomenti da passare all'estensione in quella codifica, e riconvertite alla rovescia i risultati. Scrivete funzioni di interfaccia che facciano le conversioni al posto vostro, così che possiate sostituirle quando l'estensione verrà aggiornata.

Per fare un esempio, diciamo che la funzione Foo::Bar::escape_html non gestisce ancora dati Unicode. La funzione di interfaccia converte gli argomenti in UTF-8 semplice e converte il risultato di nuovo nella rappresentazione interna Perl:

    sub mio_escape_html ($) {
      my($cosa) = shift;
      return unless defined $cosa;
      Encode::decode_utf8(Foo::Bar::escape_html(Encode::encode_utf8($cosa)));
    }

Certe volte, quando l'estensione non converte i dati ma si limita a immagazzinarli e recuperarli, vi troverete nella posizione di usare l'altrimenti pericolosa funzione Encode::_utf8_on(). Diciamo che la popolare estensione Foo::Bar, scritta in C, fornisce un metodo param che permette di immagazzinare e recuperare dati secondo queste segnature:

    $self->param($name, $value);            # salva uno scalare
    $value = $self->param($name);           # recupera uno scalare

Se l'estensione non fornisce ancora supporto per alcuna codifica, potreste scrivere una classe derivata con un metodo param come questo:

    sub param {
      my($self,$nome,$valore) = @_;
      utf8::upgrade($nome);     # ora e` sicuramente UTF-8
      if (defined $valore)
        utf8::upgrade($valore); # ora e` sicuramente UTF-8
        return $self->SUPER::param($nome,$valore);
      } else {
        my $ret = $self->SUPER::param($nome);
        Encode::_utf8_on($ret); # sappiamo che e` UTF-8
        return $ret;
      }
    }

Alcune estensioni forniscono filtri per i casi di entrata/uscita dei dati, come la famiglia di DB_File::filter_store_key. Cercate filtri del genere nella documentazione delle vostre estensioni, possono rendere la transizione a Unicode molto più facile.

Velocità

Alcune funzioni sono più lente quando lavorano su stringhe codificate in UTF-8 piuttosto che su stringhe di byte. Tutte le funzioni che devono saltare caratteri, come length(), substr() o index(), o le espressioni regolari, lavorano molto più velocemente quando i dati sono byte.

In Perl 5.8.0 questa lentezza era spesso piuttosto spettacolare; in Perl 5.8.1 è stato introdotto un sistema di cache che dovrebbe ridurre il problema, almeno per alcune operazioni. In generale, le operazioni con stringhe UTF-7 restano lente. Ad esempio, le proprietà Unicode (classi di caratteri) come \p{Nd} sono parecchio più lente (5-20 volte) delle corrispondenti semplici come \d (d'altra parte, ci sono 268 caratteri corrispondenti a Nd, contro i soli 10 per d).

Aggiornare il codice da perl-5.6.X

Perl 5.8 ha un modello Unicode diverso da quello di 5.6. In 5.6 il programmatore doveva usare la direttiva utf8 per indicare che in un particolare scope si stavano trattando dati Unicode, e doveva assicurarsi che ci entrassero solo dati Unicode. Se avete del codice che funziona sollo 5.6, avrete bisogno di alcuni tra gli aggiustamenti seguenti. Gli esempi sono scritti in modo da continuare a funzionare sotto 5.6, per cui dovreste poterli provare senza rischi.

VEDI ANCHE

the perluniintro manpage, the encoding manpage, the Encode manpage, the open manpage, the utf8 manpage, the bytes manpage, the perlretut manpage, ${^UNICODE} in the perlvar manpage

TRADUZIONE

Versione

La versione su cui si basa questa traduzione è ottenibile con:

   perl -MPOD2::IT -e print_pod perlunicode

Per maggiori informazioni sul progetto di traduzione in italiano si veda http://pod2it.sourceforge.net/ .

Traduttore

Traduzione a cura di Gianni Ceccarelli.

 NOME