perlunicook - Online in de cloud

PROGRAMMA:

NAAM

perlunicook - kookboekachtige voorbeelden van het omgaan met Unicode in Perl

PRODUCTBESCHRIJVING

Deze man-pagina bevat korte recepten die demonstreren hoe algemene Unicode-bewerkingen moeten worden uitgevoerd
in Perl, plus een compleet programma aan het eind. Alle niet-gedeclareerde variabelen in het individu
recepten worden verondersteld een eerdere passende waarde in zich te hebben.

Voorbeelden

X 0: Standaard preambule
Tenzij anders vermeld, hebben alle onderstaande voorbeelden deze standaardpreambule nodig om te werken
correct, met de "#!" aangepast om op uw systeem te werken:

#!/usr/bin/env perl

gebruik utf8; # dus literals en identifiers kunnen in UTF-8 zijn
gebruik v5.12; # of hoger om de functie "unicode_strings" te krijgen
gebruik strikt; # aanhalingstekenreeksen, declareer variabelen
gebruik waarschuwingen; # standaard aan
gebruik waarschuwingen qw(FATAL utf8); # coderingsglikkeringen fataliseren
gebruik open qw(:std:utf8); # niet-aangegeven streams in UTF-8
gebruik charnames qw(:full :short); # overbodig in v5.16

Deze doet laat zelfs Unix-programmeurs uw binaire streams "binmode" of open ze ermee
":raw", maar dat is toch de enige manier om ze draagbaar te krijgen.

WAARSCHUWING: "gebruik autodie" (vóór 2.26) en "gebruik open" kunnen niet met elkaar opschieten.

X 1: Algemeen Unicode-vaardig filter
Ontbind altijd op weg naar binnen, en hercombineer dan op weg naar buiten.

gebruik Unicode::Normaliseren;

terwijl (<>) {
$_ = NFD($_); # ontleed + canoniek opnieuw ordenen
...
} doorgaan met {
NFC afdrukken($_); # opnieuw samenstellen (waar mogelijk) + canoniek opnieuw ordenen
}

X 2: Scherpstellen Unicode waarschuwingen
Vanaf v5.14 onderscheidt Perl drie subklassen van UTFX8-waarschuwingen.

gebruik v5.14; # subwaarschuwingen waren eerder niet beschikbaar
geen waarschuwingen "nonchar"; # de 66 verboden niet-tekens
geen waarschuwingen "surrogaat"; # UTF-16/CESU-8 onzin
geen waarschuwingen "non_unicode"; # voor codepunten van meer dan 0x10_FFFF

X 3: Verklaren (bron) in utf8 voor identifiers en letterlijk
Zonder de uiterst kritieke "use utf8"-declaratie, zet u UTFX8 in uw letterlijke en
identifiers werken niet goed. Als u de zojuist hierboven gegeven standaard preambule hebt gebruikt, is dit
al gebeurd. Als je dat hebt gedaan, kun je het volgende doen:

gebruik utf8;

mijn $maat = "Aangstroem";
mijn @Xsoft = qw( cp852 cp1251 cp1252 );
mijn @XXXXXXXXX = qw( XXXX XXXXX );
mijn @X = qw( koi8-f koi8-u koi8-r );
mijn $motto = "XXX"; # FAMILIE, GROEIEND HART, DROMEDARIS KAMEEL

Als u "gebruik utf8" vergeet, worden hoge bytes verkeerd begrepen als afzonderlijke tekens, en
niets zal goed werken.

X 4: Personages en hun nummers
De functies "ord" en "chr" werken transparant op alle codepunten, niet alleen op ASCII
alleen X noch in feite, zelfs niet alleen op Unicode alleen.

# ASCII-tekens
orde("A")
chr(65)

# karakters van het Basic Multilingual Plane
volgorde("X")
chr(0x3A3)

# voorbij de BMP
ord("X") # WISKUNDIGE CURSUS KLEINE N
chr(0x1D45B)

# verder dan Unicode! (tot MAXINT)
ord("\x{20_0000}")
chr(0x20_0000)

