perlunicode - Online nel cloud

PROGRAMMA:

NOME

perlunicode - Supporto Unicode in Perl

DESCRIZIONE

Se non l'hai già fatto, prima di leggere questo documento dovresti familiarizzare con entrambi
perlunitu e perluniintro.

Unicode mira a UNI-fy l'en-CODICE-ings di tutti i set di caratteri del mondo in un unico
Standard. Per alcuni dei vari standard di codifica che esistevano quando era Unicode
creato per la prima volta, convertire da ciascuno a Unicode significava essenzialmente aggiungere una costante a ciascuno
punto di codice nello standard originale e riconvertire significava semplicemente sottrarre quello stesso
costante. Per ASCII e ISO-8859-1, la costante è 0. Per ISO-8859-5, (cirillico) la
la costante è 864; per l'ebraico (ISO-8859-8), è 1488; tailandese (ISO-8859-11), 3424; e così
via. Ciò ha reso facile eseguire le conversioni e ha facilitato l'adozione di Unicode.

E ha funzionato; al giorno d'oggi, questi standard legacy sono usati raramente. Quasi tutti usano
Unicode.

Unicode è uno standard completo. Specifica molte cose al di fuori dell'ambito di Perl,
ad esempio come visualizzare sequenze di caratteri. Per una discussione completa di tutti gli aspetti di
Unicode, vedihttp://www.unicode.org>.

Consigli Avvertenze
Anche se alcune parti di questa sezione potrebbero non essere comprensibili alla prima lettura, noi
penso che sia abbastanza importante evidenziare alcuni dei trucchi prima di approfondire, quindi
Ecco qui:

Il supporto Unicode è un requisito esteso. Sebbene Perl non implementi Unicode
standard o le relazioni tecniche di accompagnamento dall'inizio alla fine, Perl ne supporta molti
Funzionalità Unicode.

Inoltre, l'uso di Unicode può presentare problemi di sicurezza non ovvi. Leggi Unicode
Considerazioni sulla sicurezzahttp://www.unicode.org/reports/tr36>.

Più sicuro se "usi la funzione 'unicode_strings'"
Per preservare la compatibilità con le versioni precedenti, Perl non si attiva completamente internamente
Supporto Unicode a meno che non sia specificato il pragma "use feature 'unicode_strings'". (Questo
viene selezionato automaticamente se si "usa 5.012" o superiore.) In caso contrario, è possibile
scatenare sorprese inaspettate. Vedi "Il "bug Unicode"" di seguito.

Questo pragma non influisce sull'I/O. Né cambia la rappresentazione interna di
stringhe, solo la loro interpretazione. Ci sono ancora diversi posti in cui Unicode
non è completamente supportato, come nei nomi di file.

Livelli di input e output
Usa il livello ":encoding(...)" per leggere e scrivere su filehandle usando il
codifica specificata. (Vedi aperto.)

Dovresti convertire i tuoi script Perl non ASCII e non UTF-8 in UTF-8.
Vedi codifica.

"usa utf8" è ancora necessario per abilitare UTF-8 negli script
Se il tuo script Perl è esso stesso codificato in UTF-8, il pragma "usa utf8" deve essere
incluso esplicitamente per consentirne il riconoscimento (in una stringa o in un'espressione regolare
letterali o nei nomi degli identificatori). Si is , il esclusivamente tempo quando an esplicito "utilizzo utf8"
is necessario. (Vedi utf8).

Script contrassegnati con "BOM" e script UTF-16 rilevati automaticamente
Tuttavia, se uno script Perl inizia con Unicode "BOM" (UTF-16LE, UTF16-BE o
UTF-8), o se lo script sembra UTF-16 non contrassegnato da "BOM" di entrambe le endianness, Perl
leggerà correttamente nello script come la codifica Unicode appropriata. ("BOM"-meno
UTF-8 non può essere efficacemente riconosciuto o differenziato da ISO 8859-1 o altro
codifiche a otto bit.)

Byte e a Carattere Semantica
Prima di Unicode, la maggior parte delle codifiche utilizzava 8 bit (un singolo byte) per codificare ogni carattere. così
un carattere era un byte e un byte era un carattere e potevano essercene solo 256 o meno
possibili caratteri. "Byte Semantics" nel titolo di questa sezione si riferisce a questo
comportamento. Non c'era bisogno di distinguere tra "Byte" e "Carattere".

Poi arriva Unicode che ha spazio per oltre un milione di caratteri (e Perl consente
ancora di più). Ciò significa che un carattere può richiedere più di un singolo byte per essere rappresentato
it, e quindi i due termini non sono più equivalenti. Che importa sono i personaggi come
intere entità, e non di solito i byte che le compongono. Questo è il termine
"Semantica dei caratteri" nel titolo di questa sezione si riferisce a.

Perl ha dovuto cambiare internamente per separare i "byte" dai "caratteri". È importante che
cambia idea anche tu, se non l'hai già fatto, in modo che "byte" e "carattere" no
significano più la stessa cosa nella tua mente.

L'elemento base delle stringhe Perl è sempre stato un "personaggio". I cambiamenti
fondamentalmente si riduce al fatto che l'implementazione non pensa più che un personaggio sia sempre
solo un singolo byte.

Ci sono varie cose da notare:

· Le funzioni di gestione delle stringhe, per la maggior parte, continuano ad operare in termini di
caratteri. "length()", ad esempio, restituisce il numero di caratteri in una stringa,
proprio come prima. Ma quel numero non è più necessariamente uguale al numero di
byte nella stringa (potrebbero esserci più byte che caratteri). L'altro così
le funzioni includono "chop()", "chomp()", "substr()", "pos()", "index()", "rindex()",
"sort()", "sprintf()" e "write()".

Le eccezioni sono:

· il "vec" orientato ai bit

· il formato "C" orientato ai byte "pack"/"unpack"

Tuttavia, l'identificatore "W" funziona su interi caratteri, così come la "U"
specificatore.

· alcuni operatori che interagiscono con il sistema operativo della piattaforma

Gli operatori che si occupano di nomi di file sono esempi.

· quando le funzioni vengono chiamate dall'ambito del pragma "use bytes"

Probabilmente, dovresti comunque usarlo solo per il debug.

· Le stringhe, comprese le chiavi hash, e i modelli di espressioni regolari possono contenere caratteri
che hanno valori ordinali maggiori di 255.

Se utilizzi un editor Unicode per modificare il tuo programma, potrebbero verificarsi caratteri Unicode
direttamente all'interno delle stringhe letterali nella codifica UTF-8 o UTF-16. (L'ex
richiede una "BOM" o "use utf8", quest'ultima richiede una "BOM".)

"Creare Unicode" in perluniintro offre altri modi per inserire caratteri non ASCII in
le tue corde.

· Le funzioni "chr()" e "ord()" lavorano su interi caratteri.

· Le espressioni regolari corrispondono a interi caratteri. Per esempio, "." corrisponde a un intero
carattere anziché solo un singolo byte.

· L'operatore "tr///" traduce interi caratteri. (Nota che "tr///CU"
la funzionalità è stata rimossa. Per funzionalità simili, vedere "pack('U0',
...)" e "pack('C0', ...)").

· "scalar reverse()" inverte per carattere anziché per byte.

· Gli operatori di stringa di bit, "& | ^ ~" e (a partire dalla v5.22) "&. |. ^. ~." può operare
sui caratteri che non rientrano in un byte. Tuttavia, è probabile che il comportamento attuale
modificare. Non dovresti usare questi operatori su stringhe codificate in UTF-8. Se
non sei sicuro della codifica di una stringa, esegui il downgrade prima di utilizzare uno di questi
operatori; puoi usare "utf8::utf8_downgrade()".

La linea di fondo è che Perl ha sempre praticato la "Semantica dei caratteri", ma con il
avvento di Unicode, che ora è diverso da "Byte Semantics".

ASCII Regole Unicode Regole
Prima di Unicode, quando un carattere era un byte era un carattere, Perl conosceva solo il 128
caratteri definiti da ASCII, punti di codice da 0 a 127 (tranne in "usa locale").
Ciò ha lasciato i punti di codice da 128 a 255 come non assegnati e disponibili per qualsiasi uso a
programma potrebbe volere. L'unica semantica che hanno sono i loro numeri ordinali, e che loro
sono membri di nessuna delle classi di caratteri non negativi. Nessuno è considerato corrispondente
"\w" per esempio, ma tutti corrispondono a "\W".

Unicode, ovviamente, assegna a ciascuno di questi punti di codice un significato particolare (insieme a
quelli superiori a 255). Per preservare la compatibilità con le versioni precedenti, Perl utilizza solo i significati Unicode
quando c'è qualche indicazione che Unicode è ciò che è previsto; altrimenti il ​​non-ASCII
i punti codice rimangono trattati come se non fossero stati assegnati.

Ecco i modi in cui Perl sa che una stringa deve essere trattata come Unicode:

· Nell'ambito di "usa utf8"

Se l'intero programma è Unicode (indicato dall'utilizzo di 8 bit Unicode Ttrasformazione
Format), allora tutte le stringhe al suo interno devono essere Unicode.

· Nell'ambito di "usa la funzione 'unicode_strings'"

Questo pragma è stato creato in modo da poter dire esplicitamente a Perl che le operazioni sono state eseguite
nel suo ambito sono di utilizzare le regole Unicode. Più operazioni sono interessate da più recenti
perle. Vedi "Il "bug Unicode"".

· Nell'ambito di "usa 5.012" o superiore

Questo attiva implicitamente "usa la funzione 'unicode_strings'".

· Nell'ambito di "usa locale 'non_caratteri'", o "usa locale" e l'attuale
locale è un locale UTF-8.

Il primo è definito per implicare la gestione di Unicode; e quest'ultimo indica un Unicode
locale, quindi un'interpretazione Unicode di tutte le stringhe al suo interno.

· Quando la stringa contiene un punto di codice solo Unicode

Perl non ha mai accettato punti di codice superiori a 255 senza che fossero Unicode, quindi il loro uso
implica Unicode per l'intera stringa.

· Quando la stringa contiene un punto di codice denominato Unicode "\N{...}"

Il costrutto "\N{...}" si riferisce esplicitamente a un punto di codice Unicode, anche se è uno
che è anche in ASCII. Pertanto la stringa che lo contiene deve essere Unicode.

· Quando la stringa proviene da una fonte esterna contrassegnata come Unicode

L'opzione della riga di comando "-C" può specificare che alcuni input al programma sono
Unicode, e i valori di questo possono essere letti dal tuo codice Perl, vedi "${^UNICODE}" in
perlvar.

· Quando la stringa è stata aggiornata a UTF-8

