perluniintro - Online în cloud

PROGRAM:

NUME

perluniintro - Introducere Perl Unicode

DESCRIERE

Acest document oferă o idee generală despre Unicode și despre cum se utilizează Unicode în Perl. Vedea
„Resurse suplimentare” pentru referințe la tratamente mai aprofundate ale Unicode.

Unicode
Unicode este un standard de set de caractere care intenționează să codifice toate sistemele de scriere ale
lumea, plus multe alte simboluri.

Unicode și ISO/IEC 10646 sunt standarde coordonate care unifică aproape toate celelalte standarde moderne
standarde de set de caractere, care acoperă peste 80 de sisteme de scriere și sute de limbi,
inclusiv toate limbile moderne importante din punct de vedere comercial. Toate personajele în cea mai mare
Dicționarele chineză, japoneză și coreeană sunt, de asemenea, codificate. Standardele vor fi în cele din urmă
acoperă aproape toate caracterele în peste 250 de sisteme de scriere și mii de limbi.
Unicode 1.0 a fost lansat în octombrie 1991 și 6.0 în octombrie 2010.

Un Unicode caracter este o entitate abstractă. Nu este legat de un anumit întreg
lățime, în special nu la limbajul C „char”. Unicode este neutru din punct de vedere al limbii și afișare-
neutru: nu codifică limba textului și, în general, nu definește
fonturi sau alte detalii de aspect grafic. Unicode operează pe caractere și pe text construit
din acele personaje.

Unicode definește caractere precum „LICITERA LATINA MAIUSCULĂ A” sau „LITERA MINUSCULĂ GRECĂ ALPHA” și
numere unice pentru caractere, în acest caz 0x0041 și, respectiv, 0x03B1. Aceste
se numesc numere unice cod puncte. Un punct de cod este în esență poziția
caracter în setul tuturor caracterelor Unicode posibile și, prin urmare, în Perl, termenul
ordinal este adesea folosit interschimbabil cu acesta.

Standardul Unicode preferă utilizarea notației hexazecimale pentru punctele de cod. Dacă numerele
ca 0x0041 nu vă sunt familiare, aruncați o privire la o secțiune ulterioară, „Notație hexazecimală”.
Standardul Unicode folosește notația „U+0041 LITERA MAJUSCULĂ LATINĂ A”, pentru a da
punctul de cod hexazecimal și denumirea normativă a personajului.

Unicode definește, de asemenea, diverse proprietăţi pentru caractere, cum ar fi „majuscule” sau
„minuscule”, „cifră zecimală” sau „punctuație”; aceste proprietăți sunt independente de
numele personajelor. În plus, diverse operațiuni asupra personajelor ca
sunt definite scrierea cu majuscule, litere mici și colatarea (sortarea).

Un Unicode logic „personaj” poate consta de fapt din mai multe interne curent
„caracter” sau punct de cod. Pentru limbile occidentale, acest lucru este modelat adecvat de a de bază
caracter (cum ar fi „LITERA MAJUSCULĂ LATINĂ A”) urmată de una sau mai multe modificatori (ca
„COMBINAREA ACCENTULUI ACUT”). Această secvență de caractere de bază și modificatori se numește a
combinând caracter secvenţă. Unele limbi non-occidentale necesită modele mai complicate,
așa că Unicode a creat grafem grup concept, care a fost ulterior rafinat în
extins grafem grup. De exemplu, o silabă coreeană Hangul este considerată o singură
caracter logic, dar cel mai adesea constă din trei caractere Unicode reale: un lider
consoană urmată de o vocală interioară urmată de o consoană de urmă.

Dacă să numiți aceste clustere de grafeme extinse „caractere” depinde de punctul dvs
vedere. Dacă sunteți programator, probabil că veți avea tendința de a vedea fiecare element din
secvențe ca o singură unitate sau „caracter”. Totuși, din punctul de vedere al utilizatorului, întregul
secvența ar putea fi văzută ca un singur „personaj”, deoarece probabil așa arată în
contextul limbajului utilizatorului. În acest document, luăm punctul de vedere al programatorului:
un „caracter” este un punct de cod Unicode.

Pentru unele combinații de caracter de bază și modificatori, există precompus caractere.
Există un singur caracter echivalent, de exemplu, pentru secvența „LATIN CAPITAL
SCRISOAREA A" urmată de "COMBINAREA ACCENTULUI ACUT". Se numește "LICITERA MAJUSCULĂ A LATINĂ
CU ACUT". Aceste caractere precompuse sunt, totuși, disponibile doar pentru unii
combinații și sunt menite în principal să accepte conversii dus-întors între Unicode și
standarde vechi (cum ar fi ISO 8859). Utilizarea secvențelor, așa cum face Unicode, permite necesitatea
mai puține blocuri de bază (puncte de cod) pentru a exprima mai multe potențiale grafeme
clustere. Pentru a sprijini conversia între forme echivalente, diverse normalizare formulare sunt
de asemenea definit. Astfel, „MAJUSCULA LATINA A CU ACUT” se află în Normalizare Formă
Compusă, (abreviat NFC) și secvența „LITERA MAJUSCULĂ LATINĂ A” urmată de
„COMBINING ACCENT ACCENT” reprezintă același caracter în Normalizare Formă Descompus
(NFD).

Datorită compatibilității cu vechile codificări, „un număr unic pentru fiecare
Ideea caracterului” se defectează puțin: în schimb, există „cel puțin un număr pentru fiecare
caracter". Acelaşi personaj ar putea fi reprezentat diferit în mai multe moşteniri
codificări. Reversul nu este adevărat: unele puncte de cod nu au un caracter alocat.
În primul rând, există puncte de cod nealocate în blocurile utilizate altfel. În al doilea rând, acolo
sunt caractere speciale de control Unicode care nu reprezintă caractere adevărate.