X 5: Unicode letterlijk by karakter aantal
In een geïnterpoleerde letterlijke waarde, of het nu gaat om een ​​tekenreeks met dubbele aanhalingstekens of een regex, kunt u een
teken door het nummer met behulp van de "\x{HHHHHH}" ontsnappen.

Tekenreeks: "\x{3a3}"
Reguliere expressie: /\x{3a3}/

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

# zelfs niet-BMP-bereiken in regex werken prima
/[\x{1D434}-\x{1D467}]/

X 6: Krijgen karakter naam by aantal
gebruik charnames ();
mijn $name = charnames::viacode(0x03A3);

X 7: Krijgen karakter aantal by naam
gebruik charnames ();
mijn $nummer = charnames::vianame("GRIEKSE HOOFDLETTER SIGMA");

X 8: Unicode genoemd tekens
Gebruik de "\N{charnaam}" notatie om het teken met die naam te krijgen voor gebruik in geïnterpoleerd
literals (tekenreeksen met dubbele aanhalingstekens en regexes). In v5.16 is er een impliciet

gebruik charnames qw(:full :short);

Maar vóór v5.16 moet u expliciet aangeven welke set charnames u wilt. De
":full"-namen zijn de officiële Unicode-tekennaam, alias of reeks, die allemaal worden gedeeld
een naamruimte.

gebruik charnames qw(:full :short latin grieks);

"\N{MATHEMATISCHE ITALIC KLEINE N}" # :full
"\N{GRIEKSE HOOFDLETTER SIGMA}" # :full

Al het andere is een Perl-specifieke gemaksafkorting. Geef een of meer scripts op door
namen als u korte namen wilt die scriptspecifiek zijn.

"\N{Grieks:Sigma}" # :short
"\N{ae}" # Latijn
"\N{epsilon}" # Grieks

De versie v5.16 ondersteunt ook een ":loose" import voor het los matchen van karakternamen,
wat werkt net als losse matching van eigenschapsnamen: dat wil zeggen, het negeert hoofdlettergebruik,
witruimte en onderstrepingstekens:

"\N{euroteken}" # :los (vanaf v5.16)

X 9: Unicode genoemd sequenties
Deze zien eruit als karakternamen, maar retourneren meerdere codepunten. Let op de %vx
vector-printfunctionaliteit in "printf".

gebruik charnames qw(:full);
my $seq = "\N{LATIJNSE HOOFDLETTER A MET MACRON EN GRAF}";
printf "U+%v04X\n", $seq;
U + 0100.0300

X 10: Eigen genoemd tekens
Gebruik ":alias" om uw eigen lexicaal bereikde bijnamen te geven aan bestaande karakters, of zelfs
om naamloze karakters voor privégebruik nuttige namen te geven.

gebruik charnames ":full", ":alias" => {
ecute => "LATIJNSE KLEINE LETTER E MET ACUTE",
"APPLE LOGO" => 0xF8FF, # teken voor privégebruik
};

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

X 11: namen of CJK codepunten
Sinogrammen zoals XXXX komen terug met karakternamen van "CJK UNIFIED IDEOGRAPH-6771" en
"CJK UNIFIED IDEOGRAPH-4EAC", omdat hun XnamesX variëren. De CPAN "Unicode::Unihan"
module heeft een grote database om deze (en nog veel meer) te decoderen, mits je het weet
hoe de output te begrijpen.

# cpan -i Unicode::Unihan
gebruik Unicode::Unihan;
mijn $str = "XX";
mijn $unhan = Unicode::Unihan->nieuw;
voor mijn $lang (qw(Mandarijn Kantonees Koreaans JapansOn JapaneseKun)) {
printf "CJK $str in %-12s is ", $lang;
zeg $unhan->$lang($str);
}

prints:

CJK XX in het Mandarijn is DONG1JING1
CJK XX in het Kantonees is mest1ging1
CJK XX in het Koreaans is TONGKYENG
CJK XX in het JapansOn is TOUKYOU KEI KIN
CJK XX in het JapansKun is HIGASHI AZUMAMIYAKO

