perlunicook - Online sa Cloud

PROGRAMA:

NAME

perlunicook - cookbookish na mga halimbawa ng paghawak ng Unicode sa Perl

DESCRIPTION

Ang manpage na ito ay naglalaman ng mga maiikling recipe na nagpapakita kung paano pangasiwaan ang mga karaniwang operasyon ng Unicode
sa Perl, kasama ang isang kumpletong programa sa dulo. Anumang hindi idineklara na mga variable sa indibidwal
ang mga recipe ay ipinapalagay na may dating naaangkop na halaga sa kanila.

HALIMBAWA

X 0: pamantayan preamble
Maliban kung iba ang tala, ang lahat ng mga halimbawa sa ibaba ay nangangailangan ng pamantayang preamble na ito upang gumana
tama, na may "#!" inayos upang gumana sa iyong system:

#!/usr/bin/env perlas

gumamit ng utf8; # kaya ang mga literal at identifier ay maaaring nasa UTF-8
gumamit ng v5.12; # o mas bago para makakuha ng feature na "unicode_strings".
gumamit ng mahigpit; # quote string, magdeklara ng mga variable
gumamit ng mga babala; # on bilang default
gumamit ng mga babala qw(FATAL utf8); # fatalize encoding glitches
gumamit ng open qw(:std:utf8); # na hindi nadeklarang stream sa UTF-8
gumamit ng mga charnames qw(:full :short); # hindi kailangan sa v5.16

ito ang gawin kahit ang mga programmer ng Unix na "binmode" ang iyong mga binary stream, o buksan ang mga ito gamit ang
":raw", ngunit iyon ang tanging paraan upang makuha ang mga ito nang mabilis.

BABALA: "use autodie" (pre 2.26) at "use open" hindi magkasundo.

X 1: Panlahat Unicode-savvy filter
Palaging mabulok sa pagpasok, pagkatapos ay muling buuin sa paglabas.

gumamit ng Unicode:: Normalize;

habang (<>) {
$_ = NFD($_); # decompose + muling isaayos ayon sa kanon
...
} magpatuloy {
i-print ang NFC ($_); # recompose (kung posible) + reorder canonically
}

X 2: Fine-tuning Unicode babala
Simula sa v5.14, nakikilala ng Perl ang tatlong subclass ng mga babala ng UTFX8.

gumamit ng v5.14; # na subwarning ay hindi magagamit sa anumang mas maaga
walang mga babala "nonchar"; # ang 66 na bawal na hindi karakter
walang babala "kapalit"; # UTF-16/CESU-8 kalokohan
walang babala "non_unicode"; # para sa mga codepoint na higit sa 0x10_FFFF

X 3: Magpahayag pinagmulan in utf8 para mga nagpapakilala at literal
Kung wala ang lahat-ng-kritikal na "use utf8" na deklarasyon, inilalagay ang UTFX8 sa iyong mga literal at
hindi gagana nang tama ang mga identifier. Kung ginamit mo ang karaniwang preamble na ibinigay sa itaas, ito
nangyari na. Kung ginawa mo, magagawa mo ang mga bagay tulad nito:

gumamit ng utf8;

my $measure = "Aangstroem";
my @Xsoft = qw( cp852 cp1251 cp1252 );
aking @XXXXXXXXX = qw( XXXX XXXXXX );
my @X = qw( koi8-f koi8-u koi8-r );
aking $motto = "XXX"; # PAMILYA, LUMALAKING PUSO, DROMEDARY CAMEL

Kung nakalimutan mo ang "gumamit ng utf8", ang mataas na byte ay hindi mauunawaan bilang hiwalay na mga character, at
walang gagana ng tama.

X 4: Character at Russia at ilang bansa sa Asya. numero
Ang mga function na "ord" at "chr" ay malinaw na gumagana sa lahat ng codepoint, hindi lang sa ASCII
nag-iisa X o sa katunayan, hindi lamang sa Unicode lamang.