La funzione "utf8::utf8_upgrade()" può essere utilizzata esplicitamente per permanentemente (a meno che a
successivo "utf8::utf8_downgrade()" viene chiamato) fa sì che una stringa venga trattata come
Unicode.

· Esistono metodi aggiuntivi per i modelli di espressioni regolari

Un modello compilato con i modificatori "/u" o "/a" viene trattato come Unicode
(sebbene ci siano alcune restrizioni con "/a"). Sotto i modificatori "/d" e "/l",
ci sono molte altre indicazioni per Unicode; vedere "Modificatori di set di caratteri" in
perla.

Nota che tutto quanto sopra viene sovrascritto nell'ambito di "usa byte"; ma dovresti
utilizzare questo pragma solo per il debug.

Nota anche che alcune interazioni con il sistema operativo della piattaforma non usano mai Unicode
regole.

Quando sono in vigore le regole Unicode:

· Gli operatori di traduzione dei casi utilizzano le tabelle di traduzione dei casi Unicode.

Nota che "uc()", o "\U" nelle stringhe interpolate, si traduce in maiuscolo, mentre
"ucfirst", o "\u" nelle stringhe interpolate, si traduce in maiuscole/minuscole nelle lingue che
fare la distinzione (che equivale a maiuscolo nelle lingue senza il
distinzione).

C'è un modulo CPAN, "Unicode::Casing", che ti permette di definire il tuo
mappature da utilizzare in "lc()", "lcfirst()", "uc()", "ucfirst()" e "fc" (o loro
versioni inline con stringhe tra virgolette come "\U"). (Prima di Perl 5.16, questo
funzionalità era parzialmente fornita nel core Perl, ma soffriva di una serie di
insormontabili inconvenienti, quindi è stato scritto il modulo CPAN.)

· Le classi di caratteri nelle espressioni regolari corrispondono in base alle proprietà dei caratteri
specificato nel database delle proprietà Unicode.

"\w" può essere usato per abbinare un ideogramma giapponese, per esempio; e "[[:digit:]]" a
numero bengalese.

· È possibile utilizzare proprietà, script e intervalli di blocchi denominati Unicode (come tra parentesi
classi di caratteri) utilizzando il costrutto "\p{}" "matches property" e il costrutto "\P{}"
negazione, "non corrisponde alla proprietà".

Vedere "Proprietà dei caratteri Unicode" per maggiori dettagli.

Puoi definire le tue proprietà del carattere e usarle nell'espressione regolare
con il costrutto "\p{}" o "\P{}". Vedere "Proprietà dei caratteri definite dall'utente" per ulteriori informazioni
dettagli.

estesa grafema Cluster (Logico personaggi)
Considera un personaggio, dì "H". Potrebbe apparire con vari segni intorno, come un
accento acuto, o un circonflesso, o vari uncini, cerchi, frecce, ecc., sopra, sotto, a
da una parte o dall'altra, eccetera. Ci sono molte possibilità tra le lingue del mondo.
Il numero di combinazioni è astronomico, e se ci fosse un carattere per ciascuna
combinazione, esaurirebbe presto gli oltre un milione di possibili caratteri di Unicode. Così
Unicode ha adottato un approccio diverso: c'è un carattere per la base "H" e un carattere
per ciascuno dei possibili voti, e questi possono essere variamente combinati per ottenere una logica finale
carattere. Quindi un carattere logico, quello che sembra essere un singolo carattere, può essere un
sequenza di più di un singolo carattere. Lo standard Unicode li chiama
"gruppi di grafemi estesi" (che è una versione migliorata del non più molto usato
"cluster di grafema"); Perl fornisce il costrutto di espressione regolare "\X" per corrispondere a tale
sequenze nella loro interezza.

Ma l'intento di Unicode è quello di unificare gli standard e le pratiche del set di caratteri esistenti e
diversi standard preesistenti hanno caratteri singoli che significano la stessa cosa di alcuni di
queste combinazioni, come ISO-8859-1, che ne ha parecchie. Ad esempio, "LATINA
LETTERA MAIUSCOLA E CON ACUTE" era già in questo standard quando è arrivato Unicode.
Unicode quindi lo ha aggiunto al suo repertorio come quel singolo carattere. Ma questo personaggio
è considerato da Unicode equivalente alla sequenza costituita dal carattere
"LETTERA LATINA E MAIUSCOLA" seguita dal carattere "COMBINAZIONE DI ACCENTO ACUTO".

La "LETTERA LATINA E CON ACUTA" è chiamata un carattere "precomposto" e la sua
l'equivalenza con la sequenza "E" e "COMBINING ACCENT" è detta canonica
equivalenza. Si dice che tutti i caratteri precomposti abbiano una scomposizione (nella
sequenza equivalente) e il tipo di decomposizione è anche chiamato canonico. Una stringa può
essere composto il più possibile da caratteri precomposti, oppure può essere composto da
personaggi completamente scomposti. Unicode li chiama rispettivamente "Forma di normalizzazione"
Composed" (NFC) e "Normalization Form Decomposed". Il modulo "Unicode::Normalize"
contiene funzioni che convertono tra i due. Una stringa può anche avere entrambe composte
personaggi e personaggi scomposti; questo modulo può essere utilizzato per renderlo uno o l'altro
altra.

Potrebbero essere presentate stringhe in una di queste forme equivalenti. C'è attualmente
niente in Perl 5 che ignori le differenze. Quindi dovrai gestirlo appositamente.
Il solito consiglio è di convertire i tuoi input in "NFD" prima di elaborarli ulteriormente.

Per informazioni più dettagliate, vederehttp://unicode.org/reports/tr15/>.

Unicode Carattere Properties
(L'unica volta in cui Perl considera una sequenza di punti di codice individuali come un singolo
carattere logico è nel costrutto "\X", già menzionato sopra. Dunque
"carattere" in questa discussione significa un singolo punto di codice Unicode.)

Quasi tutte le proprietà dei caratteri Unicode sono accessibili tramite espressioni regolari da
utilizzando il costrutto "\p{}" "proprietà corrispondente" e la proprietà "\P{}" "non corrisponde alla proprietà" per
la sua negazione.

Ad esempio, "\p{Maiuscolo}" corrisponde a qualsiasi singolo carattere con "Maiuscolo" Unicode
proprietà, mentre "\p{L}" corrisponde a qualsiasi carattere con una "General_Category" di "L" (lettera)
proprietà (vedere "Categoria_generale" di seguito). Le parentesi non sono necessarie per una singola lettera
nomi di proprietà, quindi "\p{L}" è equivalente a "\pL".

Più formalmente, "\p{Maiuscolo}" corrisponde a qualsiasi singolo carattere il cui Unicode "Maiuscolo"
il valore della proprietà è "True" e "\P{Uppercase}" corrisponde a qualsiasi carattere il cui "Maiuscolo"
il valore della proprietà è "False" e avrebbero potuto essere scritti come "\p{Uppercase=True}" e
"\p{Maiuscolo=Falso}", rispettivamente.

Questa formalità è necessaria quando le proprietà non sono binarie; cioè, se possono sopportare di più
valori oltre a "Vero" e "Falso". Ad esempio, la proprietà "Bidi_Class" (vedi
"Tipi di caratteri bidirezionali" di seguito), può assumere diversi valori, come
"Sinistra", "Destra", "Spazio bianco" e altri. Per abbinare questi, è necessario specificare sia il
nome della proprietà ("Bidi_Class"), E il valore che viene confrontato con ("Left", "Right", ecc.).
Questo viene fatto, come negli esempi sopra, avendo le due componenti separate da un uguale
segno (o, in modo intercambiabile, i due punti), come "\p{Bidi_Class: Left}".

Tutte le proprietà dei caratteri definite da Unicode possono essere scritte in queste forme composte di
"\P{proprietà=valore}" o "\p{valore della proprietà}", ma Perl fornisce alcune proprietà aggiuntive
che sono scritti solo nella forma singola, così come le scorciatoie in forma singola per tutti i binari
proprietà e alcune altre descritte di seguito, in cui è possibile omettere il nome della proprietà e
l'uguale o il separatore di due punti.

La maggior parte delle proprietà dei caratteri Unicode ha almeno due sinonimi (o alias se preferisci): a
uno corto che è più facile da digitare e uno più lungo che è più descrittivo e quindi
più facile da capire. Quindi le proprietà "L" e "Lettera" sopra sono equivalenti e possono
essere usato in modo intercambiabile. Allo stesso modo, "Maiuscolo" è sinonimo di "Maiuscolo", e potremmo
hanno scritto "\p{Maiuscolo}" in modo equivalente a "\p{Maiuscolo}". Inoltre, ci sono in genere
vari sinonimi per i valori che può essere la proprietà. Per le proprietà binarie, "True" ha 3
sinonimi: "T", "Sì" e "Y"; e "False" ha corrispondentemente "F", "No" e "N". ma essere
attento. Una forma breve di un valore per una proprietà potrebbe non significare la stessa cosa come lo stesso
forma breve per un altro. Pertanto, per la proprietà "General_Category", "L" significa "Lettera",
ma per la proprietà "Bidi_Class", "L" significa "Sinistra". Un elenco completo di proprietà e
sinonimi è in perluniprops.

Le differenze tra maiuscole e minuscole nei nomi e nei valori delle proprietà sono irrilevanti; quindi "\p{Superiore}"
significa la stessa cosa di "\p{upper}" o anche "\p{UpPeR}". Allo stesso modo, puoi aggiungere o
sottrarre i trattini bassi ovunque nel mezzo di una parola, in modo che anche questi siano equivalenti
a "\p{U_p_p_e_r}". E lo spazio bianco è irrilevante adiacente a caratteri non di parole, come
come le parentesi graffe e i separatori di uguale o di due punti, quindi "\p{ Upper }" e "\p{ Upper_case
: Y }" sono equivalenti anche a questi. In effetti, lo spazio bianco e persino i trattini possono di solito
essere aggiunto o eliminato ovunque. Quindi anche "\p{ Maiuscole = Sì}" è equivalente. Tutto questo
è chiamato "loose-matching" da Unicode. I pochi posti in cui viene utilizzata una corrispondenza più rigorosa è
nel mezzo dei numeri e nelle proprietà dell'estensione Perl che iniziano o finiscono con an
sottolineare. La corrispondenza più rigorosa si preoccupa dello spazio bianco (tranne adiacente alla non parola
caratteri), trattini e trattini bassi non interni.

Puoi anche usare la negazione sia in "\p{}" che in "\P{}" introducendo un accento circonflesso ("^") tra
la prima parentesi graffa e il nome della proprietà: "\p{^Tamil}" è uguale a "\P{Tamil}".