Als u een specifiek romaniseringsschema in gedachten heeft, gebruik dan de specifieke module:

# cpan -i Lingua::JA::Romanize::Japans
gebruik Lingua::JA::Romanize::Japans;
my $k2r = Lingua::JA::Romanize::Japans->nieuw;
mijn $str = "XX";
zeg "Japans voor $str is ", $k2r->chars($str);

prints

Japans voor XX is toukyou

X 12: Uitdrukkelijk coderen/decoderen
In zeldzame gevallen, zoals bij het lezen van een database, krijgt u mogelijk gecodeerde tekst die u nodig hebt
decoderen.

gebruik Coderen qw (coderen decoderen);

mijn $chars = decoderen("shiftjis", $bytes, 1);
# OF
mijn $bytes = coderen("MIME-Header-ISO_2022_JP", $chars, 1);

Voor streams die allemaal dezelfde codering hebben, gebruik geen coderen/decoderen; stel in plaats daarvan het bestand in
codering wanneer u het bestand opent of onmiddellijk daarna met "binmode" zoals later beschreven
hieronder.

X 13: Decoderen programma argumenten as utf8
$ perl-CA ...
or
$ exporteren PERL_UNICODE=A
or
gebruik Codeer qw(decode_utf8);
@ARGV = kaart { decode_utf8($_, 1) } @ARGV;

X 14: Decoderen programma argumenten as lokaal codering
# cpan -i Coderen::Locale
gebruik Codeer qw(locale);
gebruik Encode::Lokale;

# gebruik "locale" als arg om te coderen/decoderen
@ARGV = map { decoderen(locale => $_, 1) } @ARGV;

X 15: Verklaren SOA{IN,UIT,ERR} naar be utf8
Gebruik een opdrachtregeloptie, een omgevingsvariabele of roep expliciet "binmode" aan:

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

X 16: Verklaren SOA{IN,UIT,ERR} naar be in lokaal codering
# cpan -i Coderen::Locale
gebruik coderen;
gebruik Encode::Lokale;

# of als stream voor binmode of open
binmode STDIN, ":codering(console_in)" if -t STDIN;
binmode STDOUT, ":codering(console_out)" if -t STDOUT;
binmode STDERR, ":codering(console_out)" if -t STDERR;

X 17: Merk filet I / O verzuim naar utf8
Bestanden die zijn geopend zonder een coderingsargument, zijn in UTF-8:

$ perl-CD ...
or
$ exporteren PERL_UNICODE=D
or
gebruik open qw(:utf8);

X 18: Merk allen I / O en betoogt verzuim naar utf8
$ perl-CSDA...
or
$ exporteren PERL_UNICODE=SDA
or
gebruik open qw(:std:utf8);
gebruik Codeer qw(decode_utf8);
@ARGV = kaart { decode_utf8($_, 1) } @ARGV;

X 19: Openen filet with specifiek codering
Specificeer streamcodering. Dit is de normale manier om met gecodeerde tekst om te gaan, niet door te bellen
laagdrempelige functies.

# Invoer bestand
open(mijn $in_file, "< :encoding(UTF-16)", "wintext");
OR
open(mijn $in_file, "<", "wintext");
binmode($in_file, ":encoding(UTF-16)");
THEN
mijn $regel = <$in_bestand>;

# uitvoerbestand
open($out_file, "> :encoding(cp1252)", "wintext");
OR
open(mijn $out_file, ">", "wintext");
binmode($out_file, ":encoding(cp1252)");
THEN
print $out_file "wat tekst\n";

Hier kunnen meer lagen worden opgegeven dan alleen de codering. Bijvoorbeeld de bezwering
":raw :encoding(UTF-16LE) :crlf" omvat impliciete CRLF-afhandeling.

X 20: Unicode omhulsel
Unicode-behuizing is heel anders dan ASCII-behuizing.

uc("henry x") # "henry x"
uc("tschuess") # "TSCHUeSS" bericht ss => SS