Când Unicode a fost conceput pentru prima dată, se credea că toate personajele lumii ar putea fi
reprezentat folosind un cuvânt de 16 biți; adică maxim 0x10000 (sau 65,536) caractere
este necesar, de la 0x0000 la 0xFFFF. Acest lucru s-a dovedit curând a fi greșit, și de la Unicode 2.0
(iulie 1996), Unicode a fost definit până la 21 de biți (0x10FFFF) și Unicode
3.1 (martie 2001) a definit primele caractere peste 0xFFFF. Primele 0x10000 de caractere
sunt numite Plan 0, Sau pachet de bază Poliglot Plan (BMP). Cu Unicode 3.1, 17 (da,
șaptesprezece) avioane în total au fost definite - dar nu sunt nici pe departe pline de definite
personaje, încă.

Când o nouă limbă este codificată, Unicode va alege, în general, un „bloc” de
puncte de cod consecutive nealocate pentru caracterele sale. Până acum, numărul de puncte de cod
în aceste blocuri a fost întotdeauna divizibil egal cu 16. Extra într-un bloc, nu în prezent
necesare, sunt lăsate nealocate, pentru creșterea viitoare. Dar au existat ocazii când a
Lansarea ulterioară a avut nevoie de mai multe puncte de cod decât suplimentele disponibile și un nou bloc a trebuit
alocat în altă parte, nu învecinat cu cel inițial, pentru a gestiona depășirea.
Astfel, a devenit evident de la început că „blocul” nu era un principal organizator adecvat,
și astfel a fost creată proprietatea „Script”. (Mai târziu a fost adăugată o proprietate de script îmbunătățită ca
Ei bine, proprietatea „Script_Extensions”.) Acele puncte de cod care sunt în blocuri de overflow
pot avea în continuare același script ca și cele originale. Conceptul de scenariu se potrivește mai bine
cu limbaj natural: există grafie „latină”, scriere „greacă” și așa mai departe; și sunt
mai multe scripturi artificiale, cum ar fi „Common” pentru caracterele care sunt folosite în mai multe
scripturi, cum ar fi simbolurile matematice. Scripturile acoperă de obicei părți variate din mai multe
blocuri. Pentru mai multe informații despre scripturi, consultați „Scripturi” în perlunicode. Divizia
în blocuri există, dar este aproape complet accidental - un artefact al modului în care
caracterele au fost și sunt încă alocate. (Rețineți că acest paragraf are
lucruri suprasimplificate de dragul ca aceasta să fie o introducere. Unicode nu prea
codifică limbaje, dar sistemele de scriere pentru ele - scripturile lor; și un script poate fi
folosit de multe limbi. Unicode codifică, de asemenea, lucruri care nu sunt cu adevărat despre limbi,
precum simboluri precum „REVENIRE BAGAJ”.)

Punctele de cod Unicode sunt doar numere abstracte. Pentru a introduce și scoate aceste abstracte
numere, numerele trebuie să fie codificat or serializat oarecum. Unicode definește mai multe
caracter codare formulare, Din care UTF-8 este cel mai popular. UTF-8 este o lungime variabilă
codificare care codifică caracterele Unicode de la 1 la 4 octeți. Alte codificări includ UTF-16
și UTF-32 și variantele lor mari și mici (UTF-8 este independent de ordinea octetilor).
ISO/IEC 10646 definește formele de codificare UCS-2 și UCS-4.

Pentru mai multe informații despre codificări, de exemplu, pentru a afla ce înlocuitori si octet
comandă mărci (BOM) sunt - vezi perlunicod.

a lui Perl Unicode Asistență
Începând cu Perl v5.6.0, Perl a avut capacitatea de a gestiona Unicode în mod nativ. Perl
v5.8.0, totuși, este prima versiune recomandată pentru lucrări Unicode serioase. The
Versiunea de întreținere 5.6.1 a remediat multe dintre problemele Unicode-ului inițial
implementare, dar, de exemplu, expresiile regulate încă nu funcționează cu Unicode în
5.6.1. Perl v5.14.0 este prima versiune în care suportul Unicode este (aproape) perfect
integrabil fără unele probleme (excepția fiind unele diferențe în quotemeta și
care este remediat începând cu Perl 5.16.0). Pentru a activa acest suport perfect, ar trebui să „utilizați
caracteristica „unicode_strings”” (care este selectată automat dacă „utilizați 5.012” sau mai mare).
Vezi caracteristica. (5.14 remediază, de asemenea, o serie de erori și abateri de la standardul Unicode.)

Înainte de Perl v5.8.0, utilizarea „use utf8” a fost folosită pentru a declara că operațiunile din
blocul sau fișierul curent ar fi conștient de Unicode. Acest model a fost considerat a fi greșit, sau la
cel mai puțin stângace: „Unicodeness” este acum purtat cu datele, în loc să fie atașat la
operațiunile. Începând cu Perl v5.8.0, rămâne un singur caz în care un „utilizare” explicit
utf8" este necesar: dacă scriptul dvs. Perl în sine este codificat în UTF-8, puteți utiliza UTF-8 în
nume de identificare și în șir de caractere și expresii regulate, spunând „utilizați utf8”.
Aceasta nu este implicită, deoarece scripturile cu date vechi de 8 biți s-ar rupe. Vedea
utf8.