Quasi tutte le proprietà sono immuni alla corrispondenza senza distinzione tra maiuscole e minuscole. Cioè, aggiungendo un "/i"
il modificatore di espressione regolare non cambia ciò a cui corrispondono. Ci sono due set che sono
ricercato. Il primo set è "Lettera_maiuscola", "Lettera_minuscola" e
"Titlecase_Letter", che corrisponde a "Cased_Letter" sotto la corrispondenza "/i". E il secondo
set è "Maiuscole", "minuscole" e "Titlecase", che corrispondono a "Cased" sotto "/i"
corrispondenza. Questo set include anche i suoi sottoinsiemi "PosixUpper" e "PosixLower" entrambi
sotto "/i" corrisponde a "PosixAlpha". (La differenza tra questi set è che alcune cose,
come i numeri romani, sono disponibili sia in maiuscolo che in minuscolo, quindi sono "Cased", ma non lo sono
considerate lettere, quindi non sono "Cased_Letter".)

Vedere "Oltre i punti di codice Unicode" per considerazioni speciali quando si abbina Unicode
proprietà rispetto a punti di codice non Unicode.

Categoria_generale

A ogni carattere Unicode viene assegnata una categoria generale, che è la "più comune"
categorizzazione di un personaggio" (dahttp://www.unicode.org/reports/tr44>).

Il modo composto di scriverli è come "\p{General_Category=Number}" (in breve:
"\p{gc:n}"). Ma Perl fornisce scorciatoie in cui tutto passa attraverso l'uguale o
il separatore di due punti viene omesso. Quindi puoi invece scrivere semplicemente "\pN".

Ecco le forme brevi e lunghe dei valori che può avere la proprietà "Categoria generale":

Corto lungo

L lettera
LC, L& Lettera_maiuscola (ovvero: [\p{Ll}\p{Lu}\p{Lt}])
Lu Lettera_maiuscola
Ll Lettera_minuscola
Lt Titlecase_Letter
Lm Modificatore_Lettera
Lo Altro_Lettera

M Marco
Mn Non spaziato_Mark
Mc Spaziatura_Marco
Me che racchiude_Mark

Numero N
Nd Decimal_Number (anche cifra)
Nl Lettera_Numero
Nessun altro_numero