# beide zijn waar:
"tschuess" =~ /TSCHUeSS/i # bericht ss => SS
"XXXXXXX" =~ /XXXXXXX/i # let op X,X,X gelijkheid

X 21: Unicode hoofdlettergevoelig vergelijkingen
Ook beschikbaar in de CPAN Unicode::CaseFold-module, de nieuwe "fc" XfoldcaseX-functie van
v5.16 geeft toegang tot dezelfde Unicode casefolding als de "/i" patroonmodifier heeft
altijd gebruikt:

gebruik functie "fc"; # fc() functie is van v5.16

# niet hoofdlettergevoelig sorteren
mijn @sorted = sorteer { fc($a) cmp fc($b) } @list;

# beide zijn waar:
fc("tschuess") eq fc("TSCHUeSS")
fc("XXXXXXX") eq fc("XXXXXXX")

X 22: Match Unicode regeleinde volgorde in regex
Een Unicode-regeleinde komt overeen met het CRLF-grafeem van twee tekens of met een van de zeven verticale tekens
witruimte tekens. Goed voor het omgaan met tekstbestanden die afkomstig zijn van verschillende besturingssystemen
systemen.

\R

s/\R/\n/g; # normaliseer alle regeleinden naar \n

X 23: Krijgen karakter categorie
Zoek de algemene categorie van een numeriek codepunt.

gebruik Unicode::UCD qw(charinfo);
mijn $kat = charinfo(0x3A3)->{categorie}; # "Lu"

X 24: uitschakelen Unicode-bewustzijn in ingebouwde tekenklassen
Schakel "\w", "\b", "\s", "\d" en de POSIX-klassen uit om correct te werken op Unicode
hetzij in dit bereik, of in slechts één regex.

gebruik v5.14;
gebruik opnieuw "/a";

# OF

mijn($getal) = $str =~ /(\d+)/a;

Of gebruik specifieke niet-Unicode-eigenschappen, zoals "\p{ahex}" en "\p{POSIX_Digit"}. Eigenschappen
werkt nog steeds normaal, ongeacht welke karakterset-modifiers ("/d /u /l /a /aa") effect zouden moeten hebben.

X 25: Match Unicode vastgoed in regex with \P, \P
Deze komen allemaal overeen met een enkel codepunt met de gegeven eigenschap. Gebruik "\P" in plaats van "\p" om
overeenkomen met één codepunt dat die eigenschap mist.

\pL, \pN, \pS, \pP, \pM, \pZ, \pC
\p{Sk}, \p{Ps}, \p{Lt}
\p{alpha}, \p{bovenste}, \p{onderste}
\p{Latijn}, \p{Grieks}
\p{script=Latijn}, \p{script=Grieks}
\p{East_Asian_Width=Breed}, \p{EA=W}
\p{Line_Break=Koppelteken}, \p{LB=HY}
\p{Numerieke_Waarde=4}, \p{NV=4}

X 26: Eigen karakter vastgoed
Definieer tijdens het compileren uw eigen aangepaste tekeneigenschappen voor gebruik in regexes.

# tekens voor privégebruik gebruiken
sub In_Tengwar { "E000\tE07F\n" }

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

# het mengen van bestaande eigenschappen
sub Is_GraecoRoman_Title {<<'END_OF_SET'}
+utf8::Islatijns
+utf8::IsGrieks
&utf8::IsTitel
END_OF_SET

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

X 27: Unicode normalisatie
Renderen meestal in NFD bij invoer en NFC bij uitvoer. NFKC- of NFKD-functies gebruiken
verbetert het onthouden van zoekopdrachten, ervan uitgaande dat u al hebt gedaan om dezelfde tekst te doorzoeken.
Merk op dat dit om veel meer gaat dan alleen vooraf gecombineerde compatibiliteitstekens; het ook
herschikt markeringen volgens hun canonieke combinatieklassen en verwijdert singletons.

gebruik Unicode::Normaliseren;
mijn $nfd = NFD($orig);
mijn $nfc = NFC($orig);
mijn $nfkd = NFKD($orig);
mijn $nfkc = NFKC($orig);