a lui Perl Unicode Modele Usi
Perl acceptă atât șiruri de caractere pre-5.6 de octeți nativi de opt biți, cât și șiruri de caractere Unicode
personaje. Principiul general este că Perl încearcă să-și păstreze datele ca octeți de opt biți
cât mai mult timp posibil, dar de îndată ce Unicodeness nu poate fi evitat, datele sunt
upgrade transparent la Unicode. Înainte de Perl v5.14.0, upgrade-ul nu a fost complet
transparent (a se vedea „„Eroarea Unicode”” în perlunicode) și pentru compatibilitate inversă,
transparența totală nu este câștigată decât dacă „utilizați caracteristica „unicode_strings”” (vezi caracteristica) sau
„Utilizați 5.012” (sau mai mare) este selectat.

Pe plan intern, Perl utilizează în prezent fie oricare setul de caractere nativ de opt biți al
platforma (de exemplu Latin-1) este, implicit la UTF-8, pentru a codifica șiruri Unicode.
Mai exact, dacă toate punctele de cod din șir sunt 0xFF sau mai puțin, Perl folosește nativul
set de caractere pe opt biți. În caz contrar, folosește UTF-8.

În mod normal, unui utilizator de Perl nu trebuie să știe și nici să-i pese cum se întâmplă să îl codifice Perl
șiruri interne, dar devine relevant atunci când scoateți șiruri Unicode într-un flux
fără un strat PerlIO (unul cu codificarea „implicit”). Într-un astfel de caz, octeții bruti
folosit intern (setul de caractere nativ sau UTF-8, după caz ​​pentru fiecare șir).
să fie utilizat și un avertisment „Caractere larg” va fi emis dacă acele șiruri conțin a
caracter peste 0x00FF.

De exemplu,

perl -e „printează „\x{DF}\n”, „\x{0100}\x{DF}\n”’

produce un amestec destul de inutil de octeți nativi și UTF-8, precum și un avertisment:

Caracter larg imprimat la...

Pentru a scoate UTF-8, utilizați stratul de ieșire „:encoding” sau „:utf8”. În prealabil

binmode(STDOUT, ":utf8");

la acest program exemplu se asigură că rezultatul este complet UTF-8 și elimină
avertismentul programului.

Puteți activa automatizarea UTF-8 a mânerelor de fișiere standard, implicit „open()”
strat și @ARGV folosind fie comutatorul de linie de comandă „-C”, fie „PERL_UNICODE”
variabilă de mediu, consultați perlrun pentru documentația comutatorului „-C”.

Rețineți că aceasta înseamnă că Perl se așteaptă ca alt software să funcționeze în același mod: dacă Perl are
a fost făcut să creadă că STDIN ar trebui să fie UTF-8, dar apoi STDIN care vine de la altul
comanda nu este UTF-8, Perl se va plânge probabil de UTF-8 malformat.

Toate caracteristicile care combină Unicode și I/O necesită, de asemenea, utilizarea noii caracteristici PerlIO.
Cu toate acestea, aproape toate platformele Perl 5.8 folosesc PerlIO: puteți vedea dacă a dvs. este de
rulează „perl -V” și caută „useperlio=define”.

Unicode si EBCDIC
Perl 5.8.0 a adăugat suport pentru Unicode pe platformele EBCDIC. Acest sprijin i sa permis
expiră în versiunile ulterioare, dar a fost reînviat în 5.22. Suportul Unicode este ceva mai mult
complex de implementat, deoarece sunt necesare conversii suplimentare. Vezi perlebcdic pentru mai multe
informaţii.