P punteggiatura (anche punt)
Connettore PC_Punteggiatura
Pd Dash_Punteggiatura
Ps Open_Punteggiatura
Pe Close_Punteggiatura
Pi iniziale_punteggiatura
(può comportarsi come Ps o Pe a seconda dell'uso)
Pf Final_Punteggiatura
(può comportarsi come Ps o Pe a seconda dell'uso)
Po Altro_Punteggiatura

simbolo S
Sm Matematica_Simbolo
Sc Valuta_Simbolo
Sk Modifier_Simbolo
Quindi Altro_Simbolo

Separatore Z
Zs Space_Separator
Zl Line_Separator
Zp Paragrafo_Separatore

C Altro
Cc Control (anche Cntrl)
Cf Formato
Cs surrogato
Co Private_Use
Cn non assegnato

Le proprietà di una lettera corrispondono a tutti i caratteri in una qualsiasi delle sottoproprietà di due lettere
iniziando con la stessa lettera. "LC" e "L&" sono speciali: entrambi sono alias per il set
composto da tutto ciò che corrisponde a "Ll", "Lu" e "Lt".

bidirezionale Carattere Tipi

Perché le scritture differiscono nella loro direzionalità (l'ebraico e l'arabo sono scritti proprio per
a sinistra, ad esempio) Unicode fornisce una proprietà "Bidi_Class". Alcuni dei valori questo
la proprietà può avere sono:

Significato del valore

L da sinistra a destra
Incorporamento LRE da sinistra a destra
LRO Override da sinistra a destra
R da destra a sinistra
AL lettera araba
Incorporamento RLE da destra a sinistra
Ignora RLC da destra a sinistra
Formato PDF Pop direzionale
IT Numero Europeo
ES Separatore Europeo
ET Terminatore europeo
UN numero arabo
Separatore comune CS
Segno non spaziato NSM
BN Confine neutro
B Separatore di paragrafo
Separatore di segmenti S
WS Spazio bianco
SU altri neutri

Questa proprietà è sempre scritta nella forma composta. Ad esempio, "\p{Bidi_Class:R}"
corrisponde ai caratteri che normalmente sono scritti da destra a sinistra. A differenza di "General_Category"
proprietà, questa proprietà può avere più valori aggiunti in una futura versione di Unicode. Quelli
sopra elencati comprendeva il set completo per molte versioni Unicode, ma ne sono state aggiunte altre
in Unicode 6.3; puoi sempre trovare quello che contengono quelli attuali in perluniprops. e
<http://www.unicode.org/reports/tr9/> descrive come usarli.

Script

Le lingue del mondo sono scritte in molte scritture diverse. Questa frase (a meno che tu non sia
leggendolo in traduzione) è scritto in latino, mentre il russo è scritto in cirillico, e
Il greco è scritto in, beh, greco; Giapponese principalmente in Hiragana o Katakana. Ci sono molti
altri accessori.

Le proprietà Unicode "Script" e "Script_Extensions" forniscono a quale script un determinato carattere
è in. Entrambe le proprietà possono essere specificate con la forma composta come "\p{Script=Hebrew}"
(breve: "\p{sc=hebr}"), o "\p{Script_Extensions=Javanese}" (breve: "\p{scx=java}"). In
Inoltre, Perl fornisce scorciatoie per tutti i nomi di proprietà "Script". puoi omettere
tutto fino agli uguali (o due punti) e scrivi semplicemente "\p{Latin}" o
"\P{Cirillico}". (Questo non è vero per "Script_Extensions", che deve essere
scritto nella forma composta.)

La differenza tra queste due proprietà riguarda i caratteri che vengono utilizzati in più
script. Ad esempio, le cifre da '0' a '9' sono utilizzate in molte parti del mondo.
Questi sono inseriti in uno script chiamato "Comune". Altri caratteri sono usati solo in pochi
script. Ad esempio, il "KATAKANA-HIRAGANA DOUBLE HYPHEN" è usato in entrambi i giapponesi
script, Katakana e Hiragana, ma da nessun'altra parte. La proprietà "Script" posiziona tutto
caratteri che vengono utilizzati in più script nello script "Comune", mentre il
La proprietà "Script_Extensions" inserisce quelli che vengono utilizzati solo in pochi script in ciascuno di
quegli script; mentre si utilizza ancora "Comune" per quelli utilizzati in molti script. Quindi entrambi questi
gioco:

"0" =~ /\p{sc=Comune}/ # Corrispondenze
"0" =~ /\p{scx=Comune}/ # Corrispondenze

e solo il primo di questi corrisponde:

"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{sc=Comune} # Corrisponde a
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{scx=Comune} # Nessuna corrispondenza

E solo gli ultimi due di questi corrispondono:

"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{sc=Hiragana} # Nessuna corrispondenza
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{sc=Katakana} # Nessuna corrispondenza
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{scx=Hiragana} # Corrisponde a
"\N{KATAKANA-HIRAGANA DOUBLE HYPHEN}" =~ /\p{scx=Katakana} # Corrisponde a

"Script_Extensions" è quindi uno "Script" migliorato, in cui ci sono meno caratteri in
lo script "Comune", e di conseguenza più in altri script. È nuovo in Unicode
versione 6.0, ed è probabile che i suoi dati cambino in modo significativo nelle versioni successive, poiché le cose
sistemati. Il nuovo codice dovrebbe probabilmente usare "Script_Extensions" e non semplice
"Sceneggiatura".

(In realtà, oltre a "Comune", lo script "Ereditato", contiene caratteri che vengono utilizzati in
più script. Questi sono caratteri modificatori che ereditano il valore dello script del
carattere di controllo. Alcuni di questi sono usati in molti script, quindi vai in "Ereditato"
sia in "Script" che in "Script_Extensions". Altri sono usati in pochi script, così lo sono
in "Ereditato" in "Script", ma non in "Script_Extensions".)

Vale la pena sottolineare che ci sono diversi insiemi di cifre in Unicode che sono
equivalente a 0-9 e corrisponde a "\d" in un'espressione regolare. Se sono utilizzati in
una sola lingua, sono in "Script" e "Script_Extension" di quella lingua. Se
sono usati in più di uno script, saranno in "sc=Common", ma solo se lo sono
utilizzati in molti script dovrebbero essere in "scx=Common".

Un elenco completo degli script e delle loro scorciatoie è in perluniprops.

Usa il of , il "È" Prefisso

Per compatibilità con le versioni precedenti (con Perl 5.6), tutte le proprietà sono scrivibili senza utilizzare il
forma composta menzionata finora potrebbe avere "Is" o "Is_" anteposto al loro nome, quindi
"\P{Is_Lu}", ad esempio, è uguale a "\P{Lu}" e "\p{IsScript:Arabic}" è uguale a
"\p{Arabo}".

Blocchi

Oltre script, Unicode definisce anche blocchi di personaggi. La differenza tra
script e blocchi è che il concetto di script è più vicino ai linguaggi naturali, mentre
il concetto di blocchi è più di un raggruppamento artificiale basato su gruppi di Unicode
caratteri con valori ordinali consecutivi. Ad esempio, il blocco "Latino di base" è all
i caratteri i cui ordinali sono compresi tra 0 e 127 inclusi; in altre parole, l'ASCII
caratteri. La scrittura "latino" contiene alcune lettere di questa e molte altre
blocchi, come "Latin-1 Supplement", "Latin Extended-A", ecc., ma non contiene tutto
i personaggi di quei blocchi. Non contiene, ad esempio, le cifre 0-9,
perché quelle cifre sono condivise tra molti script e quindi sono nello script "Comune".

Per ulteriori informazioni sugli script rispetto ai blocchi, vedere UAX#24 "Proprietà script Unicode":
<http://www.unicode.org/reports/tr24>

È probabile che le proprietà "Script" o "Script_Extensions" siano quelle che desideri utilizzare
durante l'elaborazione del linguaggio naturale; la proprietà "Block" può essere utile occasionalmente in
lavorando con i dadi e i bulloni di Unicode.

I nomi dei blocchi sono abbinati nella forma composta, come "\p{Blocco: Frecce}" o
"\p{Blk=ebraico}". A differenza della maggior parte delle altre proprietà, solo pochi nomi di blocco hanno un Unicode-
nome breve definito. Ma Perl fornisce una scorciatoia (leggera, non più consigliata):
Puoi dire, ad esempio "\p{In_Arrows}" o "\p{In_Hebrew}".

Per compatibilità con le versioni precedenti, il prefisso "In" può essere omesso se non c'è conflitto di denominazione
con uno script o qualsiasi altra proprietà, e puoi anche usare un prefisso "È" invece in quelli
casi. Ma non farlo per il nuovo codice perché il tuo codice potrebbe violare le nuove versioni e
questo è già successo: c'è stato un tempo nelle primissime versioni di Unicode in cui
"\p{ebraico}" avrebbe trovato la corrispondenza con bloccare Ebraico; ora no.

L'uso del prefisso "In" evita questa ambiguità, finora. Ma le nuove versioni di Unicode continuano
per aggiungere nuove proprietà i cui nomi iniziano con "In". C'è la possibilità che uno di
un giorno entreranno in conflitto con il tuo utilizzo. Poiché questa è solo un'estensione Perl,
Il nome di Unicode avrà la precedenza e il codice verrà danneggiato. Inoltre, Unicode è
libero di aggiungere uno script il cui nome inizia con "In"; che creerebbe problemi.

Quindi è più chiaro e migliore usare la forma composta quando si specificano i blocchi. E stai sicuro
questo è ciò che davvero vuoi fare. Nella maggior parte dei casi gli script sono ciò che vuoi
anziché.

Un elenco completo dei blocchi e delle loro scorciatoie è in perluniprops.

Altri Properties

Ci sono molte più proprietà rispetto a quelle di base descritte qui. Un elenco completo
è in perluniprops.

Unicode definisce tutte le sue proprietà nella forma composta, quindi tutte le proprietà a forma singola sono
Estensioni Perl. La maggior parte di questi sono solo sinonimi di quelli Unicode, ma alcuni lo sono
estensioni autentiche, comprese alcune che sono in forma composta. E parecchi di
questi sono effettivamente raccomandati da Unicode (inhttp://www.unicode.org/reports/tr18>).

Questa sezione fornisce alcuni dettagli su tutte le estensioni che non sono solo sinonimi di composto-
form proprietà Unicode (per quelle proprietà, dovrai fare riferimento a Unicode
Standardhttp://www.unicode.org/reports/tr44>.

"\p{Tutti}"
Questo corrisponde a ogni possibile punto di codice. È equivalente a "qr/./s". A differenza di tutti i
altre proprietà "\p{}" non definite dall'utente corrispondono, non viene mai generato alcun avviso se questo
questa proprietà viene confrontata con un punto di codice non Unicode (vedi "Oltre il codice Unicode
punti" di seguito).

"\p{Alnum}"
Corrisponde a qualsiasi carattere "\p{Alphabetic}" o "\p{Decimal_Number}".

"\p{Qualsiasi}"
Corrisponde a uno qualsiasi dei punti di codice Unicode 1_114_112. È sinonimo di
"\p{Unicode}".

"\p{ASCII}"
Corrisponde a uno qualsiasi dei 128 caratteri nel set di caratteri US-ASCII, che è un
sottoinsieme di Unicode.

"\p{Assegnato}"
Questo corrisponde a qualsiasi punto di codice assegnato; cioè, qualsiasi punto di codice la cui categoria generale
non è "Non assegnato" (o, equivalentemente, non "Cn").

"\p{Vuoto}"
È lo stesso di "\h" e "\p{HorizSpace}": un carattere che cambia la spaziatura
orizzontalmente.

"\p{Tipo_decomposizione: Non canonico}" (Short: "\p{Dt=NonCanon}")
Corrisponde a un carattere che ha una scomposizione non canonica.

Si è parlato della sezione "Ammassi di grafemi estesi (caratteri logici)" sopra
decomposizioni canoniche. Tuttavia, molti più personaggi hanno un diverso tipo di
decomposizione, una decomposizione "compatibile" o "non canonica". Le sequenze che
tali scomposizioni non sono considerate canonicamente equivalenti alle pre-
carattere composto. Un esempio è il "SUPERSCRIPT ONE". È un po' come a
cifra normale 1, ma non esattamente; la sua scomposizione nella cifra 1 è detta a
decomposizione "compatibile", in particolare una decomposizione "super". Ce ne sono diversi
tali decomposizioni di compatibilità (vedihttp://www.unicode.org/reports/tr44>),
incluso uno chiamato "compat", che significa qualche tipo di decomposizione vario
che non rientra nelle altre categorie di scomposizione scelte da Unicode.

Nota che la maggior parte dei caratteri Unicode non ha una scomposizione, quindi la loro scomposizione
il tipo è "Nessuno".

Per tua comodità, Perl ha aggiunto il tipo di decomposizione "Non_Canonical" per significare
una delle numerose scomposizioni di compatibilità.

"\p{Grafico}"
Corrisponde a qualsiasi carattere grafico. In teoria, questo significa un personaggio che su
una stampante causerebbe l'utilizzo dell'inchiostro.

"\p{SpazioOrizzontale}"
È lo stesso di "\h" e "\p{Blank}": un carattere che cambia la spaziatura
orizzontalmente.

"\p{In=*}"
Questo è un sinonimo di "\p{Present_In=*}"

"\p{PerlSpace}"
È lo stesso di "\s", limitato ad ASCII, ovvero "[ \f\n\r\t]" e inizia in
Perl v5.18, una scheda verticale.

Mnemonico: lo spazio (originale) di Perl

"\p{PerlWord}"
È lo stesso di "\w", limitato ad ASCII, ovvero "[A-Za-z0-9_]"

Mnemonico: parola (originale) di Perl.

"\p{Posix...}"
Ci sono molti di questi, che sono equivalenti, usando la notazione "\p{}", per
classi Posix e sono descritte in "Classi di caratteri POSIX" in perlrecharclass.

"\p{Presente_In: *}" (Short: "\p{In=*}")
Questa proprietà viene utilizzata quando è necessario sapere in quale versione/i Unicode è un carattere.

L'"*" sopra sta per un numero di versione Unicode a due cifre, come 1.1 o 4.0; o
l'"*" può anche essere "Non assegnato". Questa proprietà corrisponderà ai punti di codice di cui
la disposizione finale è stata risolta a partire dal rilascio Unicode fornito dalla versione
numero; "\p{Present_In: Non assegnato}" corrisponderà a quei punti di codice il cui significato ha
ancora da assegnare.

Ad esempio, "U+0041" "LATIN CAPITAL LETTER A" era presente nel primissimo Unicode
versione disponibile, che è la 1.1, quindi questa proprietà è vera per tutte le versioni "*" valide.
D'altra parte, "U+1EFF" non è stato assegnato fino alla versione 5.1 quando è diventato "LATIN
LETTERA Y PICCOLO CON LOOP", quindi gli unici "*" che corrisponderebbero sono 5.1, 5.2 e
successivamente.

Unicode fornisce la proprietà "Age" da cui deriva. Il problema con l'età
è che una sua interpretazione rigorosa (che prende Perl) lo fa corrispondere al preciso
release viene introdotto il significato di un punto di codice. Quindi "U+0041" corrisponderebbe solo a 1.1;
e "U+1EFF" solo 5.1. Questo di solito non è quello che vuoi.

Alcune implementazioni non Perl della proprietà Age possono cambiare il suo significato per essere il
uguale alla proprietà Perl "Present_In"; basta esserne consapevoli.

Un'altra confusione con entrambe queste proprietà è che la definizione non è che il
punto di codice è stato addetto, ma che il significato del punto di codice è stato
determinato. Questo perché 66 punti di codice saranno sempre non assegnati, e quindi il
"Età" per loro è la versione Unicode in cui è stata presa la decisione di renderli tali.
Ad esempio, "U+FDD0" deve essere permanentemente non assegnato a un personaggio, e la decisione
per farlo è stato fatto nella versione 3.1, quindi "\p{Age=3.1}" corrisponde a questo carattere, come anche
fa "\p{Present_In: 3.1}" e versioni successive.

"\p{Stampa}"
Corrisponde a qualsiasi carattere grafico o vuoto, eccetto i controlli.

"\p{SpacePerl}"
Questo è lo stesso di "\s", incluso oltre ASCII.

Mnemonico: Spazio, come modificato da Perl. (Non include la scheda verticale fino a quando
v5.18, che sia lo standard Posix che Unicode considerano lo spazio bianco.)

"\p{Titolo}" e a "\p{Titolo}"
Sotto la corrispondenza con distinzione tra maiuscole e minuscole, entrambi corrispondono agli stessi punti di codice di "\p{Generale
Category=Titlecase_Letter}" ("\p{gc=lt}"). La differenza è che sotto "/i" senza maiuscole
corrispondenza, questi corrispondono allo stesso di "\p{Cased}", mentre "\p{gc=lt}" corrisponde
"\p{Cased_Letter").

"\p{Unicode}"
Corrisponde a uno qualsiasi dei punti di codice Unicode 1_114_112. "\p{Qualsiasi}".

"\p{SpazioVert}"
È lo stesso di "\v": un carattere che cambia la spaziatura in verticale.

"\p{Parola}"
È lo stesso di "\w", inclusi oltre 100_000 caratteri oltre ASCII.

"\p{XPosix...}"
Ce ne sono molti di questi, che sono le classi Posix standard estese al massimo
Gamma Unicode. Sono descritti in "Classi di caratteri POSIX" in perlrecharclass.

Definito dall'utente Carattere Properties
Puoi definire le tue proprietà dei caratteri binari definendo subroutine i cui nomi
iniziare con "In" o "È". (La funzione sperimentale "(?[ ])" in perlre fornisce un
alternativa che consente definizioni più complesse.) Le subroutine possono essere definite in qualsiasi
pacchetto. Le proprietà definite dall'utente possono essere utilizzate nell'espressione regolare "\p{}" e
costrutti "\P{}"; se stai usando una proprietà definita dall'utente da un pacchetto diverso da
uno in cui ti trovi, devi specificare il suo pacchetto nel costrutto "\p{}" o "\P{}".

# assumendo che la proprietà Is_Foreign sia definita in Lang::
pacchetto principale; # nome del pacchetto di proprietà richiesto
if ($txt =~ /\p{Lang::IsForeign}+/) { ... }

pacchetto Lang; # nome del pacchetto di proprietà non richiesto
se ($txt =~ /\p{E' estero}+/) { ... }

Nota che l'effetto è in fase di compilazione e immutabile una volta definito. Tuttavia, le subroutine
viene passato un singolo parametro, che è 0 se la corrispondenza con distinzione tra maiuscole e minuscole è attiva e non
zero se è attiva la corrispondenza senza maiuscole. La subroutine può restituire valori diversi
a seconda del valore del flag, e un insieme di valori sarà immutabilmente attivo per
tutte le corrispondenze con distinzione tra maiuscole e minuscole e l'altro impostato per tutte le corrispondenze senza distinzione tra maiuscole e minuscole.

Nota che se l'espressione regolare è contaminata, Perl morirà invece di chiamare il
subroutine quando il nome della subroutine è determinato dai dati alterati.

Le subroutine devono restituire una stringa formattata in modo speciale, con uno o più newline-
linee separate. Ogni riga deve essere una delle seguenti:

· Un singolo numero esadecimale che denota un punto di codice da includere.

· Due numeri esadecimali separati da spazi bianchi orizzontali (spazio o tabulare
caratteri) che denota un intervallo di punti di codice da includere.

· Qualcosa da includere, preceduto da "+": una proprietà di carattere incorporata (preceduta da
"utf8::") o un carattere definito dall'utente completo (incluso il nome del pacchetto)
proprietà, per rappresentare tutti i caratteri in quella proprietà; due codici esadecimali
punti per un intervallo; o un singolo punto di codice esadecimale.

· Qualcosa da escludere, preceduto da "-": una proprietà del carattere esistente (preceduta da
"utf8::") o un carattere definito dall'utente completo (incluso il nome del pacchetto)
proprietà, per rappresentare tutti i caratteri in quella proprietà; due codici esadecimali
punti per un intervallo; o un singolo punto di codice esadecimale.

· Qualcosa da negare, preceduto da "!": una proprietà del carattere esistente (preceduta da
"utf8::") o un carattere definito dall'utente completo (incluso il nome del pacchetto)
proprietà, per rappresentare tutti i caratteri in quella proprietà; due codici esadecimali
punti per un intervallo; o un singolo punto di codice esadecimale.

· Qualcosa con cui intersecare, preceduto da "&": una proprietà del carattere esistente (prefisso
da "utf8::") o un carattere definito dall'utente completo (incluso il nome del pacchetto)
proprietà, per tutti i caratteri tranne i caratteri nella proprietà; Due
punti di codice esadecimale per un intervallo; o un singolo punto di codice esadecimale.

Ad esempio, per definire una proprietà che copra entrambi i sillabari giapponesi (hiragana e
katakana), puoi definire

sub InKana {
ritorno <
3040\t309F
30A0\t30FF
FINE
}

Immagina che l'indicatore di fine here-doc sia all'inizio della riga. Ora puoi usare
"\p{InKana}" e "\P{InKana}".

Avresti potuto anche utilizzare i nomi delle proprietà dei blocchi esistenti:

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

Supponiamo di voler abbinare solo i caratteri allocati, non gli intervalli di blocchi grezzi: in
in altre parole, vuoi rimuovere i caratteri non assegnati:

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

La negazione è utile per definire (sorpresa!) classi negate.

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

Ciò corrisponderà a tutti i punti di codice non Unicode, poiché ognuno di essi non è in Kana. Voi
può utilizzare l'intersezione per escluderli, se lo si desidera, come mostra questo esempio modificato:

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

&utf8::Qualsiasi deve essere l'ultima riga nella definizione.

L'intersezione viene generalmente utilizzata per ottenere i caratteri comuni abbinati a due (o più)
classi. È importante ricordare di non usare "&" per il primo set; sarebbe
intersecano con niente, risultando in un insieme vuoto.

A differenza delle corrispondenze di proprietà "\p{}" non definite dall'utente, non viene mai generato alcun avviso se queste
le proprietà vengono confrontate con un punto di codice non Unicode (vedi "Oltre i punti di codice Unicode"
sotto).

Definito dall'utente Custodie Mapping (Per grave hacker solo)
Si caratteristica ha stato rimosso as of Perl 5.16 Il modulo CPAN "Unicode::Casing" fornisce
migliore funzionalità senza gli inconvenienti che questa caratteristica aveva. Se stai usando un Perl
prima della 5.16, questa funzione era documentata in modo più completo nella versione 5.14 di questo pod:
<http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hacker-only%29>

Carattere codifiche per Ingresso e a Uscita
Vedere Codifica.

Unicode Regular Espressione Assistenza Livello
Il seguente elenco di funzionalità supportate da Unicode per le espressioni regolari descrive tutto
funzionalità attualmente direttamente supportate dal core Perl. I riferimenti al "Livello N" e al
i numeri di sezione si riferiscono allo standard tecnico Unicode n. 18, "Unicode Regular
Expressions", versione 13, da agosto 2008.

· Livello 1 - Supporto Unicode di base

RL1.1 Notazione esadecimale - completata [1]
Proprietà RL1.2 - fatto [2][3]
Proprietà di compatibilità RL1.2a - fatto [4]
RL1.3 Sottrazione e Intersezione - sperimentale [5]
RL1.4 Limiti di parole semplici - fatto [6]
RL1.5 Incontri semplici sciolti - fatto [7]
Confini della linea RL1.6 - MANCANTE [8][9]
RL1.7 Punti Codice Supplementare - fatto [10]

[1] "\N{U+...}" e "\x{...}"
[2] "\p{...}" "\P{...}"
[3] supporta non solo l'elenco minimo, ma tutte le proprietà dei caratteri Unicode (vedi Unicode
Proprietà del carattere sopra)
[4] "\d" "\D" "\s" "\S" "\w" "\W" "\X" "[:puntello:]" "[:^prop:]"
[5] La funzione sperimentale a partire dalla v5.18 "(?[...])" realizza questo.
Vedere "(?[ ])" in perlre. Se non vuoi utilizzare una funzione sperimentale, puoi
utilizzare uno dei seguenti:

· Previsione dell'espressione regolare

Puoi imitare la sottrazione di classe usando lookahead. Ad esempio, quale UTS#18
potrebbe scrivere come

[{Blocco=greco}-[{NON ASSEGNATO}]]

in Perl può essere scritto come:

(?!\p{Non assegnato})\p{Blocco=Greco}
(?=\p{Assegnato})\p{Blocco=Greco}

Ma in questo particolare esempio, probabilmente vuoi davvero

\p{greco}

che corrisponderà ai caratteri assegnati noti per essere parte della scrittura greca.

· Modulo CPAN "Unicode::Regex::Set"

Implementa l'intero raggruppamento, intersezione, unione e rimozione UTS#18
(sottrazione) sintassi.

· "Proprietà dei caratteri definite dall'utente"

"+" per unione, "-" per rimozione (set-difference), "&" per intersezione

[6] "\b" "\B"
[7] Nota che Perl esegue la piegatura completa dei casi in corrispondenza, non in modo semplice:
Ad esempio "U+1F88" è equivalente a "U+1F00 U+03B9", anziché solo "U+1F80".
Questa differenza è importante principalmente per alcune lettere maiuscole greche con certe
modificatori: il Case-folding completo scompone la lettera, mentre il case-folding Semplice
la piegatura lo mapperebbe su un singolo carattere.

[8] Perl tratta "\n" come delimitatore di inizio e fine riga. Unicode specifica di più
personaggi che dovrebbero essere così interpretati.
Questi sono:

VT U+000B (\v in Do)
FF U+000C (\f)
CR U+000D (\r)
NEL U+0085
LS U+2028
PSU+2029

"^" e "$" nei modelli di espressioni regolari dovrebbero corrispondere a tutti questi, ma
non farlo. Anche questi caratteri non influiscono, ma dovrebbero, su "<>" $. e sulla riga di script
numeri.

Inoltre, le righe non devono essere divise all'interno di "CRLF" (cioè non ci sono righe vuote tra
"\r" e "\n"). Per "CRLF", prova il livello ":crlf" (vedi PerlIO).

[9] Ma "Unicode::LineBreak" è disponibile.
Questo modulo fornisce l'interruzione di linea conforme a UAX#14 "Unicode Line Breaking
Algoritmo"http://www.unicode.org/reports/tr14>.

[10] UTF-8/UTF-EBDDIC utilizzato in Perl consente non solo da "U+10000" a "U+10FFFF" ma anche
oltre "U+10FFFF"
· Livello 2 - Supporto Unicode esteso

Equivalenti canonici RL2.1 - MANCANTE [10][11]
RL2.2 Cluster Grapheme predefiniti - MANCANTE [12]
RL2.3 Limiti di parole predefiniti - FATTO [14]
RL2.4 Partite perse predefinite - MANCANTE [15]
Proprietà del nome RL2.5 - FATTO
RL2.6 Proprietà caratteri jolly - MANCANTE

[10] vedere UAX#15 "Moduli di normalizzazione Unicode"
[11] hanno Unicode::Normalizza ma non integrato nelle espressioni regolari
[12] hanno \X e \b{gcb} ma non abbiamo un "Grapheme Cluster
Modalità"
[14] vedere UAX#29, Confini delle parole
[15] Questo è trattato nel Capitolo 3.13 (in Unicode 6.0)

· Livello 3 - Supporto su misura

RL3.1 Punteggiatura personalizzata - MANCANTE
RL3.2 Cluster di grafemi su misura - MANCANTE [17][18]
RL3.3 Confini di parole su misura - MANCANTE
RL3.4 Partite libere personalizzate - MANCANTE
Gamma su misura RL3.5 - MANCANTE
RL3.6 Corrispondenza del contesto - MANCANTE [19]
RL3.7 Partite incrementali - MANCANTE
( RL3.8 Condivisione set Unicode )
RL3.9 Possibili Match Set - MANCANTE
RL3.10 Abbinamento piegato - MANCANTE [20]
RL3.11 Submatchers - MANCANTE

[17] vedere UAX#10 "Algoritmi di confronto Unicode"
[18] hanno Unicode::Fascicola ma non integrato nelle espressioni regolari
[19] hanno (?<=x) e (?=x), ma guarda avanti o guarda indietro
dovrebbe vedere al di fuori della sottostringa di destinazione
[20] necessitano di corrispondenze insensibili per caratteristiche linguistiche altro
del caso; per esempio, da hiragana a katakana, largo e
Han stretto e semplificato all'Han tradizionale (vedi UTR#30
"Caratteri pieghevoli")

Unicode codifiche
I caratteri Unicode sono assegnati a codice punti, che sono numeri astratti. Per usare questi
numeri, sono necessarie varie codifiche.

·UTF-8

UTF-8 è una codifica indipendente dall'ordine dei byte a lunghezza variabile (da 1 a 4 byte). Nella maggior parte dei casi
della documentazione di Perl, incluso altrove in questo documento, il termine "UTF-8" significa
anche "UTF-EBCDIC". Ma in questa sezione, "UTF-8" si riferisce solo alla codifica utilizzata su
Piattaforme ASCII. È un superset di US-ASCII a 7 bit, quindi qualsiasi cosa codificata in ASCII ha
la rappresentazione identica quando codificata in UTF-8.

La tabella seguente è tratta da Unicode 3.2.

Codice Punti 1° Byte 2° Byte 3° Byte 4° Byte

U+0000..U+007F 00..7F
U+0080..U+07FF * C2..DF 80..BF
U+0800..U+0FFF E0 * A0..BF 80..BF
U+1000..U+CFFF E1..EC 80..BF 80..BF
U+D000..U+D7FF ED 80..9F 80..BF
U+D800..U+DFFF +++++ utf16 surrogati, non legali utf8 +++++
U+E000..U+FFFF EE..EF 80..BF 80..BF
U+10000..U+3FFFF F0 * 90..BF 80..BF 80..BF
U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
U+100000..U+10FFFF F4 80..8F 80..BF 80..BF

Notare gli spazi contrassegnati da "*" prima di molte delle voci di byte sopra. Questi sono
causato da UTF-8 legale evitando codifiche non brevi: è tecnicamente possibile
UTF-8-codifica un singolo punto di codice in modi diversi, ma ciò è esplicitamente vietato,
e dovrebbe essere sempre usata la codifica più breve possibile (ed è quello che fa Perl).

Un altro modo per vederlo è tramite bit:

Codice Punti 1° Byte 2° Byte 3° Byte 4° Byte

0aaaaaaaaaaaaaa
00000bbbbaaaaaa 110bbbbb 10aaaaaa
ccccbbbbbbaaaaa 1110cccc 10bbbbbb 10aaaaaa
00000ggdccccccbbbbbbaaaaaa 11110gg 10cccccc 10bbbbbb 10aaaaaa

Come puoi vedere, i byte di continuazione iniziano tutti con "10" e i bit iniziali di
il byte iniziale dice quanti byte ci sono nel carattere codificato.

La specifica UTF-8 originale consentiva fino a 6 byte, per consentire la codifica dei numeri
fino a "0x7FFF_FFFF". Perl continua a consentirli e lo ha esteso fino a 13
i byte per codificare il codice puntano a ciò che può essere contenuto in una parola a 64 bit. Tuttavia, Perl lo farà
avvisa se emetti qualcuno di questi come non portatile; e sotto stretto input UTF-8
protocolli, sono vietati.

· UTF-EBCDIC

Come UTF-8, ma sicuro per EBCDIC, nel modo in cui UTF-8 è sicuro per ASCII. Questo significa che tutto
i caratteri di base (che include tutti quelli che hanno equivalenti ASCII (come "A",
"0", "%", ecc.) sono gli stessi sia in EBCDIC che in UTF-EBCDIC.)

UTF-EBCDIC è utilizzato sulle piattaforme EBCDIC. I punti di codice Unicode più grandi richiedono 5 byte
per rappresentare (invece di 4 in UTF-8), e Perl lo estende a un massimo di 7 byte per
encode pode punta a ciò che può stare in una parola a 32 bit (invece di 13 byte e a
parola a 64 bit in UTF-8).

· UTF-16, UTF-16BE, UTF-16LE, surrogati e "BOM" (Byte Order Mark)

I seguenti elementi sono principalmente per riferimento e conoscenza generale di Unicode, Perl
non usa questi costrutti internamente.

Come UTF-8, UTF-16 è una codifica a larghezza variabile, ma dove UTF-8 utilizza codice a 8 bit
unità, UTF-16 utilizza unità di codice a 16 bit. Tutti i punti di codice occupano 2 o 4 byte in
UTF-16: i punti di codice "U+0000..U+FFFF" sono memorizzati in una singola unità a 16 bit e il codice
punti "U+10000..U+10FFFF" in due unità a 16 bit. Quest'ultimo caso sta usando surrogati,
la prima unità a 16 bit è la alto surrogato, e il secondo è il Basso
surrogato.

I surrogati sono punti di codice messi da parte per codificare l'intervallo "U+10000..U+10FFFF" di
Il codice Unicode punta in coppie di unità a 16 bit. Il alto surrogati sono la gamma
"U+D800..U+DBFF" e il Basso surrogati sono l'intervallo "U+DC00..U+DFFF". il surrogato
la codifica è

$ciao = ($uni - 0x10000) / 0x400 + 0xD800;
$lo = ($uni - 0x10000) % 0x400 + 0xDC00;

e la decodifica è

$uni = 0x10000 + ($ciao - 0xD800) * 0x400 + ($lo - 0xDC00);

A causa dei 16 bit, UTF-16 dipende dall'ordine dei byte. È possibile utilizzare lo stesso UTF-16
per i calcoli in memoria, ma se è richiesta l'archiviazione o il trasferimento, UTF-16BE
(big-endian) o UTF-16LE (little-endian) devono essere scelte.

Questo introduce un altro problema: cosa succede se sai solo che i tuoi dati sono UTF-16, ma
non sai quale endianness? I byte Order Mark, o "BOM", sono una soluzione per
questo. Un carattere speciale è stato riservato in Unicode per funzionare come ordine di byte
marker: il carattere con il punto di codice "U+FEFF" è la "BOM".

Il trucco è che se leggi una "BOM", saprai l'ordine dei byte, poiché se lo fosse
scritto su una piattaforma big-endian, leggerai i byte "0xFE 0xFF", ma se lo fosse
scritto su una piattaforma little-endian, leggerete i byte "0xFF 0xFE". (E se il
la piattaforma di origine stava scrivendo nella piattaforma ASCII UTF-8, leggerai i byte
"0xEF 0xBB 0xBF".)

Il modo in cui funziona questo trucco è che il carattere con il punto di codice "U+FFFE" non lo è
dovrebbe essere nei flussi di input, quindi la sequenza di byte "0xFF 0xFE" non è ambigua
""BOM", rappresentato in formato little-endian" e non può essere "U+FFFE", rappresentato in
formato big-endian".

I surrogati non hanno alcun significato in Unicode al di fuori del loro uso in coppia per rappresentare altri
punti di codice. Tuttavia, Perl consente loro di essere rappresentati individualmente internamente, per
esempio dicendo "chr(0xD801)", in modo che tutti i codici puntino, non solo quelli validi per
interscambio aperto, sono rappresentabili. Unicode definisce la semantica per loro, come
la loro "General_Category" è "Cs". Ma poiché il loro uso è alquanto pericoloso, Perl
avviserà (usando la categoria di avviso "surrogato", che è una sottocategoria di "utf8")
se si tenta di fare cose come prendere la minuscola di uno o far corrispondere le maiuscole-
in modo insensibile, o per emetterli. (Ma non provarlo su Perls prima della 5.14).

· UTF-32, UTF-32BE, UTF-32LE

La famiglia UTF-32 è più o meno simile alla famiglia UTF-16, tranne per il fatto che le unità sono
32 bit e quindi lo schema surrogato non è necessario. UTF-32 è una larghezza fissa
codifica. Le firme "BOM" sono "0x00 0x00 0xFE 0xFF" per BE e "0xFF 0xFE 0x00
0x00" per LE.

· UCS-2, UCS-4

Codifiche legacy a larghezza fissa definite dallo standard ISO 10646. UCS-2 è un 16 bit
codifica. A differenza di UTF-16, UCS-2 non è estensibile oltre "U+FFFF", perché non lo fa
utilizzare surrogati. UCS-4 è una codifica a 32 bit, funzionalmente identica a UTF-32 (la
la differenza è che UCS-4 non vieta né surrogati né code point più grandi di
"0x10_FFFF").

·UTF-7

Una codifica sicura a sette bit (non a otto bit), utile se il trasporto o l'archiviazione
non è sicuro a otto bit. Definito da RFC 2152.

non carattere codice punti
66 punti di codice sono messi da parte in Unicode come "punti di codice non di carattere". Questi hanno tutti il
"Non assegnato" ("Cn") "General_Category", e nessun carattere verrà mai assegnato a nessuno dei
loro. Sono i 32 punti di codice tra "U+FDD0" e "U+FDEF" inclusi, e il 34
punti di codice:

U+FFFE U+FFFF
U+1FFFF U+1FFFF
U+2FFFF U+2FFFF
...
U+EFFFE U+EFFFF
U+FFFFF U+FFFFF
U+10FFFF U+10FFFF

Fino a Unicode 7.0, i non caratteri erano "vietato per l'uso in interscambio aperto di
Dati di testo Unicode", in modo che il codice che ha elaborato quei flussi possa utilizzare questi punti di codice
come sentinelle che potrebbero essere mescolate ai dati del personaggio, e lo sarebbero sempre
distinguibile da quel dato. (Il corsivo sopra e il paragrafo successivo sono aggiunti in
questo documento.)

Unicode 7.0 ha cambiato la formulazione in modo che siano "non è un raccomandato per l'uso all'aperto
interscambio di dati di testo Unicode". Lo standard 7.0 continua dicendo:

"Se un non carattere viene ricevuto in uno scambio aperto, non è richiesta una domanda per
interpretarlo in alcun modo. È buona norma, tuttavia, riconoscerlo come un
non carattere e di intraprendere le azioni appropriate, come sostituirlo con "U+FFFD"
carattere sostitutivo, per indicare il problema nel testo. Non è consigliabile
eliminare semplicemente i punti di codice non di carattere da tale testo, a causa del potenziale
problemi di sicurezza causati dall'eliminazione di caratteri non interpretati. (Vedi clausola di conformità
C7 nella Sezione 3.2, Requisiti di conformità e Rapporto tecnico Unicode n. 36,
"Considerazioni sulla sicurezza Unicode"
<http://www.unicode.org/reports/tr36/#Sostituzione_per_Ill_Formed_Subsequences>)."

Questa modifica è stata apportata perché è stato riscontrato che vari strumenti commerciali come editor o
per cose come il controllo del codice sorgente, era stato scritto in modo che non potessero gestire
file di programma che utilizzavano questi punti di codice, precludendo di fatto il loro utilizzo quasi
interamente! E questo non è mai stato l'intento. Sono sempre stati pensati per essere utilizzabili all'interno
una domanda, o un insieme di domande cooperanti, a piacimento.

Se stai scrivendo codice, come un editor, dovrebbe essere in grado di gestirne qualsiasi
Dati di testo Unicode, quindi non dovresti utilizzare questi punti di codice da solo, e invece
consentirli in ingresso. Se hai bisogno di sentinelle, dovrebbero invece essere qualcosa che
non è legale Unicode. Per i dati UTF-8, puoi utilizzare i byte 0xC1 e 0xC2 come sentinelle, come
non compaiono mai in UTF-8 ben formato. (Ci sono equivalenti per UTF-EBCDIC). Puoi
memorizza anche i tuoi punti di codice Unicode in variabili intere e usa valori negativi come
sentinelle.

Se non stai scrivendo uno strumento del genere, allora se accetti i non caratteri come input dipende da
voi (anche se lo Standard consiglia di non farlo). Se esegui un controllo rigoroso del flusso di input
con Perl, questi punti di codice continuano ad essere vietati. Questo è per mantenere indietro
compatibilità (altrimenti potrebbero aprirsi potenziali falle di sicurezza, come ignari
applicazione che è stata scritta presumendo che i non caratteri sarebbero stati filtrati prima
raggiungerlo, potrebbe ora, senza preavviso, iniziare a ottenerli). Per fare un controllo rigoroso,
puoi usare il livello ":encoding('UTF-8')".

Perl continua ad avvisare (usando la categoria di avviso "nonchar", che è una sottocategoria di
"utf8") se si tenta di restituire caratteri non caratteri.

Al di là di Unicode codice punti
Il punto di codice Unicode massimo è "U+10FFFF" e Unicode definisce solo le operazioni sul codice
indica attraverso quello. Ma Perl lavora sui punti di codice fino al massimo consentito
numero non firmato disponibile sulla piattaforma. Tuttavia, Perl non li accetterà dall'input
stream a meno che non vengano utilizzate regole lassiste e avviserà (usando la categoria di avviso
"non_unicode", che è una sottocategoria di "utf8"), se presente.

Poiché le regole Unicode non sono definite su questi punti di codice, se un'operazione definita da Unicode
viene eseguito su di essi, Perl utilizza quelle che riteniamo siano regole sensate, mentre generalmente avverte,
utilizzando la categoria "non_unicode". Ad esempio, "uc("\x{11_0000}")" genererà tale
avviso, restituendo il parametro di input come risultato, poiché Perl definisce il maiuscolo di
ogni punto di codice non Unicode per essere il punto di codice stesso. (Tutto il caso cambia
le operazioni, non solo le maiuscole, funzionano in questo modo.)

La situazione con le proprietà Unicode corrispondenti nelle espressioni regolari, "\p{}" e
I costrutti "\P{}", contro questi punti di codice non sono così chiari, e come questi sono
gestito è cambiato man mano che abbiamo acquisito esperienza.

Una possibilità è trattare qualsiasi corrispondenza con questi punti di codice come non definita. Ma dal momento che
Perl non ha il concetto di una corrispondenza indefinita, lo converte in fallimento o
"FALSO". Questo è quasi, ma non del tutto, ciò che Perl ha fatto dalla v5.14 (quando si usano questi codici
i punti sono diventati generalmente affidabili) fino alla v5.18. La differenza è che Perl ha trattato tutto
"\p{}" corrisponde a esito negativo, ma tutti i "\P{}" corrispondono a esito positivo.

Un problema con questo è che porta a risultati imprevisti e confusi in alcuni
casi:

chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # Fallito su <= v5.18
chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # Fallito! su <= v5.18

Cioè, ha trattato entrambe le corrispondenze come non definite e le ha convertite in false (alzando a
avviso su ciascuno). Il primo caso è il risultato atteso, ma il secondo è probabile
controintuitivo: "Come potrebbero essere entrambi falsi quando sono complementi?" Un altro problema
era che l'implementazione aveva già ottimizzato molte corrispondenze di proprietà Unicode
operazioni esistenti più semplici e veloci, che non generano l'avvertimento. Abbiamo scelto di non rinunciare
quelle ottimizzazioni, che aiutano la stragrande maggioranza delle partite, solo per generare un avviso
per l'improbabile eventualità che venga confrontato un punto di codice superiore a Unicode.

Come risultato di questi problemi, a partire dalla v5.20, ciò che fa Perl è trattare non Unicode
il codice indica solo i tipici caratteri Unicode non assegnati e corrisponde di conseguenza.
(Nota: Unicode ha punti di codice non assegnati atipici. Ad esempio, ha un codice non di caratteri
punti, e quelli che, una volta assegnati, sono destinati ad essere scritti Right-to-
sinistra, come lo sono l'arabo e l'ebraico. Perl presuppone che nessun punto di codice non Unicode ne abbia
proprietà atipiche.)

Perl, nella maggior parte dei casi, genererà un avviso quando corrisponde a un punto di codice Unicode sopra
contro una proprietà Unicode quando il risultato è "TRUE" per "\p{}" e "FALSE" per "\P{}".
Per esempio:

chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # Fallisce, nessun avviso
chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # Riesce, con avviso

In entrambi questi esempi, il carattere che viene abbinato non è Unicode, quindi Unicode no
definire come dovrebbe corrispondere. Chiaramente non è una cifra esadecimale ASCII, quindi il primo esempio
chiaramente dovrebbe fallire, e così fa, senza preavviso. Ma è discutibile che il secondo
esempio dovrebbe avere un risultato indefinito, quindi "FALSO". Quindi viene lanciato un avvertimento per questo.

Quindi l'avvertimento viene lanciato per molti meno casi rispetto ai precedenti Perls, e solo quando cosa
il risultato potrebbe essere discutibile. Si scopre che nessuna delle ottimizzazioni fatte da Perl
(o è probabile che venga mai fatto) fa sì che l'avviso venga saltato, quindi risolve entrambi
problemi del precedente approccio di Perl. La proprietà più comunemente usata che è influenzata da
questa modifica è "\p{Unassigned}" che è una forma abbreviata per
"\p{General_Category=Non assegnato}". A partire dalla v5.20, tutti i punti di codice non Unicode sono
considerato "non assegnato". Nelle versioni precedenti le partite fallivano perché il risultato era
considerato indefinito.

L'unico posto in cui l'avvertimento non viene lanciato quando avrebbe dovuto essere è se
le ottimizzazioni fanno sì che l'intera corrispondenza del modello non venga nemmeno tentata. Ad esempio, Perl
potrebbe capire che affinché una stringa corrisponda a un certo modello di espressione regolare, la stringa
deve contenere la sottostringa "foobar". Prima di tentare la partita, Perl potrebbe cercare
quella sottostringa e, se non viene trovata, fallisce immediatamente la corrispondenza senza effettivamente provarla;
quindi non viene generato alcun avviso anche se la stringa contiene un punto di codice sopra Unicode.

Questo comportamento è più "Fai ciò che intendo" rispetto ai precedenti Perls per la maggior parte delle applicazioni. Ma
rileva meno problemi per il codice che deve essere rigorosamente conforme a Unicode. Dunque
è disponibile un'ulteriore modalità di funzionamento per accogliere tale codice. Questa modalità è
abilitato se viene compilato un modello di espressione regolare all'interno dell'ambito lessicale in cui il
La classe di avviso "non_unicode" è stata resa fatale, ad esempio da:

usa gli avvisi FATAL => "non_unicode"

(vedi avvertenze). In questa modalità operativa, Perl solleverà l'avviso per tutte le corrispondenze
contro un punto di codice non Unicode (non solo quelli discutibili), e salta il
ottimizzazioni che potrebbero impedire la visualizzazione dell'avviso. (Attualmente ancora non lo farà
avvisa se la partita non viene nemmeno tentata, come nell'esempio "foobar" sopra.)

In sintesi, Perl ora normalmente tratta i punti di codice non Unicode come tipici Unicode non assegnati
punti di codice per le corrispondenze di espressioni regolari, generando un avviso solo quando è discutibile
quale dovrebbe essere il risultato. Tuttavia, se questo avvertimento è stato reso fatale, non lo è
saltato.

C'è un'eccezione a tutto questo. "\p{All}" sembra una proprietà Unicode, ma è una
Estensione Perl che è definita come vera per tutti i possibili punti di codice, Unicode o meno, quindi
non viene mai generato alcun avviso quando si confronta questo con un punto di codice non Unicode. (Prima
alla v5.20, era un sinonimo esatto di "\p{Any}", corrispondendo ai punti di codice da 0 a 0x10FFFF.)

Sicurezza Implicazioni of Unicode
Innanzitutto, leggi Considerazioni sulla sicurezza di Unicodehttp://www.unicode.org/reports/tr36>.

Inoltre, tieni presente quanto segue:

· UTF-8 non valido

Sfortunatamente, la specifica originale di UTF-8 lascia spazio all'interpretazione
di quanti byte di output codificato si dovrebbe generare da un input Unicode
carattere. A rigor di termini, la sequenza più breve possibile di byte UTF-8 dovrebbe essere
generato, perché altrimenti c'è il potenziale per un overflow del buffer di input al
ricezione dell'estremità di una connessione UTF-8. Perl genera sempre la lunghezza minima UTF-8,
e con gli avvisi attivi, Perl avviserà della lunghezza non più breve UTF-8 insieme ad altri
malformazioni, come i surrogati, che non sono punti di codice Unicode validi per
interscambio.

· La corrispondenza dei modelli di espressioni regolari potrebbe sorprenderti se non sei abituato
Unicode. A partire da Perl 5.14, sono disponibili diversi modificatori di pattern da controllare
questo, chiamato i modificatori del set di caratteri. I dettagli sono forniti in "Set di caratteri
modificatori" in perlre.

Come discusso altrove, Perl ha un piede (due zoccoli?) piantato in ciascuno dei due mondi: il
vecchio mondo di ASCII e locali a byte singolo e il nuovo mondo di Unicode, aggiornamento quando
necessario. Se il tuo codice legacy non utilizza in modo esplicito Unicode, nessun passaggio automatico
a Unicode dovrebbe accadere.

Unicode in Perl on EBCDIC
Unicode è supportato sulle piattaforme EBCDIC. Vedi perlebcdic.

A meno che non vengano discussi specificamente problemi ASCII vs. EBCDIC, i riferimenti a UTF-8
la codifica in questo documento e altrove dovrebbe essere letta come UTF-EBCDIC su EBCDIC
piattaforme. Vedere "Unicode e UTF" in perlebcdic.

Poiché UTF-EBCDIC è così simile a UTF-8, le differenze sono per lo più nascoste;
"use utf8" (e NON qualcosa come "use utfebcdic") dichiara che lo script è nel
codifica "nativa" a 8 bit della piattaforma di Unicode. (Analogamente per il livello ":utf8".)

Locale
Vedi "Unicode e UTF-8" in perllocale

Quando Unicode Le normative No Accadere
Ci sono ancora molti posti in cui Unicode (in una codifica o in un'altra) potrebbe essere dato come
argomenti o ricevuti come risultati, o entrambi in Perl, ma non lo è, nonostante Perl abbia
modi estesi per l'input e l'output in Unicode e alcuni altri "punti di ingresso" come il
@ARGV array (che a volte può essere interpretato come UTF-8).

Le seguenti sono tali interfacce. Inoltre, vedere "Il "bug Unicode"". Per tutti questi
interfacce Perl attualmente (a partire dalla v5.16.0) assume semplicemente stringhe di byte sia come argomenti
e risultati, o stringhe UTF-8 se è stato utilizzato il pragma "encoding" (deprecato).

Una ragione per cui Perl non tenta di risolvere il ruolo di Unicode in queste situazioni
è che le risposte dipendono fortemente dal sistema operativo e dai file system.
Ad esempio, se i nomi dei file possono essere in Unicode e esattamente in che tipo di codifica, è
non esattamente un concetto portatile. Allo stesso modo per "qx" e "sistema": quanto bene sarà il
"interfaccia a riga di comando" (e quale di esse?) gestisce Unicode?

· "chdir", "chmod", "chown", "chroot", "exec", "link", "lstat", "mkdir", "rename",
"rmdir", "stat", "symlink", "truncate", "unlink", "utime", "-X"

· %ENV

· "glob" (noto anche come "<*>")

· "open", "opendir", "sysopen"

· "qx" (noto anche come operatore di backtick), "sistema"

· "readdir", "readlink"

Le "Unicode Insetto"
Il termine "bug Unicode" è stato applicato a un'incoerenza con i punti di codice nel
Blocco "Latin-1 Supplement", ovvero tra 128 e 255. Senza una localizzazione specificata,
a differenza di tutti gli altri caratteri o punti di codice, questi caratteri possono essere molto diversi
semantica a seconda delle regole in vigore. (Caratteri i cui punti di codice sono superiori a 255
forzare le regole Unicode; mentre le regole per i caratteri ASCII sono le stesse in entrambi ASCII
e regole Unicode.)

Nelle regole Unicode, questi caratteri latini1 superiori vengono interpretati come punti di codice Unicode,
il che significa che hanno la stessa semantica dei controlli Latin-1 (ISO-8859-1) e C1.

Come spiegato in "Regole ASCII contro Regole Unicode", sotto le regole ASCII, sono considerate
essere caratteri non assegnati.

Questo può portare a risultati imprevisti. Ad esempio, la semantica di una stringa può improvvisamente
cambia se viene aggiunto un punto di codice superiore a 255, che cambia le regole da ASCII a
Unicode. Ad esempio, considera il seguente programma e il suo output:

$ perl -le'
nessuna caratteristica 'unicode_strings';
$s1 = "\xC2";
$s2 = "\x{2660}";
per ($s1, $s2, $s1.$s2) {
stampa /\w/ || 0;
}
'
0
0
1

Se non c'è "\w" in "s1" né in "s2", perché la loro concatenazione ne ha uno?

Questa anomalia deriva dal tentativo di Perl di non disturbare i vecchi programmi che non usavano
Unicode, insieme al desiderio di Perl di aggiungere il supporto Unicode senza problemi. Ma il risultato
si è rivelato non perfetto. (A proposito, puoi scegliere di essere avvisato quando cose come
questo accada. Vedere "codifica::avvisi".)

"usa la funzionalità 'unicode_strings'" è stata aggiunta, a partire da Perl v5.12, per risolvere questo problema
problema. Influisce su queste cose:

· Cambiare il caso di uno scalare, cioè usando "uc()", "ucfirst()", "lc()", e
"lcfirst()", o "\L", "\U", "\u" e "\l" in contesti con virgolette doppie, come normale
sostituzioni di espressioni

Sotto "unicode_strings" a partire da Perl 5.12.0, vengono generalmente utilizzate le regole Unicode.
Vedere "lc" in perlfunc per i dettagli su come funziona in combinazione con vari altri
pragma.

· Utilizzo della corrispondenza delle espressioni regolari senza maiuscole e minuscole ("/i").

A partire da Perl 5.14.0, le espressioni regolari compilate nell'ambito di
"unicode_strings" usa le regole Unicode anche quando viene eseguito o compilato in regolari più grandi
espressioni al di fuori del campo di applicazione.

· Corrispondenza di una qualsiasi delle diverse proprietà nelle espressioni regolari.

Queste proprietà sono "\b" (senza parentesi graffe), "\B" (senza parentesi graffe), "\s", "\S", "\w",
"\W", e tutte le classi di caratteri Posix con l’esclusione di "[[:ascii:]]".

A partire da Perl 5.14.0, le espressioni regolari compilate nell'ambito di
"unicode_strings" usa le regole Unicode anche quando viene eseguito o compilato in regolari più grandi
espressioni al di fuori del campo di applicazione.

· In "quotemeta" o nel suo equivalente in linea "\Q".

A partire da Perl 5.16.0, vengono utilizzate regole di quotazione coerenti nell'ambito di
"unicode_strings", come descritto in "quotemeta" in perlfunc. Prima o fuori
il suo ambito, nessun punto di codice superiore a 127 è citato nelle stringhe con codifica UTF-8, ma in byte
stringhe codificate, i punti di codice tra 128-255 sono sempre citati.

Puoi vedere da quanto sopra che l'effetto di "unicode_strings" è aumentato su diversi
Rilasci di Perl. (E il supporto di Perl per Unicode continua a migliorare; è meglio usare il
ultima versione disponibile al fine di ottenere i risultati più completi e accurati possibili.)
Nota che "unicode_strings" viene scelto automaticamente se "usi 5.012" o versioni successive.

Per Perls precedenti a quelli descritti sopra, o quando una stringa viene passata a una funzione
al di fuori dell'ambito di "unicode_strings", vedere la sezione successiva.

forzatura Unicode in Perl (O unforcing Unicode in Perla)
A volte (vedi "Quando Unicode non si verifica" o "Il bug Unicode") ci sono situazioni
dove devi semplicemente forzare una stringa di byte in UTF-8 o viceversa. Lo standard
modulo Encode può essere usato per questo, o le chiamate di basso livello "utf8::upgrade($bytestring)"
e "utf8::downgrade($utf8string[, FAIL_OK])".

Nota che "utf8::downgrade()" può fallire se la stringa contiene caratteri che non si adattano
in un byte.

Chiamare una delle due funzioni su una stringa che è già nello stato desiderato non è possibile.

"Regole ASCII contro regole Unicode" fornisce tutti i modi in cui una stringa viene creata per utilizzare Unicode
regole.

utilizzando Unicode in XS
Vedere "Supporto Unicode" in perlguts per un'introduzione a Unicode a livello XS, e
"Supporto Unicode" in perlapi per i dettagli dell'API.

Hacking Perl a lavoro on prima Unicode versioni (Per molto grave hacker solo)
Perl per impostazione predefinita viene fornito con l'ultima versione Unicode supportata integrata, ma l'obiettivo è
per consentirti di cambiare per utilizzarne uno precedente. In Perls v5.20 e v5.22, tuttavia,
la prima versione utilizzabile è Unicode 5.1. Perl v5.18 è in grado di gestire tutto in precedenza
versioni.

Scarica i file nella versione desiderata di Unicode dal sito Web Unicode
<http://www.unicode.org>). Questi dovrebbero sostituire i file esistenti in lib/unicore nel
Albero dei sorgenti Perl. Segui le istruzioni in LEGGIMI.perl in quella directory per cambiarne alcuni
dei loro nomi, e poi compilate perl (vedi INSTALLA).

porting codice da perl-5.6.X
Perl a partire dalla 5.8 hanno un modello Unicode diverso dalla 5.6. In 5.6 il programmatore era
richiesto di utilizzare il pragma "utf8" per dichiarare che un determinato ambito dovrebbe essere affrontato
Dati Unicode e doveva assicurarsi che solo i dati Unicode raggiungessero quell'ambito. Se tu
se hai un codice che funziona con 5.6, avrai bisogno di alcune delle seguenti modifiche
il tuo codice. Gli esempi sono scritti in modo tale che il codice continuerà a funzionare sotto 5.6, quindi
dovresti essere sicuro di provarli.

· Un filehandle che dovrebbe leggere o scrivere UTF-8

se ($] > 5.008) {
binmode $fh, ":encoding(utf8)";
}

· Uno scalare che verrà passato a qualche estensione

Che si tratti di "Compress::Zlib", "Apache::Request" o di qualsiasi estensione di cui non si fa menzione
Unicode nella manpage, devi assicurarti che il flag UTF8 sia rimosso. Nota
che al momento in cui scrivo (gennaio 2012) i moduli citati non lo sono
A conoscenza di UTF-8. Si prega di controllare la documentazione per verificare se questo è ancora vero.

se ($] > 5.008) {
richiedere la codifica;
$val = Codifica::encode_utf8($val); # crea ottetti
}

· Uno scalare ottenuto da un'estensione

Se ritieni che lo scalare torni come UTF-8, molto probabilmente vorrai il flag UTF8
restaurato:

se ($] > 5.008) {
richiedere la codifica;
$val = Codifica::decode_utf8($val);
}

· Stessa cosa, se sei veramente sicuro che sia UTF-8

se ($] > 5.008) {
richiedere la codifica;
Codifica::_utf8_on($val);
}