X 28: Converteren niet-ASCII Unicode numeriek
Tenzij u "/a" of "/aa" hebt gebruikt, komt "\d" overeen met meer dan alleen ASCII-cijfers, maar PerlXs
impliciete conversie van tekenreeks naar nummer herkent deze momenteel niet. Hier is hoe
converteer dergelijke strings handmatig.

gebruik v5.14; # nodig voor functie num().
gebruik Unicode::UCD qw(num);
my $str = "heb X en XXXX en X en hier";
mijn @nums = ();
terwijl ($str =~ /(\d+|\N)/g) { # niet alleen ASCII!
druk op @nums, num($1);
}
zeg "@nums"; # 12 4567 0.875

gebruik charnames qw(:full);
my $nv = num("\N{RUMI DIGIT ONE}\N{RUMI CIJFER TWEE}");

X 29: Match Unicode grafeme cluster in regex
Programmeur-zichtbare XcharactersX zijn codepunten die overeenkomen met "/./s", maar voor de gebruiker zichtbaar
XcharactersX zijn grafemen die overeenkomen met "/\X/".

# Zoek klinker *plus* elke combinatie van diakritische tekens, onderstrepingen, enz.
mijn $nfd = NFD($orig);
$nfd =~ / (?=[aeiou]) \X /xi

X 30: Extract by grafeme verkrijgen in plaats daarvan of by codepunt (regex)
# match en pak vijf eerste grafemen
mijn($eerste_vijf) = $str =~ /^ ( \X{5} ) /x;

X 31: Extract by grafeme verkrijgen in plaats daarvan of by codepunt (substr)
# cpan -i Unicode::GCString
gebruik Unicode::GCString;
mijn $gcs = Unicode::GCString->new($str);
mijn $first_five = $gcs->substr(0, 5);

X 32: Omkeren snaar by grafeme
Omkeren met codepunt verprutst diakritische tekens, waardoor "creme brulee" per ongeluk wordt omgezet in
"eelXurb emXerc" in plaats van in "eelurb emerc"; dus in plaats daarvan omgekeerd door grafeem. Beide
deze benaderingen werken goed, ongeacht in welke normalisatie de string zich bevindt:

$str = join("", omgekeerde $str =~ /\X/g);

# OF: cpan -i Unicode::GCString
gebruik Unicode::GCString;
$str = omgekeerde Unicode::GCString->nieuw($str);

X 33: Draad lengte in grafemen
De string "brulee" heeft zes grafemen maar maximaal acht codepunten. Dit telt mee
grafeem, niet per codepunt:

mijn $str = "brulee";
mijn $count = 0;
terwijl ($str =~ /\X/g) { $count++ }

# OF: cpan -i Unicode::GCString
gebruik Unicode::GCString;
mijn $gcs = Unicode::GCString->new($str);
mijn $count = $gcs->length;

X 34: Unicode kolombreedte voor het drukken
PerlXs "printf", "sprintf" en "format" denken dat alle codepunten 1 printkolom innemen, maar
velen nemen 0 of 2. Om te laten zien dat normalisatie geen verschil maakt, printen we beide uit
vormen:

gebruik Unicode::GCString;
gebruik Unicode::Normaliseren;

mijn @woorden = qw/creme brulee/;
@words = kaart { NFC($_), NFD($_) } @words;

voor mijn $str (@words) {
mijn $gcs = Unicode::GCString->new($str);
mijn $cols = $gcs->columns;
mijn $pad = " " x (10 - $cols);
zeg str, $pad, " |";
}

genereert dit om aan te tonen dat het correct opvult, ongeacht de normalisatie:

crème |
creXme |
brulee |
bruXleXe |

X 35: Unicode vergelijking
Tekst gesorteerd op numeriek codepunt volgt geen redelijke alfabetische volgorde; gebruik de UCA voor
tekst sorteren.

gebruik Unicode::Collate;
my $col = Unicode::Collate->new();
mijn @lijst = $col->sort(@oude_lijst);