# ASCII na character
ord("A")
chr(65)

# na character mula sa Basic Multilingual Plane
ord("X")
chr(0x3A3)

# lampas sa BMP
ord("X") # MATHEMATICAL ITALIC SMALL N
chr(0x1D45B)

# lampas sa Unicode! (hanggang MAXINT)
ord("\x{20_0000}")
chr(0x20_0000)

X 5: Unicode literal by katangian numero
Sa isang interpolated na literal, double-quoted man na string o regex, maaari mong tukuyin ang a
character sa pamamagitan ng numero nito gamit ang "\x{HHHHHH}" pagtakas.

String: "\x{3a3}"
Regex: /\x{3a3}/

String: "\x{1d45b}"
Regex: /\x{1d45b}/

# kahit na hindi BMP na saklaw sa regex ay gumagana nang maayos
/[\x{1D434}-\x{1D467}]/

X 6: Magsimula katangian pangalan by numero
gumamit ng mga charname ();
aking $name = charname::viacode(0x03A3);

X 7: Magsimula katangian numero by pangalan
gumamit ng mga charname ();
my $number = charnames::vianame("GREEK CAPITAL LETTER SIGMA");

X 8: Unicode pinangalanan character
Gamitin ang "\N{pangalan ng karakter}" notation upang makuha ang character sa pangalang iyon para magamit sa interpolated
literals (double-quoted na mga string at regexes). Sa v5.16, mayroong isang implicit

gumamit ng mga charnames qw(:full :short);

Ngunit bago ang v5.16, dapat ay tahasan mo kung aling hanay ng mga charname ang gusto mo. Ang
Ang ":full" na mga pangalan ay ang opisyal na Unicode na pangalan ng character, alias, o sequence, na ibinabahagi lahat
isang namespace.

gumamit ng mga charnames qw(:full :short latin greek);

"\N{MATHEMATICAL ITALIC SMALL N}" # :puno
"\N{GREEK CAPITAL LETTER SIGMA}" # :puno

Ang anumang bagay ay isang Perl-specific na convenience abbreviation. Tukuyin ang isa o higit pang mga script sa pamamagitan ng
mga pangalan kung gusto mo ng mga maiikling pangalan na tukoy sa script.

"\N{Greek:Sigma}" # :short
"\N{ae}" # latin
"\N{epsilon}" # greek

Sinusuportahan din ng v5.16 release ang isang ":loose" na pag-import para sa maluwag na pagtutugma ng mga pangalan ng character,
na gumagana tulad ng maluwag na pagtutugma ng mga pangalan ng ari-arian: ibig sabihin, binabalewala nito ang kaso,
whitespace, at mga salungguhit:

"\N{euro sign}" # :loose (mula sa v5.16)

X 9: Unicode pinangalanan pagkakasunud-sunod
Ang mga ito ay parang mga pangalan ng character ngunit nagbabalik ng maraming codepoint. Pansinin ang %vx
pag-andar ng vector-print sa "printf".

gumamit ng mga charnames qw(:full);
my $seq = "\N{LATIN CAPITAL LETTER A NA MAY MACRON AT LIBINGAN}";
printf "U+%v04X\n", $seq;
U + 0100.0300

X 10: Pasadya pinangalanan character
Gamitin ang ":alias" upang bigyan ang iyong sariling lexically scoped na mga palayaw sa mga umiiral nang character, o kahit na
upang bigyan ng mga hindi pinangalanang pribadong paggamit ng mga character na kapaki-pakinabang na pangalan.

gumamit ng mga charnames na ":full", ":alias" => {
ecute => "MALIIT NA LETTER E LATIN NA MAY ACUTE",
"APPLE LOGO" => 0xF8FF, # pribadong paggamit ng character
};

"\N{ecute}"
"\N{APPLE LOGO}"