· Un wrapper per DBI "fetchrow_array" e "fetchrow_hashref"

Quando il database contiene solo UTF-8, una funzione o un metodo wrapper è un modo conveniente
per sostituire tutte le tue chiamate "fetchrow_array" e "fetchrow_hashref". Una funzione wrapper
semplificherà inoltre l'adattamento ai futuri miglioramenti del driver del database. Nota
che al momento della stesura di questo documento (gennaio 2012), il DBI non ha un modo standardizzato per farlo
gestire i dati UTF-8. Si prega di controllare la documentazione DBI per verificare se è ancora
vero.

riga di recupero secondaria {
# $che cos'è uno di fetchrow_{array,hashref}
mio($sé, $qlc, $cosa) = @_;
se ($] < 5.008) {
ritorna $qlc->$cosa;
} Else {
richiedere la codifica;
se (ricerca) {
mio @arr = $qlc->$cosa;
per (@arr) {
definito && /[^\000-\177]/ && Codifica::_utf8_on($_);
}
ritorna @arr;
} Else {
il mio $ret = $qc->$cosa;
se (rif $ret) {
per il mio $k (chiavi %$ret) {
definito
&& /[^\000-\177]/
&& Codifica::_utf8_on($_) per $ret->{$k};
}
restituisci $ret;
} Else {
definito && /[^\000-\177]/ && Encode::_utf8_on($_) per $ret;
restituisci $ret;
}
}
}
}

· Un grande scalare che sai può contenere solo ASCII

Gli scalari che contengono solo ASCII e sono contrassegnati come UTF-8 a volte sono un ostacolo per il tuo
programma. Se riconosci una situazione del genere, rimuovi semplicemente il flag UTF8:

utf8::downgrade($val) se $] > 5.008;

Usa perlunicode online usando i servizi onworks.net