Zie de sorteer programma van de Unicode::Tussle CPAN-module voor een handige opdrachtregel
interface naar deze module.

X 36: Geval- en accentongevoelig Unicode sorteren
Specificeer een sorteersterkte van niveau 1 om hoofdlettergebruik en diakritische tekens te negeren en alleen naar de
basis karakter.

gebruik Unicode::Collate;
my $col = Unicode::Collate->new(level => 1);
mijn @lijst = $col->sort(@oude_lijst);

X 37: Unicode lokaal vergelijking
Sommige locaties hebben speciale sorteerregels.

# gebruik ofwel v5.12, OF: cpan -i Unicode::Collate::Locale
gebruik Unicode::Collate::Locale;
my $col = Unicode::Collate::Locale->new(locale => "de__phonebook");
mijn @lijst = $col->sort(@oude_lijst);

De sorteer programma hierboven vermeld accepteert een "--locale" parameter.

X 38: maken "cmp" werk on tekst verkrijgen in plaats daarvan of codepunten
In plaats van dit:

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

Gebruik dit:

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

X 39: Geval- en accentongevoelig vergelijkingen
Gebruik een collator-object om Unicode-tekst per teken te vergelijken in plaats van per codepunt.

gebruik Unicode::Collate;
my $es = Unicode::Collate->new(
niveau => 1,
normalisatie => undef
);

# nu zijn beide waar:
$es->eq("Garcia", "GARCIA" );
$es->eq("Marquez", "MARQUEZ");

X 40: Geval- en accentongevoelig lokaal vergelijkingen
Hetzelfde, maar in een specifieke omgeving.

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

# nu is dit waar:
$de->eq("tschuess", "TSCHUESS"); # mededeling ue => UE, ss => SS

X 41: Unicode lijnbrekend
Splits tekst op in regels volgens de Unicode-regels.

# cpan -i Unicode::LineBreak
gebruik Unicode::LineBreak;
gebruik charnames qw(:full);

my $para = "Dit is een super\N{HYPHEN}lange string. " x 20;
mijn $fmt = Unicode::LineBreak->nieuw;
print $fmt->break($para), "\n";

X 42: Unicode tekst in DBM hasj, the vervelend weg
Als u een gewone Perl-tekenreeks gebruikt als sleutel of waarde voor een DBM-hash, wordt een breed teken geactiveerd
uitzondering als codepunten niet in een byte passen. Hier leest u hoe u de
vertaling:

gebruik DB_File;
gebruik Coderen qw (coderen decoderen);
gelijkspel %dbhash, "DB_File", "padnaam";

# WINKEL

# neem aan dat $uni_key en $uni_value abstracte Unicode-strings zijn
mijn $enc_key = coderen("UTF-8", $uni_key, 1);
mijn $enc_value = coderen("UTF-8", $uni_value, 1);
$dbhash{$enc_key} = $enc_waarde;

# OPHALEN

# neem aan dat $uni_key een normale Perl-string bevat (abstracte Unicode)
mijn $enc_key = coderen("UTF-8", $uni_key, 1);
mijn $enc_value = $dbhash{$enc_key};
mijn $uni_value = decoderen("UTF-8", $enc_value, 1);

X 43: Unicode tekst in DBM hasj, the En het is heel gemakkelijk weg
Hier leest u hoe u de vertaling impliciet kunt beheren; alle codering en decodering is voltooid
automatisch, net als bij streams waaraan een bepaalde codering is gekoppeld:

gebruik DB_File;
gebruik DBM_Filter;

mijn $dbobj = gelijkspel %dbhash, "DB_File", "padnaam";
$dbobj->Filter_Value("utf8"); # dit is het magische stukje

# WINKEL

# neem aan dat $uni_key en $uni_value abstracte Unicode-strings zijn
$dbhash{$uni_key} = $uni_waarde;

# OPHALEN

# $uni_key bevat een normale Perl-string (abstracte Unicode)
mijn $uni_value = $dbhash{$uni_key};