X 11: pangalan of CJK mga codepoint
Nagbabalik ang mga sinogram tulad ng XXXX na may mga pangalan ng karakter ng "CJK UNIFIED IDEOGRAPH-6771" at
"CJK UNIFIED IDEOGRAPH-4EAC", dahil iba-iba ang kanilang XnamesX. Ang CPAN "Unicode::Unihan"
Ang module ay may malaking database para sa pag-decode ng mga ito (at marami pang iba), basta't alam mo
kung paano maunawaan ang output nito.

# cpan -i Unicode::Unihan
gumamit ng Unicode::Unihan;
aking $str = "XX";
my $unhan = Unicode::Unihan->new;
para sa aking $lang (qw(Mandarin Cantonese Korean JapaneseOn JapaneseKun)) {
printf "Ang CJK $str sa %-12s ay ", $lang;
sabihin $unhan->$lang($str);
}

mga kopya:

Ang CJK XX sa Mandarin ay DONG1JING1
Ang CJK XX sa Cantonese ay dung1ging1
Ang CJK XX sa Korean ay TONGKYENG
Ang CJK XX sa JapaneseOn ay TOUKYOU KEI KIN
Ang CJK XX sa JapaneseKun ay HIGASHI AZUMAMIYAKO

Kung nasa isip mo ang isang partikular na scheme ng romanization, gamitin ang partikular na module:

# cpan -i Lingua::JA::Romanize::Japanese
gumamit ng Lingua::JA::Romanize::Japanese;
my $k2r = Lingua::JA::Romanize::Japanese->new;
aking $str = "XX";
sabihin ang "Japanese para sa $str ay ", $k2r->chars($str);

mga kopya

Ang Japanese para sa XX ay toukyou

X 12: Malinaw encode/decode
Sa mga bihirang pagkakataon, tulad ng isang database read, maaari kang bigyan ng naka-encode na text na kailangan mo
mag-decode.

gamitin ang Encode qw(encode decode);

my $chars = decode("shiftjis", $bytes, 1);
# O
my $bytes = encode("MIME-Header-ISO_2022_JP", $chars, 1);

Para sa mga stream na nasa parehong pag-encode, huwag gumamit ng encode/decode; sa halip ay itakda ang file
pag-encode kapag binuksan mo ang file o kaagad pagkatapos gamit ang "binmode" tulad ng inilarawan sa ibang pagkakataon
sa ibaba.

X 13: Mabasa programa argumento as utf8
$ perl -CA ...
or
$ export PERL_UNICODE=A
or
gamitin ang Encode qw(decode_utf8);
@ARGV = mapa { decode_utf8($_, 1) } @ARGV;

X 14: Mabasa programa argumento as lokal pag-encode
# cpan -i Encode::Locale
gamitin ang Encode qw(locale);
gamitin ang Encode::Locale;

# gamitin ang "locale" bilang arg para i-encode/decode
@ARGV = mapa { decode(locale => $_, 1) } @ARGV;

X 15: Magpahayag STD{IN,OUT,ERR} sa be utf8
Gumamit ng opsyon sa command-line, variable ng kapaligiran, o kung hindi man ay tahasang tumawag sa "binmode":

$ perl -CS ...
or
$ export PERL_UNICODE=S
or
gumamit ng open qw(:std:utf8);
or
binmode(STDIN, ":utf8");
binmode(STDOUT, ":utf8");
binmode(STDERR, ":utf8");

X 16: Magpahayag STD{IN,OUT,ERR} sa be in lokal pag-encode
# cpan -i Encode::Locale
gumamit ng Encode;
gamitin ang Encode::Locale;

# o bilang isang stream para sa binmode o bukas
binmode STDIN, ": encoding(console_in)" kung -t STDIN;
binmode STDOUT, ":encoding(console_out)" kung -t STDOUT;
binmode STDERR, ":encoding(console_out)" kung -t STDERR;