Pe platformele EBCDIC, forma internă de codificare Unicode este UTF-EBCDIC în loc de UTF-8.
Diferența este că, deoarece UTF-8 este „sigur pentru ASCII”, caracterele ASCII codifică în UTF-8
așa cum este, în timp ce UTF-EBCDIC este „EBCDIC sigur”, prin aceea că toate caracterele de bază (care includ
toate cele care au echivalente ASCII (cum ar fi „A”, „0”, „%”, etc) sunt aceleași în ambele
EBCDIC și UTF-EBCDIC. Adesea, documentația va folosi termenul „UTF-8” pentru a însemna UTF-EBCDIC
de asemenea. Acesta este cazul în acest document.

Crearea Unicode
Această secțiune se aplică pe deplin pentru Perls începând cu v5.22. Diverse avertismente pentru mai devreme
versiunile sunt în subsecțiunea „Avertismente privind versiunile anterioare” de mai jos.

Pentru a crea caractere Unicode în literale, utilizați notația „\N{...}” între ghilimele duble
siruri de caractere:

my $smiley_from_name = "\N{FATĂ ALBĂ ZÂMBĂTORĂ}";
my $smiley_from_code_point = "\N{U+263a}";

În mod similar, ele pot fi utilizate în expresii literale regulate

$smiley =~ /\N{FATA ALBĂ ZÂMBĂTORĂ}/;
$smiley =~ /\N{U+263a}/;

În timpul execuției, puteți utiliza:

folosiți denumiri ();
meu $hebrew_alef_from_name
= charnames::string_vianame("SCRISOARE EBRAICA ALEF");
my $hebrew_alef_from_code_point = charnames::string_vianame("U+05D0");

Desigur, „ord()” va face invers: transformă un caracter într-un punct de cod.

Există și alte opțiuni de rulare. Puteți folosi „pack()”:

my $hebrew_alef_from_code_point = pack("U", 0x05d0);

Sau puteți folosi „chr()”, deși este mai puțin convenabil în cazul general:

$hebrew_alef_from_code_point = chr(utf8::unicode_la_nativ(0x05d0));
utf8::upgrade($hebrew_alef_from_code_point);

„utf8::unicode_to_native()” și „utf8::upgrade()” nu sunt necesare dacă argumentul este
peste 0xFF, deci cele de mai sus ar fi putut fi scrise ca

$hebrew_alef_from_code_point = b.c(0x05d0);

deoarece 0x5d0 este peste 255.

„\x{}” și „\o{}” pot fi, de asemenea, folosite pentru a specifica punctele de cod în timpul compilării în format dublu.
șiruri de caractere ghilițe, dar, pentru compatibilitatea cu Perls mai vechi, se aplică aceleași reguli ca
cu „chr()” pentru punctele de cod mai mici de 256.

„utf8::unicode_to_native()” este folosit pentru ca codul Perl să fie portabil pe platformele EBCDIC.
Puteți să o omiteți dacă sunteți într-adevăr sigur că nimeni nu va dori vreodată să-ți folosească codul pe un alt
Platforma ASCII. Începând cu Perl v5.22, apelurile către acesta pe platformele ASCII sunt optimizate,
deci nu există nicio penalizare de performanță în adăugarea lui. Sau pur și simplu îl poți folosi pe celălalt
constructii care nu o necesita.

Consultați „Resurse suplimentare” pentru a afla cum să găsiți toate aceste nume și coduri numerice.

Mai devreme Comunicate limitări

Pe platformele EBCDIC, înainte de v5.22, utilizarea „\N{U+...}” nu funcționează corect.

Înainte de v5.16, folosirea „\N{...}” cu un nume de caracter (spre deosebire de un punct de cod „U+...”)
a cerut un „utilizați nume de caractere :full”.

Înainte de v5.14, existau câteva erori în „\N{...}” cu un nume de caracter (spre deosebire de un
"U+..." punct de cod).

„charnames::string_vianame()” a fost introdus în v5.14. Înainte de asta,
„charnames::vianame()” ar trebui să funcționeze, dar numai dacă argumentul este de forma „U+...”. Ta
Cel mai bun pariu acolo pentru runtime Unicode după numele caracterului este probabil:

folosiți denumiri ();
meu $hebrew_alef_from_name
= pack("U", charnames::vianame("SCRISOARE EBRAICA ALEF"));

Manipularea Unicode
Manipularea Unicode este în cea mai mare parte transparentă: utilizați doar șirurile ca de obicei.
Funcții precum „index()”, „length()” și „substr()” vor funcționa pe caracterele Unicode;
expresiile regulate vor funcționa pe caracterele Unicode (vezi perlunicode și perlretut).

Rețineți că Perl consideră clusterele de grafeme ca fiind caractere separate, deci, de exemplu

lungime de tipărire ("\N{LETERA MAJUSCULĂ LATINE A}\N{COMBINAREA ACCENTUL ACUT}"),
„\n”;

va imprima 2, nu 1. Singura excepție este că expresiile regulate au „\X” pentru
potrivirea unui cluster de grafeme extins. (Astfel, „\X” într-o expresie regulată s-ar potrivi cu
întreaga secvență a ambelor caractere exemplu.)

Viața nu este chiar atât de transparentă, totuși, atunci când lucrați cu codificări vechi, I/O și
anumite cazuri speciale:

Moştenire Codificări
Când combinați date vechi și Unicode, datele vechi trebuie să fie actualizate la Unicode.
În mod normal, se presupune că datele moștenite sunt ISO 8859-1 (sau EBCDIC, dacă este cazul).

Modulul „Codificare” știe despre multe codificări și are interfețe pentru a face conversii
între acele codificări:

utilizați Encode „decode”;
$date = decode("iso-8859-3", $date); # convertiți din moștenire în utf-8

Unicode I / O
În mod normal, scrieți date Unicode

print FH $some_string_with_unicode, "\n";

produce octeți bruti pe care Perl se întâmplă să îi folosească pentru a codifica intern șirul Unicode.
Codificarea internă a lui Perl depinde de sistem, precum și de caracterele în care se află
sfoara la momentul respectiv. Dacă vreunul dintre caractere se află la punctele de cod 0x100 sau mai sus, dvs
va primi un avertisment. Pentru a vă asigura că rezultatul este redat în mod explicit în codificarea dvs
dorinta - si pentru a evita avertismentul - deschide fluxul cu codificarea dorita. niste
exemple:

deschide FH, ">:utf8", "fișier";

deschide FH, ">:encoding(ucs2)", "fișier";
deschide FH, „>:encoding(UTF-8)”, „fișier”;
deschide FH, ">:encoding(shift_jis)", "fișier";

iar pe fluxurile deja deschise, utilizați „binmode()”:

binmode(STDOUT, ":utf8");

binmode(STDOUT, ":encoding(ucs2)");
binmode(STDOUT, ":encoding(UTF-8)");
binmode(STDOUT, ":encoding(shift_jis)");

Potrivirea numelor de codificare este liberă: majusculele nu contează și multe codificări au
mai multe pseudonime. Rețineți că stratul „:utf8” trebuie întotdeauna specificat exact așa;
este nu sub rezerva potrivirii libere a numelor de codificare. De asemenea, rețineți că în prezent
„:utf8” este nesigur pentru intrare, deoarece acceptă datele fără a valida acest lucru
într-adevăr valid UTF-8; ar trebui să utilizați în schimb „:encoding(utf-8)” (cu sau fără cratima).

Vedeți PerlIO pentru stratul „:utf8”, PerlIO::encoding și Encode::PerlIO pentru
Stratul „:encoding()” și Encode::Supportat pentru multe codificări acceptate de „Encode”
modul.

Citirea unui fișier despre care știți că se întâmplă să fie codificat într-unul dintre Unicode sau moștenire
codificări nu transformă în mod magic datele în Unicode în ochii lui Perl. Pentru a face asta,
specificați stratul corespunzător la deschiderea fișierelor

deschide(my $fh,'<:encoding(utf8)', 'orice');
my $line_of_unicode = <$fh>;

deschide(my $fh,'<:encoding(Big5)', 'orice');
my $line_of_unicode = <$fh>;

Straturile I/O pot fi, de asemenea, specificate mai flexibil cu pragma „deschisă”. Vezi deschis, sau
uită-te la următorul exemplu.

utilizați open ':encoding(utf8)'; # va fi codificarea implicită de intrare/ieșire
# UTF-8
deschide X, ">fișier";
tipăriți X b.c(0x100), „\n”;
închide X;
deschide Y,"
printf „%#x\n”, ord( ); # aceasta ar trebui să imprime 0x100
închide Y;

Cu pragma „deschisă” poți folosi stratul „:locale”.

BEGIN { $ENV{LC_ALL} = $ENV{LANG} = 'ru_RU.KOI8-R' }
# :locale va analiza variabilele de mediu locale cum ar fi
# LC_ALL
utilizați open OUT => ':locale'; # russki parusski
deschis(O, ">koi8");
tipăriți O b.c(0x430); # Unicode LICITĂ MINUSCULĂ CHRILICĂ A = KOI8-R 0xc1
aproape O;
deschis(eu, "
printf „%#x\n”, ord( ), „\n”; # acesta ar trebui să imprime 0xc1
aproape I;

Aceste metode instalează un filtru transparent pe fluxul I/O care convertește datele din
codificarea specificată atunci când este citită din flux. Rezultatul este întotdeauna Unicode.

Pragma deschisă afectează toate apelurile „open()” după pragma prin setarea straturilor implicite.
Dacă doriți să afectați numai anumite fluxuri, utilizați straturi explicite direct în „open()”
apel.

Puteți comuta codificările pe un flux deja deschis utilizând „binmode()”; vezi "binmode"
în perlfunc.

„:locale” nu funcționează în prezent cu „open()” și „binmode()”, doar cu „open”
pragma. Metodele „:utf8” și „:encoding(...)” funcționează cu toate „open()”,
„binmode()”, și pragma „deschisă”.

În mod similar, puteți utiliza aceste straturi I/O pe fluxurile de ieșire pentru a converti automat Unicode
la codificarea specificată atunci când este scrisă în flux. De exemplu, următoarele
snippet copiază conținutul fișierului „text.jis” (codat ca ISO-2022-JP, alias JIS) în
fișierul „text.utf8”, codificat ca UTF-8:

deschide ($nihongo meu, '<:encoding(iso-2022-jp)', 'text.jis');
deschide($unicode-ul meu, '>:utf8', 'text.utf8');
while (<$nihongo>) { print $unicode $_ }

Denumirea codificărilor, atât prin pragma „open()”, cât și prin pragma „deschisă”, permite flexibilitate
nume: „koi8-r” și „KOI8R” vor fi ambele înțelese.

Codificări comune recunoscute de ISO, MIME, IANA și diverse alte standardizări
organizațiile sunt recunoscute; pentru o listă mai detaliată, consultați Encode::Supported.

„read()” citește caractere și returnează numărul de caractere. „căută()” și „spune()”
operează pe număr de octeți, la fel ca „sysread()” și „sysseek()”.

Observați că, din cauza comportamentului implicit de a nu face nicio conversie la intrare, if
nu există un strat implicit, este ușor să scrieți din greșeală cod care continuă să se extindă a
fișier prin codificarea în mod repetat a datelor:

# AVERTISMENT DE COD RĂU
deschide F, „fișier”;
local $/; ## citit în întregul fișier de caractere de 8 biți
$t = ;
aproape F;
deschide F, ">:encoding(utf8)", "fișier";
imprima F $t; ## convertiți în UTF-8 la ieșire
aproape F;

Dacă rulați acest cod de două ori, conținutul fișierului fişier va fi de două ori codificat UTF-8. O „utilizare
open ':encoding(utf8)'" ar fi evitat eroarea sau deschiderea explicit și a fişier
pentru intrare ca UTF-8.

NOTĂ: caracteristicile „:utf8” și „:encoding” funcționează numai dacă Perl-ul tău a fost construit cu
PerlIO, care este implicit pe majoritatea sistemelor.

Afiseaza Unicode As Text
Uneori este posibil să doriți să afișați scalari Perl care conțin Unicode ca ASCII simplu (sau
EBCDIC) text. Următoarea subrutină își convertește argumentul astfel încât caracterele Unicode
cu puncte de cod mai mari de 255 sunt afișate ca „\x{...}”, caractere de control (cum ar fi
„\n”) sunt afișate ca „\x..”, iar restul caracterelor ca ele însele:

sub nice_string {
a te alatura("",
hartă { $_ > 255 # dacă caracter lat...
? sprintf("\\x{%04X}", $_) # \x{...}
: chr($_) =~ /[[:cntrl:]]/ # altfel dacă caracterul de control...
? sprintf("\\x%02X", $_) # \x..
: quotemeta(chr($_)) # else citat sau ca ei înșiși
} unpack("W*", $_[0])); # despachetează caractere Unicode
}

De exemplu,

nice_string("foo\x{100}bar\n")

returnează șirul

„foo\x{0100}bar\x0A”

care este gata de tipărit.

("\\x{}" este folosit aici în loc de "\\N{}", deoarece este cel mai probabil să doriți să vedeți ce
valorile native sunt.)

Special Cazuri
· Bit Complement Operator ~ Și vec()

Operatorul de complement de biți „~” poate produce rezultate surprinzătoare dacă este utilizat pe șiruri
care conțin caractere cu valori ordinale peste 255. Într-un astfel de caz, rezultatele sunt
în concordanță cu codificarea internă a caracterelor, dar nu cu multe altele. Asa de
nu face asta. În mod similar pentru „vec()”: veți opera pe codul intern
tipare de biți ale caracterelor Unicode, nu pe valorile punctelor de cod, ceea ce este foarte
probabil nu ceea ce vrei tu.

· O privire la codificarea internă a lui Perl

Utilizatorilor normali de Perl nu ar trebui să le pese niciodată de modul în care Perl codifică un anumit șir Unicode
(deoarece modalitățile normale de a ajunge la conținutul unui șir cu Unicode - prin intrare
și ieșirea - ar trebui să fie întotdeauna prin straturi I/O definite în mod explicit). Dar dacă trebuie,
există două moduri de a privi în culise.

O modalitate de a arunca o privire în codificarea internă a caracterelor Unicode este utilizarea
"unpack("C*", ..." pentru a obține octeții oricărei codare a șirului de caractere se întâmplă să fie, sau
"unpack("U0..", ...)" pentru a obține octeții codificării UTF-8:

# aceasta tipărește c4 80 pentru octeții UTF-8 0xc4 0x80
print join(" ", unpack("U0(H2)*", pack("U", 0x100))), "\n";

O altă modalitate ar fi să folosiți modulul Devel::Peek:

perl -MDevel::Peek -e 'Dump(b.c(0x100))'

Aceasta arată steagul „UTF8” în FLAGS și atât octeții UTF-8, cât și caracterele Unicode în
„PV”. Vezi și mai târziu în acest document discuția despre „utf8::is_utf8()”
Funcția.

Avansat subiecte
· Echivalența șirurilor

Problema echivalenței șirurilor devine oarecum complicată în Unicode: ce faci
adică prin „egal”?

(Este „MAJUSCULA LATINA A CU ACUTA” egală cu „LITERA MAJUSCULĂ LATINA A”?)

Răspunsul scurt este că, implicit, Perl compară echivalența ("eq", "ne") numai pe baza
pe punctele de cod ale personajelor. În cazul de mai sus, răspunsul este nu (deoarece 0x00C1
!= 0x0041). Dar, uneori, orice litere majuscule A ar trebui considerate egale, sau chiar
A din orice caz.

Răspunsul lung este că trebuie să luați în considerare normalizarea caracterelor și majusculele
probleme: vezi Unicode::Normalize, Unicode Technical Report #15, Unicode Normalization
Formehttp://www.unicode.org/unicode/reports/tr15> și secțiuni despre maparea cazurilor în
standardul Unicodehttp://www.unicode.org>.

Începând cu Perl 5.8.0, plierea „completă” a carcaselor Caz Mapări/Carcasă specială is
implementate, dar erorile rămân în „qr//i” cu ele, în mare parte remediate de 5.14, și
în esență în întregime până la 5.18.

· Colaţionarea şirurilor

Oamenilor le place să-și vadă șirurile bine sortate - sau, după cum spune limbajul Unicode, colate.
Dar din nou, ce vrei să spui prin colate?

(Litera „MAJUSCULĂ LATINĂ A CU ACUT” apare înainte sau după „SITERA MAJUSCULĂ LATINĂ A
CU GRAVE"?)

Răspunsul scurt este că, implicit, Perl compară șiruri de caractere ("lt", "le", "cmp", "ge",
„gt”) bazat numai pe punctele de cod ale caracterelor. În cazul de mai sus, răspunsul
este „după”, deoarece 0x00C1 > 0x00C0.

Răspunsul lung este că „depinde”, iar un răspuns bun nu poate fi dat fără
cunoscând (cel puțin) contextul lingvistic. Vezi Unicode::Collate și Unicode
Colaționare Algoritm <http://www.unicode.org/unicode/reports/tr10/>

Diverse
· Intervale și clase de caractere

Intervalele de caractere din clasele de caractere pentru expresii regulate (de exemplu, „/[az]/”)
iar în „tr///” (cunoscut și ca „y///”) operatorul nu sunt conștienți din punct de vedere magic de Unicode.
Ceea ce înseamnă aceasta este că „[A-Za-z]” nu va începe, în mod magic, să însemne „toate alfabetice
litere" (nu că înseamnă asta chiar și pentru caractere de 8 biți; pentru acestea, dacă sunteți
folosind locale (perllocale), folosiți „/[[:alpha:]]/”; iar dacă nu, utilizați 8-bit-aware
proprietatea „\p{alpha}”).

Toate proprietățile care încep cu „\p” (și inversul său „\P”) sunt de fapt caracter
clase care sunt conștiente de Unicode. Sunt zeci de ele, vezi perluniprops.

Începând cu v5.22, puteți utiliza puncte de cod Unicode ca puncte finale ale obișnuit
intervale de caractere ale modelului de expresie, iar intervalul va include tot codul Unicode
punctele care se află între acele puncte finale, inclusiv.

qr/ [\N{U+03]-\N{U+20}] /x

include punctele de cod „\N{U+03}”, „\N{U+04}”, ..., „\N{U+20}”.

(Se plănuiește extinderea acestui comportament la intervalele din „tr///” în Perl v5.24.)

· Conversii șir în număr

Unicode definește mai multe alte caractere zecimale - și numerice - în afară de
familiar de la 0 la 9, cum ar fi cifrele arabe și indice. Perl nu acceptă string-
conversie în număr pentru alte cifre decât ASCII 0 la 9 (și ASCII „a” la „f” pentru
hexazecimal). Pentru a obține conversii sigure din orice șir Unicode, utilizați „num()„în
Unicode::UCD.

Întrebări cu răspunsuri
· Se vor rupe vechile mele scripturi?

Foarte probabil că nu. Dacă nu generați cumva caractere Unicode, vechi
comportamentul trebuie păstrat. Despre singurul comportament care s-a schimbat și care
ar putea începe să genereze Unicode este vechiul comportament al „chr()” în cazul în care furnizarea unui
argumentul mai mult de 255 a produs un caracter modulo 255. "b.c(300)”, de exemplu, a fost
egal cu "b.c(45)" sau "-" (în ASCII), acum este LITERA LATINA MAIUSCULĂ I CU BREVE.

· Cum îmi fac scripturile să funcționeze cu Unicode?

Ar trebui să fie nevoie de foarte puțină muncă, deoarece nimic nu se schimbă până când nu generați Unicode
date. Cel mai important lucru este obținerea intrării ca Unicode; pentru asta, vezi mai devreme
Discuție I/O. Pentru a obține compatibilitate completă cu Unicode, adăugați „funcția de utilizare
„unicode_strings”” (sau „utilizați 5.012” sau o versiune ulterioară) în scriptul dvs.

· Cum știu dacă șirul meu este în Unicode?

Nu ar trebui să-ți pese. Dar poți dacă Perl-ul tău este înainte de 5.14.0 sau nu
specificat „utilizați caracteristica „unicode_strings” sau „utilizați 5.012” (sau mai mare), deoarece altfel
regulile pentru punctele de cod din intervalul 128 până la 255 sunt diferite în funcție de
indiferent dacă șirul în care sunt conținute este în Unicode sau nu. (Consultați „Când Unicode
Nu se întâmplă" în perlunicode.)

Pentru a determina dacă un șir este în Unicode, utilizați:

print utf8::is_utf8($string) ? 1 : 0, „\n”;

Dar rețineți că acest lucru nu înseamnă că oricare dintre caracterele din șir sunt necesare
codificat UTF-8 sau că oricare dintre caractere are puncte de cod mai mari de 0xFF (255)
sau chiar 0x80 (128), sau că șirul are orice caracter. Toate „is_utf8()”
face este să returneze valoarea indicatorului intern „utf8ness” atașat la $string.
Dacă indicatorul este dezactivat, octeții din scalar sunt interpretați ca o codificare de un singur octet.
Dacă indicatorul este activat, octeții din scalar sunt interpretați ca (lungime variabilă,
potenţial multi-octeţi) puncte de cod codificate UTF-8 ale caracterelor. Octeți adăugați la a
Șirurile codificate UTF-8 sunt actualizate automat la UTF-8. Dacă se amestecă non-UTF-8 și
Scalarii UTF-8 sunt îmbinați (interpolare cu ghilimele duble, concatenare explicită sau
înlocuirea parametrilor printf/sprintf), rezultatul va fi codificat UTF-8 ca și cum ar fi copii
dintre șirurile de octeți au fost actualizate la UTF-8: de exemplu,

$a = "ab\x80c";
$b = „\x{100}”;
printează „$a = $b\n”;

șirul de ieșire va fi codificat UTF-8 „ab\x80c = \x{100}\n”, dar $a va rămâne byte-
codificat.

Uneori s-ar putea să aveți nevoie să știți lungimea octetului unui șir în loc de
lungimea caracterului. Pentru aceasta, utilizați fie funcția „Encode::encode_utf8()”, fie funcția
pragma „bytes” și funcția „length()”:

$unicode-ul meu = b.c(0x100);
lungimea tipăririi($unicode), „\n”; # va imprima 1
necesită codificare;
lungimea tipăririi(Encode::encode_utf8($unicode)),"\n"; # va imprima 2
utilizați octeți;
lungimea tipăririi($unicode), „\n”; # va tipări și 2
# (0xC4 0x80 al UTF-8)
fără octeți;

· Cum aflu ce codificare are un fișier?

S-ar putea să încercați Encode::Guess, dar are o serie de limitări.

· Cum detectez datele care nu sunt valide într-o anumită codificare?

Utilizați pachetul „Encode” pentru a încerca să îl convertiți. De exemplu,

utilizați Encode 'decode_utf8';

if (eval { decode_utf8($string, Encode::FB_CROAK); 1 }) {
# $șir este valid utf8
} Else {
# $șir nu este valid utf8
}

Sau folosiți „despachetați” pentru a încerca să îl decodați:

folosiți avertismente;
@chars = unpack("C0U*", $string_of_bytes_that_think_is_utf8);

Dacă nu este valid, este produs un avertisment „Caractere UTF-8 incorect”. „C0” înseamnă „proces
caracterul șir pe caracter". Fără asta, „unpack("U*", ...)" ar funcționa
în modul „U0” (implicit dacă șirul de format începe cu „U”) și ar reveni
octeții care formează codificarea UTF-8 a șirului țintă, ceva care va face
lucrează mereu.

· Cum convertesc datele binare într-o anumită codificare sau viceversa?

Acest lucru probabil nu este atât de util pe cât ați putea crede. În mod normal, nu ar trebui să fie nevoie.

Într-un sens, ceea ce cereți nu are prea mult sens: codificările sunt pentru
caracterele și datele binare nu sunt „caractere”, deci conversia „date” în unele
codificarea nu are sens decât dacă știți în ce set de caractere și codificarea
sunt date binare, caz în care nu sunt doar date binare, nu-i așa?

Dacă aveți o secvență brută de octeți despre care știți că ar trebui interpretată prin a
codificare specială, puteți folosi „Encode”:

utilizați Encode 'from_to';
de la_la($date, "iso-8859-1", "utf-8"); # de la latin-1 la utf-8

Apelul la „from_to()” modifică octeții din $data, dar nimic material despre
natura șirului s-a schimbat în ceea ce privește Perl. Și înainte și după
apelul, șirul $data conține doar o grămadă de octeți de 8 biți. În ceea ce privește Perl
în cauză, codificarea șirului rămâne ca „octeți de 8 biți nativi de sistem”.

Ați putea asocia acest lucru cu un modul fictiv „Traduceți”:

utilizați Translate;
my $frase = "Da";
Traduceți::from_to($frază, 'engleză', 'deutsch');
Fraza ## conține acum „Ja”

Conținutul șirului se modifică, dar nu și natura șirului. Perl nu
știi mai multe după apel decât înainte că conținutul șirului indică
afirmativ.

Înapoi la conversia datelor. Dacă aveți (sau doriți) date în sistemul nativ pe 8 biți
codificare (de ex. Latin-1, EBCDIC etc.), puteți folosi pack/unpack pentru a converti la/de la
Unicode.

$native_string = pack("W*", unpack("U*", $Unicode_string));
$Unicode_string = pack("U*", unpack("W*", $native_string));

Dacă aveți o secvență de octeți ști este valid UTF-8, dar Perl nu îl știe încă,
poți să-l faci și pe Perl credincios:

utilizați Encode 'decode_utf8';
$Unicode = decode_utf8($bytes);

sau:

$Unicode = pachet("U0a*", $octeți);

Puteți găsi octeții care alcătuiesc o secvență UTF-8 cu

@bytes = unpack ("C*", $Unicode_string)

și puteți crea Unicode bine format cu

$Unicode_string = pachet("U*", 0xff, ...)

· Cum afișez Unicode? Cum introduc Unicode?

Vedeahttp://www.alanwood.net/unicode/> și
<http://www.cl.cam.ac.uk/~mgk25/unicode.html>

· Cum funcționează Unicode cu localitățile tradiționale?

Dacă localitatea dvs. este un local UTF-8, începând cu Perl v5.20, Perl funcționează bine pentru toate
categorii cu excepția „LC_COLLATE” care se ocupă cu sortarea și operatorul „cmp”.

Pentru alte locații, începând cu Perl 5.16, puteți specifica

utilizați localitatea „:not_characters”;

pentru a-l face pe Perl să lucreze bine cu ei. Problema este că trebuie să traduci din
set de caractere locale către/de la Unicode. Consultați „Unicode I/O” de mai sus pentru cum se face

utilizați deschis „:locale”;

pentru a realiza acest lucru, dar detaliile complete sunt în „Unicode și UTF-8” în perllocale,
inclusiv probleme care se întâmplă dacă nu specificați „:not_characters”.

Hexazecimal Notaţie
Standardul Unicode preferă să folosească notația hexazecimală, deoarece asta arată mai clar
împărțirea Unicode în blocuri de 256 de caractere. Hexazecimalul este, de asemenea, pur și simplu mai scurt
decât zecimală. Puteți folosi și notația zecimală, dar învățați să utilizați doar hexazecimal
face viața mai ușoară cu standardul Unicode. Notația „U+HHHH” folosește hexazecimal, pentru
exemplu.

Prefixul „0x” înseamnă un număr hexazecimal, cifrele sunt 0-9 si af (sau AF, caz
nu contează). Fiecare cifră hexazecimală reprezintă patru biți sau jumătate de octet. "imprimare
0x..., „\n”” va afișa un număr hexazecimal în zecimal, iar „printf „%x\n”, $decimal” va afișa
arată un număr zecimal în hexazecimal. Dacă aveți doar „cifrele hexadecimale” ale unui hexazecimal
număr, puteți utiliza funcția „hex()”.

printează 0x0009, „\n”; #9
printează 0x000a, „\n”; # 10
printează 0x000f, „\n”; # 15
printează 0x0010, „\n”; #16
printează 0x0011, „\n”; #17
printează 0x0100, „\n”; #256

printează 0x0041, „\n”; #65

printf „%x\n”, 65; #41
printf „%#x\n”, 65; # 0x41

print hex("41"), "\n"; # 65

Mai departe Resurse
· Consorțiul Unicode

<http://www.unicode.org/>

· Întrebări frecvente Unicode

<http://www.unicode.org/unicode/faq/>

· Glosar Unicode

<http://www.unicode.org/glossary/>

· Lista de lectură recomandată Unicode

Consorțiul Unicode are o listă de articole și cărți, dintre care unele oferă mult
tratare mai aprofundată a Unicode:http://unicode.org/resources/readinglist.html>

· Resurse utile Unicode

<http://www.unicode.org/unicode/onlinedat/resources.html>

· Unicode și suport multilingv în HTML, fonturi, browsere web și alte aplicații

<http://www.alanwood.net/unicode/>

· Întrebări frecvente UTF-8 și Unicode pentru Unix/Linux

<http://www.cl.cam.ac.uk/~mgk25/unicode.html>

· Seturi de caractere moștenite

<http://www.czyborra.com/>http://www.eki.ee/letter/>

· Puteți explora diverse informații din fișierele de date Unicode utilizând
Modulul „Unicode::UCD”.

UNICODE IN MAI BATRAN PERLS

Dacă nu vă puteți actualiza Perl la 5.8.0 sau o versiune ulterioară, puteți încă să faceți ceva Unicode
procesare prin utilizarea modulelor „Unicode::String”, „Unicode::Map8” și „Unicode::Map”,
disponibil de la CPAN. Dacă ai instalat codul GNU, poți folosi și Perl
front-end „Convert::Recode” pentru conversii de caractere.

Următoarele sunt conversii rapide de la ISO 8859-1 (Latin-1) octeți la UTF-8 octeți și
înapoi, codul funcționează chiar și cu versiuni mai vechi de Perl 5.

# ISO 8859-1 la UTF-8
s/([\x80-\xFF])/chr(0xC0|ord($1)>>6).chr(0x80|ord($1)&0x3F)/eg;

# UTF-8 la ISO 8859-1
s/([\xC2\xC3])([\x80-\xBF])/chr(ord($1)<<6&0xC0|ord($2)&0x3F)/eg;

Utilizați perluniintro online folosind serviciile onworks.net