X 44: PROGRAMMA: Demo of Unicode vergelijking en het drukken
Hier is een volledig programma dat laat zien hoe u gebruik kunt maken van locale-gevoelige sortering, Unicode-behuizing,
en het beheren van afdrukbreedten wanneer sommige tekens nul of twee kolommen innemen, niet
slechts één kolom per keer. Wanneer het wordt uitgevoerd, produceert het volgende programma dit mooi uitgelijnd
output:

Crème Brulee.......X2.00
Éclair........ X1.60
Fideua........ X4.20
Hamburger.......... X6.00
Jamón Serrano...... X4.45
Taalkunde........... X7.00
Paté ............... X4.15
Peren.............. X2.00
Perches............. X2.25
Smorbrod........... X5.75
Spätzle............ 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

Hier is dat programma; getest op v5.14.

#!/usr/bin/env perl
# umenu - demo sorteren en afdrukken van Unicode-voedsel
#
# (verplichte en steeds langere preambule)
#
gebruik utf8;
gebruik v5.14; # voor locale sorteren
gebruik strikt;
gebruik waarschuwingen;
gebruik waarschuwingen qw(FATAL utf8); # coderingsfouten fataliseren
gebruik open qw(:std:utf8); # niet-aangegeven streams in UTF-8
gebruik charnames qw(:full :short); # overbodig in v5.16

# standaardmodules
gebruik Unicode::Normaliseren; # std perl distro vanaf v5.8
gebruik Lijst::Util qw(maximaal); # std perl distro vanaf v5.10
gebruik Unicode::Collate::Locale; # std perl distro vanaf v5.14

# cpan-modules
gebruik Unicode::GCString; # van CPAN

# voorwaartse defs
subpad($$$);
sub colbreedte(_);
ondertitel recht(_);

mijn %prijs = (
"XXXXX" => 6.50, # gyros
"peren" => 2.00, # zoals eh, peren
"linguica" => 7.00, # pittige worst, Portugees
"xorico" => 3.00, # chorizoworst, Catalaans
"hamburger" => 6.00, # burgermeister meisterburger
"eclair" => 1.60, # dessert, Frans
"smorbrod" => 5.75, # broodjes, Noors
"spätzle" => 5.50, # Bayerische noedels, mussen
"XX" => 7.50, # bao1 zi5, gestoomde varkensbroodjes, Mandarijn
"jamon serrano" => 4.45, #boerenham, Spaans
"peches" => 2.25, # perziken, Frans
"XXXXXXX" => 1.85, # met room gevuld gebak zoals eclair
"XXX" => 4.00, #makgeolli, Koreaanse rijstwijn
"XX" => 9.99, #sushi, Japans
"XXX" => 2.65, # omochi, rijstwafels, Japans
"creme brulee" => 2.00, # crema catalana
"fideua" => 4.20, # meer noedels, Valenciaans
# (Catalaans=fideuada)
"paté" => 4.15, #ganzenleverpasta, Frans
"XXXXX" => 8.00, # okonomiyaki, Japans
);

mijn $width = 5 + max kaart { colwidth } sleutels% prijs;

# Dus het Aziatische spul komt uit in een volgorde die iemand
# wie die scripts leest, zal niet in paniek raken; de
# CJK-dingen zullen op die manier in JIS X 0208-volgorde staan.
my $coll = Unicode::Collate::Locale->new(locale => "ja");

voor mijn $item ($coll->sort(keys %price)) {
printpad(entitle($item), $width, ".");
printf " X%.2f\n", $price{$item};
}

subpad($$$) {
mijn($str, $breedte, $padchar) = @_;
geef $str terug. ($padchar x ($width - colwidth($str)));
}

subcolbreedte(_) {
mijn($str) = @_;
retourneer Unicode::GCString->new($str)->columns;
}

ondertitel recht(_) {
mijn($str) = @_;
$str =~ s{ (?=\pL)(\S) (\S*) }
{ eerst($1) . lc($2) }xge;
geef $str terug;
}

Gebruik perlunicook online met behulp van onworks.net-services