X 17: gumawa file I / O default sa utf8
Ang mga file na binuksan nang walang argumento sa pag-encode ay nasa UTF-8:

$ perl -CD...
or
$ export PERL_UNICODE=D
or
gumamit ng open qw(:utf8);

X 18: gumawa lahat I / O at mga pagtatalo default sa utf8
$ perl -CSDA ...
or
$ export PERL_UNICODE=SDA
or
gumamit ng open qw(:std:utf8);
gamitin ang Encode qw(decode_utf8);
@ARGV = mapa { decode_utf8($_, 1) } @ARGV;

X 19: Pagbubukas file sa tiyak pag-encode
Tukuyin ang stream encoding. Ito ang karaniwang paraan upang makitungo sa naka-encode na teksto, hindi sa pamamagitan ng pagtawag
mababang antas ng mga pag-andar.

# input file
open(my $in_file, "< :encoding(UTF-16)", "wintext");
OR
open(my $in_file, "<", "wintext");
binmode($in_file, ": encoding(UTF-16)");
Pagkatapos
aking $line = <$in_file>;

# output file
open($out_file, "> :encoding(cp1252)", "wintext");
OR
open(my $out_file, ">", "wintext");
binmode($out_file, ": encoding(cp1252)");
Pagkatapos
i-print ang $out_file "ilang teksto\n";

Higit pang mga layer kaysa sa pag-encode lamang ang maaaring tukuyin dito. Halimbawa, ang incantation
Kasama sa ":raw :encoding(UTF-16LE) :crlf" ang implicit na paghawak sa CRLF.

X 20: Unicode pambalot
Ang Unicode casing ay ibang-iba sa ASCII casing.

uc("henry X") # "HENRY X"
uc("tschuess") # "TSCHUeSS" notice ss => SS

# pareho ang totoo:
"tschuess" =~ /TSCHUeSS/i # notice ss => SS
"XXXXXXX" =~ /XXXXXXX/i # pansinin ang pagkakapareho ng X,X,X

X 21: Unicode case-insensitive paghahambing
Available din sa CPAN Unicode::CaseFold module, ang bagong "fc" XfoldcaseX function mula sa
Ang v5.16 ay nagbibigay ng access sa parehong Unicode casefolding tulad ng mayroon ang "/i" pattern modifier
laging ginagamit:

gamitin ang tampok na "fc"; Ang # fc() function ay mula sa v5.16

# sort case-insensitively
my @sorted = sort { fc($a) cmp fc($b) } @list;

# pareho ang totoo:
fc("tschuess") eq fc("TSCHUeSS")
fc("XXXXXXXXX") eq fc("XXXXXXXXX")

X 22: Tumugma Unicode linebreak pagkakasunud-sunod in regex
Ang isang Unicode linebreak ay tumutugma sa dalawang-character na CRLF grapheme o alinman sa pitong patayo
mga character na whitespace. Mabuti para sa pagharap sa mga textfile na nagmumula sa iba't ibang operating
systems.

\R

s/\R/\n/g; # gawing normal ang lahat ng linebreak sa \n

X 23: Magsimula katangian kategorya
Hanapin ang pangkalahatang kategorya ng isang numeric codepoint.

gumamit ng Unicode::UCD qw(charinfo);
aking $cat = charinfo(0x3A3)->{category}; # "Lu"

X 24: Hindi pinapagana Unicode-awareness in builtin mga charclass
Huwag paganahin ang "\w", "\b", "\s", "\d", at ang mga klase ng POSIX na gumana nang tama sa Unicode
alinman sa saklaw na ito, o sa isang regex lamang.

gumamit ng v5.14;
gumamit ng re "/a";

# O

my($num) = $str =~ /(\d+)/a;

O gumamit ng mga partikular na un-Unicode na katangian, tulad ng "\p{ahex}" at "\p{POSIX_Digit"}. Ari-arian
gumagana pa rin nang normal kahit anong charset modifiers ("/d /u /l /a /aa") ang dapat maging epekto.

X 25: Tumugma Unicode mga katangian in regex sa \p, \P
Ang lahat ng ito ay tumutugma sa isang codepoint sa ibinigay na property. Gamitin ang "\P" sa halip na "\p" sa
tumugma sa isang codepoint na kulang sa property na iyon.

\pL, \pN, \pS, \pP, \pM, \pZ, \pC
\p{Sk}, \p{Ps}, \p{Lt}
\p{alpha}, \p{itaas}, \p{ibaba}
\p{Latin}, \p{Griyego}
\p{script=Latin}, \p{script=Greek}
\p{East_Asian_Width=Wide}, \p{EA=W}
\p{Line_Break=Hyphen}, \p{LB=HY}
\p{Numeric_Value=4}, \p{NV=4}

X 26: Pasadya katangian mga katangian
Tukuyin sa oras ng pag-compile ang iyong sariling mga katangian ng custom na character para magamit sa mga regexe.

# gamit ang mga pribadong gamit na character
sub In_Tengwar { "E000\tE07F\n" }

kung (/\p{In_Tengwar}/) { ... }

# pinaghalo ang mga umiiral nang property
sub Is_GraecoRoman_Title {<<'END_OF_SET'}
+utf8::IsLatin
+utf8::IsGreek
&utf8::IsTitle
END_OF_SET

kung (/\p{Is_GraecoRoman_Title}/ { ... }

X 27: Unicode normalisasyon
Karaniwang nagre-render sa NFD sa input at NFC sa output. Gamit ang mga function ng NFKC o NFKD
pinapabuti ang paggunita sa mga paghahanap, sa pag-aakalang nagawa mo na ang parehong tekstong hahanapin.
Tandaan na ito ay tungkol sa higit pa sa mga paunang pinagsamang compatibility glyph; ito rin
muling pag-aayos ng mga marka ayon sa kanilang kanonikal na pagsasama-sama ng mga klase at pag-aalis ng mga singleton.

gumamit ng Unicode:: Normalize;
my $nfd = NFD($orig);
my $nfc = NFC($orig);
my $nfkd = NFKD($orig);
my $nfkc = NFKC($orig);

X 28: Palitan hindi ASCII Unicode mga numero
Maliban kung gumamit ka ng "/a" o "/aa", ang "\d" ay tumutugma sa higit sa ASCII na mga digit lamang, ngunit ang mga PerlX
hindi kasalukuyang kinikilala ng implicit string-to-number conversion ang mga ito. Narito kung paano
manu-manong i-convert ang naturang mga string.

gumamit ng v5.14; # kailangan para sa num() function
gumamit ng Unicode::UCD qw(num);
my $str = "nakuha ang X at XXXX at X at dito";
aking @nums = ();
habang ($str =~ /(\d+|\N)/g) { # hindi lang ASCII!
push @nums, num ($1);
}
sabihin ang "@nums"; # 12 4567 0.875

gumamit ng mga charnames qw(:full);
my $nv = num("\N{RUMI DIGIT ONE}\N{RUMI DIGIT TWO}");

X 29: Tumugma Unicode grapema kumpol in regex
Ang XcharactersX na nakikita ng programmer ay mga codepoint na tinutugma ng "/./s", ngunit nakikita ng user
Ang XcharactersX ay mga grapheme na tinutugma ng "/\X/".

# Maghanap ng patinig *plus* anumang pinagsamang mga diacritics, underlining, atbp.
my $nfd = NFD($orig);
$nfd =~ / (?=[aeiou]) \X /xi

X 30: Kunin by grapema sa halip of by codepoint (regex)
# tumugma at kumuha ng limang unang grapheme
my($first_five) = $str =~ /^ ( \X{5} ) /x;

X 31: Kunin by grapema sa halip of by codepoint (substr)
# cpan -i Unicode::GCString
gumamit ng Unicode::GCString;
my $gcs = Unicode::GCString->new($str);
my $first_five = $gcs->substr(0, 5);

X 32: Baligtarin pisi by grapema
Ang pagbabalikwas sa pamamagitan ng codepoint ay nakakagulo sa mga diacritics, na nagkakamali sa pag-convert ng "creme brulee" sa
"eelXurb emXerc" sa halip na sa "eelurb emerc"; kaya baligtarin ng grapheme sa halip. pareho
gumagana nang tama ang mga diskarteng ito anuman ang normalisasyon ng string:

$str = sumali("", baligtarin $str =~ /\X/g);

# O: cpan -i Unicode::GCString
gumamit ng Unicode::GCString;
$str = baligtarin ang Unicode::GCString->new($str);

X 33: Pisi haba in graphemes
Ang string na "brulee" ay may anim na graphemes ngunit hanggang walong codepoints. Ito ay binibilang ng
grapheme, hindi sa pamamagitan ng codepoint:

my $str = "brulee";
ang aking $count = 0;
habang ($str =~ /\X/g) { $count++ }

# O: cpan -i Unicode::GCString
gumamit ng Unicode::GCString;
my $gcs = Unicode::GCString->new($str);
aking $count = $gcs->length;

X 34: Unicode lapad ng haligi para pag-print
Iniisip ng PerlX na "printf", "sprintf", at "format" na ang lahat ng codepoint ay tumatagal ng 1 print column, ngunit
marami ang kumukuha ng 0 o 2. Dito para ipakita na walang pinagkaiba ang normalisasyon, pareho kaming nagpi-print
mga form:

gumamit ng Unicode::GCString;
gumamit ng Unicode:: Normalize;

my @words = qw/creme brulee/;
@mga salita = mapa { NFC($_), NFD($_) } @mga salita;

para sa aking $str (@mga salita) {
my $gcs = Unicode::GCString->new($str);
aking $cols = $gcs->column;
aking $pad = " " x (10 - $cols);
sabihin ang str, $pad, " |";
}

bumubuo nito upang ipakita na ito ay tama ang pad kahit na ang normalisasyon:

creme |
creXme |
brulee |
bruXleXe |

X 35: Unicode paghahambing
Ang tekstong pinagsunod-sunod ayon sa numerong codepoint ay hindi sumusunod sa makatwirang pagkakasunod-sunod ng alpabeto; gamitin ang UCA para sa
pag-uuri ng teksto.

gumamit ng Unicode::Collate;
my $col = Unicode::Collate->new();
aking @list = $col->sort(@old_list);

Tingnan ang ucsort programa mula sa Unicode::Tussle CPAN module para sa isang maginhawang command-line
interface sa modyul na ito.

X 36: Kaso- at accent-insensitive Unicode uri
Tumukoy ng lakas ng collation ng level 1 para balewalain ang case at diacritics, tinitingnan lang ang
pangunahing karakter.

gumamit ng Unicode::Collate;
my $col = Unicode::Collate->new(level => 1);
aking @list = $col->sort(@old_list);

X 37: Unicode lokal paghahambing
May mga espesyal na panuntunan sa pag-uuri ang ilang lokal.

# gumamit ng v5.12, O: cpan -i Unicode::Collate::Locale
gumamit ng Unicode::Collate::Locale;
my $col = Unicode::Collate::Locale->new(locale => "de__phonebook");
aking @list = $col->sort(@old_list);

Ang ucsort ang program na binanggit sa itaas ay tumatanggap ng parameter na "--locale".

X 38: Paggawa "cmp" trabaho on teksto sa halip of mga codepoint
Sa halip na ito:

@srecs = uri {
$b->{AGE} <=> $a->{AGE}
||
$a->{NAME} cmp $b->{NAME}
} @recs;

Gamitin mo to:

my $coll = Unicode::Collate->new();
para sa aking $rec (@recs) {
$rec->{NAME_key} = $coll->getSortKey( $rec->{NAME} );
}
@srecs = uri {
$b->{AGE} <=> $a->{AGE}
||
$a->{NAME_key} cmp $b->{NAME_key}
} @recs;

X 39: Kaso- at accent-insensitive paghahambing
Gumamit ng collator object upang ihambing ang Unicode text ayon sa character sa halip na sa pamamagitan ng codepoint.

gumamit ng Unicode::Collate;
my $es = Unicode::Collate->new(
antas => 1,
normalisasyon => undef
);

# ngayon pareho ang totoo:
$es->eq("Garcia", "GARCIA" );
$es->eq("Marquez", "MARQUEZ");

X 40: Kaso- at accent-insensitive lokal paghahambing
Pareho, ngunit sa isang partikular na lokal.

my $de = Unicode::Collate::Locale->new(
locale => "de__phonebook",
);

# ngayon ito ay totoo:
$de->eq("tschuess", "TSCHUESS"); # notice ue => UE, ss => SS

X 41: Unicode linebreaking
Hatiin ang teksto sa mga linya ayon sa mga panuntunan ng Unicode.

# cpan -i Unicode::LineBreak
gumamit ng Unicode::LineBreak;
gumamit ng mga charnames qw(:full);

my $para = "Ito ay isang super\N{HYPHEN}mahabang string. " x 20;
my $fmt = Unicode::LineBreak->new;
print $fmt->break($para), "\n";

X 42: Unicode teksto in DBM hash, ang nakakapagod paraan
Ang paggamit ng isang regular na string ng Perl bilang isang susi o halaga para sa isang hash ng DBM ay magti-trigger ng isang malawak na character
pagbubukod kung ang anumang mga codepoint ay hindi magkasya sa isang byte. Narito kung paano manu-manong pamahalaan ang
pagsasalin:

gumamit ng DB_File;
gamitin ang Encode qw(encode decode);
itali ang %dbhash, "DB_File", "pathname";

# TINDAHAN

# assume $uni_key at $uni_value ay abstract Unicode strings
my $enc_key = encode("UTF-8", $uni_key, 1);
my $enc_value = encode("UTF-8", $uni_value, 1);
$dbhash{$enc_key} = $enc_value;

# FETCH

# ipagpalagay na ang $uni_key ay may hawak na isang normal na string ng Perl (abstract Unicode)
my $enc_key = encode("UTF-8", $uni_key, 1);
aking $enc_value = $dbhash{$enc_key};
my $uni_value = decode("UTF-8", $enc_value, 1);

X 43: Unicode teksto in DBM hash, ang madali paraan
Narito kung paano implicitly na pamahalaan ang pagsasalin; tapos na lahat ng encoding at decoding
awtomatiko, tulad ng sa mga stream na may partikular na pag-encode na naka-attach sa mga ito:

gumamit ng DB_File;
gumamit ng DBM_Filter;

my $dbobj = tie %dbhash, "DB_File", "pathname";
$dbobj->Filter_Value("utf8"); # ito ang magic bit

# TINDAHAN

# assume $uni_key at $uni_value ay abstract Unicode strings
$dbhash{$uni_key} = $uni_value;

# FETCH

Ang # $uni_key ay mayroong isang normal na string ng Perl (abstract Unicode)
aking $uni_value = $dbhash{$uni_key};

X 44: PROGRAMA: Demo of Unicode paghahambing at pag-print
HereXs isang buong programa na nagpapakita kung paano gamitin ang locale-sensitive sorting, Unicode casing,
at pamamahala sa mga lapad ng pag-print kapag ang ilan sa mga character ay tumatagal ng zero o dalawang column, hindi
isang column lang sa bawat pagkakataon. Kapag tumakbo, ang sumusunod na programa ay gumagawa nito nang maayos na nakahanay
output:

Creme Brulee....... X2.00
Eclair............. X1.60
Fideua............. X4.20
Hamburger.......... X6.00
Jamon Serrano...... X4.45
Linguica........... X7.00
Pate............... X4.15
Mga peras.............. X2.00
Peches............. X2.25
Smorbrod.......... X5.75
Spaetzle............ X5.50
Xorico............. X3.00
XXXXX.............. X6.50
XXX............. X4.00
XXX............. X2.65
XXXXX......... X8.00
XXXXXXX..... X1.85
XX............... X9.99
XX............... X7.50

Narito ang programang iyon; sinubukan sa v5.14.

#!/usr/bin/env perlas
# umenu - demo sorting at printing ng Unicode food
#
# (obligado at lalong mahaba ang preamble)
#
gumamit ng utf8;
gumamit ng v5.14; # para sa locale sorting
gumamit ng mahigpit;
gumamit ng mga babala;
gumamit ng mga babala qw(FATAL utf8); # fatalize encoding faults
gumamit ng open qw(:std:utf8); # na hindi nadeklarang stream sa UTF-8
gumamit ng mga charnames qw(:full :short); # hindi kailangan sa v5.16

# std module
gumamit ng Unicode:: Normalize; # std perl distro sa v5.8
gamitin ang Listahan::Util qw(max); # std perl distro sa v5.10
gumamit ng Unicode::Collate::Locale; # std perl distro sa v5.14

# cpan module
gumamit ng Unicode::GCString; # mula sa CPAN

# forward defs
sub pad($$$);
sub colwidth(_);
sub entitle(_);

ang aking %presyo = (
"XXXXX" => 6.50, # gyros
"peras" => 2.00, # parang um, peras
"linguica" => 7.00, # maanghang na sausage, Portuguese
"xorico" => 3.00, # chorizo ​​​​sausage, Catalan
"hamburger" => 6.00, # burgermeister meisterburger
"eclair" => 1.60, # dessert, French
"smorbrod" => 5.75, # sandwich, Norwegian
"spaetzle" => 5.50, # Bayerisch noodles, maliliit na maya
"XX" => 7.50, # bao1 zi5, steamed pork buns, Mandarin
"jamon serrano" => 4.45, # country ham, Spanish
"peches" => 2.25, # peaches, French
"XXXXXXX" => 1.85, # pastry na puno ng cream tulad ng eclair
"XXX" => 4.00, # makgeolli, Korean rice wine
"XX" => 9.99, # sushi, Japanese
"XXX" => 2.65, # omochi, rice cake, Japanese
"creme brulee" => 2.00, # crema catalana
"fideua" => 4.20, # pang pansit, Valencian
# (Catalan=fideuada)
"pate" => 4.15, # gooseliver paste, French
"XXXXX" => 8.00, # okonomiyaki, Japanese
);

my $width = 5 + max map { colwidth } keys %price;

# Kaya ang mga bagay na Asyano ay lumalabas sa isang pagkakasunud-sunod na ang isang tao
# na nagbabasa ng mga script na iyon ay hindi magugulat; ang
Ang # CJK na bagay ay nasa JIS X 0208 order sa ganoong paraan.
my $coll = Unicode::Collate::Locale->new(locale => "ja");

para sa aking $item ($coll->sort(keys %price)) {
print pad(entitle($item), $width, ".");
printf " X%.2f\n", $presyo{$item};
}

sub pad($$$) {
my($str, $width, $padchar) = @_;
ibalik ang $str . ($padchar x ($width - colwidth($str)));
}

sub colwidth(_) {
my($str) = @_;
ibalik ang Unicode::GCString->new($str)->column;
}

sub entitle(_) {
my($str) = @_;
$str =~ s{ (?=\pL)(\S) (\S*) }
{ ucfirst ($1) . lc($2) }xge;
ibalik ang $str;
}

Gumamit ng perlunicook online gamit ang mga serbisyo ng onworks.net