perlunicook - Online nel Cloud

PROGRAMMA:

NOME

perlunicook - esempi da manuale di gestione di Unicode in Perl

DESCRIZIONE

Questa manpage contiene brevi ricette che mostrano come gestire le comuni operazioni Unicode
in Perl, più un programma completo alla fine. Qualsiasi variabile non dichiarata nell'individuo
si presume che le ricette abbiano un valore appropriato precedente in esse.

ESEMPI

X 0: Standard preambolo
Salvo diversa indicazione, tutti gli esempi seguenti richiedono che questo preambolo standard funzioni
correttamente, con il "#!" regolato per funzionare sul tuo sistema:

#!/usr/bin/env perl

usa utf8; # quindi letterali e identificatori possono essere in UTF-8
usa v5.12; # o successivo per ottenere la funzione "unicode_strings"
usa rigoroso; # stringhe di virgolette, dichiara variabili
utilizzare gli avvisi; # attivato per impostazione predefinita
usa gli avvertimenti qw(FATAL utf8); # fatalize glitch di codifica
usa open qw(:std:utf8); # stream non dichiarati in UTF-8
usa i nomi dei caratteri qw(:full :short); # non necessario nella v5.16

Si effettua rendi anche i programmatori Unix "binmode" i tuoi flussi binari, o aprili con
":raw", ma è comunque l'unico modo per accedervi in ​​modo portatile.

AVVERTIMENTO: "use autodie" (pre 2.26) e "use open" non vanno d'accordo.

X 1: Generico Esperto di Unicode filtro
Decomponi sempre all'ingresso, quindi ricomponi all'uscita.

usa Unicode :: Normalizza;

mentre (<>) {
$_ = DNF($_); # decomponi + riordina canonicamente
...
} Continua {
stampa NFC($_); # ricomponi (dove possibile) + riordina canonicamente
}

X 2: Ritocchi Unicode avvertenze
A partire dalla v5.14, Perl distingue tre sottoclassi di avvisi UTFX8.

usa v5.14; # avvisi secondari non disponibili prima
nessun avviso "nonchar"; # i 66 non personaggi proibiti
nessun avviso "surrogato"; # UTF-16/CESU-8 sciocchezze
nessun avviso "non_unicode"; # per codepoint oltre 0x10_FFFF

X 3: Dichiarare source in utf8 per identificatori e letterali
Senza la fondamentale dichiarazione "use utf8", inserendo UTFX8 nei tuoi letterali e
gli identificatori non funzioneranno correttamente. Se hai usato il preambolo standard appena dato sopra, questo
già successo. Se lo hai fatto, puoi fare cose come questa:

usa utf8;

my $misura = "Aangstroem";
mio @Xsoft = qw( cp852 cp1251 cp1252 );
mio @XXXXXXXXX = qw( XXXX XXXXX );
mio @X = qw( koi8-f koi8-u koi8-r );
mio $motto = "XXX"; # FAMIGLIA, CUORE IN CRESCITA, CAMMELLO DROMEDARIO

Se dimentichi "usa utf8", i byte alti verranno fraintesi come caratteri separati e
niente funzionerà bene.

X 4: Personaggi e loro numeri
Le funzioni "ord" e "chr" funzionano in modo trasparente su tutti i codepoint, non solo su ASCII
solo X né di fatto, nemmeno solo su Unicode da solo.

# caratteri ASCII
ord("A")
chr(65)

# caratteri dal piano multilingue di base
ordine("X")
chr(0x3A3)

# oltre il BMP
ord("X") # CORSO MATEMATICO PICCOLO N
chr(0x1D45B)

# oltre Unicode! (fino a MAXINT)
ord("\x{20_0000}")
chr(0x20_0000)

X 5: Unicode letterali by carattere numero
In un letterale interpolato, che sia una stringa tra doppi apici o un'espressione regolare, puoi specificare a
carattere con il suo numero usando "\x{HHHHH}" fuga.

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

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

# anche gli intervalli non BMP in regex funzionano bene
/[\x{1D434}-\x{1D467}]/

X 6: Ottieni carattere Nome by numero
usa i nomi dei caratteri ();
my $name = nomi di caratteri::viacodice(0x03A3);

X 7: Ottieni carattere numero by Nome
usa i nomi dei caratteri ();
my $number = charnames::vianame("LETTERA MAIUSCOLA GRECA SIGMA");

X 8: Unicode detto caratteri
Usa il "\N{nome del personaggio}" notazione per ottenere il carattere con quel nome da usare in interpolated
letterali (stringhe e espressioni regolari tra virgolette). Nella v5.16, c'è un implicito

usa i nomi dei caratteri qw(:full :short);

Ma prima della v5.16, devi essere esplicito su quale set di nomi di caratteri desideri. Il
I nomi ":full" sono il nome, l'alias o la sequenza ufficiale del carattere Unicode, che tutti condividono
uno spazio dei nomi.

usa i nomi dei caratteri qw(:full :breve latino greco);

"\N{MATEMATICA CORSIVO PICCOLO N}" # :full
"\N{LETTERA MAIUSCOLA GRECA SIGMA}" # :full

Qualsiasi altra cosa è un'abbreviazione di convenienza specifica per Perl. Specifica uno o più script per
nomi se vuoi nomi brevi che sono specifici dello script.

"\N{Greco:Sigma}" # :breve
"\N{ae}" # latino
"\N{epsilon}" # greco

La versione v5.16 supporta anche un'importazione ":loose" per la corrispondenza libera dei nomi dei personaggi,
che funziona proprio come la corrispondenza libera dei nomi delle proprietà: ovvero ignora il caso,
spazi bianchi e caratteri di sottolineatura:

"\N{simbolo dell'euro}" # :loose (dalla v5.16)

X 9: Unicode detto sequenze
Sembrano nomi di personaggi ma restituiscono più codepoint. Notare il %vx
funzionalità di stampa vettoriale in "printf".

usa i nomi dei caratteri qw(:full);
my $seq = "\N{MAIUSCOLO LATINO A CON MACRON E TOMBA}";
printf "U+%v04X\n", $seq;
U + 0100.0300

X 10: Custom detto caratteri
Usa ":alias" per dare i tuoi soprannomi con ambito lessicale a personaggi esistenti, o anche
per dare nomi utili a caratteri di uso privato senza nome.

usa i nomi dei caratteri ":full", ":alias" => {
ecute => "E MINUSCOLA LATINA CON ACUTA",
"LOGO APPLE" => 0xF8FF, # carattere per uso privato
};

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

X 11: nomi of CJK punti di codice
I sinogrammi come XXXX tornano con i nomi dei personaggi di "CJK UNFIED IDEOGRAPH-6771" e
"CJK UNFIED IDEOGRAPH-4EAC", perché i loro XnamesX variano. Il CPAN "Unicode::Unihan"
il modulo ha un ampio database per decodificare questi (e molto altro ancora), a condizione che tu lo sappia
come capire il suo output.

# cpan -i Unicode::Unihan
usa Unicode::Unihan;
mio $str = "XX";
my $unhan = Unicode::Unihan->new;
per il mio $lang (qw(mandarino cantonese coreano giapponeseOn giapponeseKun)) {
printf "CJK $str in %-12s è ", $lang;
say $unhan->$lang($str);
}

stampe:

CJK XX in mandarino è DONG1JING1
CJK XX in cantonese è dung1ging1
CJK XX in coreano è TONGKYENG
CJK XX in giapponese On è TOUKYOU KEI KIN
CJK XX in giapponeseKun è HIGASHI AZUMAMIYAKO

Se hai in mente uno schema di romanizzazione specifico, usa il modulo specifico:

# cpan -i Lingua::JA::Romanize::Giapponese
usa Lingua::JA::Romanize::Japanese;
my $k2r = Lingua::JA::Romanize::Japanese->new;
mio $str = "XX";
say "Il giapponese per $str è ", $k2r->chars($str);

stampe

Il giapponese per XX è toukyou

X 12: Esplicito codifica/decodifica
In rare occasioni, come la lettura di un database, potresti ricevere del testo codificato di cui hai bisogno
decodificare.

usa Encode qw (codifica decodifica);

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

Per i flussi tutti nella stessa codifica, non utilizzare codifica/decodifica; invece imposta il file
codifica quando si apre il file o subito dopo con "binmode" come descritto in seguito
qua sotto.

X 13: Decodificare Programma argomenti as utf8
$perl-CA...
or
$ esportazione PERL_UNICODE=A
or
usa Codifica qw(decode_utf8);
@ARGV = mappa { decode_utf8($_, 1) } @ARGV;

X 14: Decodificare Programma argomenti as località codifica
# cpan -i Codifica::Locale
usa Encode qw(locale);
usa Encode::Locale;

# usa "locale" come argomento per codificare/decodificare
@ARGV = map { decode(locale => $_, 1) } @ARGV;

X 15: Dichiarare STD{IN,OUT,ERR} a be utf8
Utilizzare un'opzione della riga di comando, una variabile di ambiente oppure chiamare esplicitamente "binmode":

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

X 16: Dichiarare STD{IN,OUT,ERR} a be in località codifica
# cpan -i Codifica::Locale
usa Codifica;
usa Encode::Locale;

# o come flusso per binmode o open
binmode STDIN, ":encoding(console_in)" if -t STDIN;
binmode STDOUT, ":encoding(console_out)" if -t STDOUT;
binmode STDERR, ":encoding(console_out)" if -t STDERR;

X 17: Make filetto I / O difetto a utf8
I file aperti senza un argomento di codifica saranno in UTF-8:

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

X 18: Make contro tutti i I / O e args difetto a utf8
$perl-CSDA...
or
$ esportazione PERL_UNICODE=SDA
or
usa open qw(:std:utf8);
usa Codifica qw(decode_utf8);
@ARGV = mappa { decode_utf8($_, 1) } @ARGV;

X 19: Apri filetto con specifico codifica
Specifica la codifica del flusso. Questo è il modo normale di gestire il testo codificato, non chiamando
funzioni di basso livello.

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

# file di uscita
open($out_file, "> :encoding(cp1252)", "wintext");
OR
open(my $out_file, ">", "wintext");
binmode($out_file, ":encoding(cp1252)");
POI
print $out_file "del testo\n";

Qui è possibile specificare più livelli oltre alla semplice codifica. Ad esempio, l'incantesimo
":raw :encoding(UTF-16LE) :crlf" include la gestione implicita di CRLF.

X 20: Unicode involucro
L'involucro Unicode è molto diverso dall'involucro ASCII.

uc("henry X") # "HENRY X"
uc("tschuess") # "TSCHUESS" avviso ss => SS

# entrambi sono veri:
"tschuess" =~ /TSCHUeSS/i # avviso ss => SS
"XXXXXXX" =~ /XXXXXXX/i # nota X,X,X identità

X 21: Unicode insensitive caso confronto
Disponibile anche nel modulo CPAN Unicode::CaseFold, la nuova funzione "fc" XfoldcaseX di
v5.16 concede l'accesso allo stesso casefolding Unicode del modificatore di pattern "/i"
sempre usato:

utilizzare la funzione "fc"; # La funzione fc() è della v5.16

# ordina senza distinzione tra maiuscole e minuscole
mio @ordinato = ordina { fc($a) cmp fc($b) } @lista;

# entrambi sono veri:
fc("TSCHUESS") eq fc("TSCHUESS")
fc("XXXXXXX") eq fc("XXXXXXX")

X 22: partita Unicode interruzione di linea sequenza in regex
Un'interruzione di riga Unicode corrisponde al grafema CRLF di due caratteri o a uno dei sette verticali
caratteri di spaziatura bianca. Buono per gestire file di testo provenienti da diverse operazioni
sistemi.

\R

s/\R/\n/g; # normalizza tutte le interruzioni di riga su \n

X 23: Ottieni carattere categoria
Trova la categoria generale di un codepoint numerico.

usa Unicode::UCD qw(charinfo);
mio $gatto = carinfo(0x3A3)->{categoria}; # "Lu"

X 24: Disattivazione Consapevolezza Unicode in incorporato classi di caratteri
Disabilita "\w", "\b", "\s", "\d" e le classi POSIX affinché funzionino correttamente su Unicode
in questo ambito o in una sola regex.

usa v5.14;
usa re "/a";

# O

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

Oppure usa proprietà non Unicode specifiche, come "\p{ahex}" e "\p{POSIX_Digit"}. Proprietà
funzionano ancora normalmente, non importa quali modificatori di set di caratteri ("/d /u /l /a /aa") dovrebbero essere applicati.

X 25: partita Unicode proprietà in regex con \P, \P
Questi corrispondono tutti a un singolo punto di codice con la proprietà data. Usa "\P" al posto di "\p" per
corrisponde a un punto di codice privo di tale proprietà.

\pL, \pN, \pS, \pP, \pM, \pZ, \pC
\p{Sc}, \p{Ps}, \p{Lt}
\p{alpha}, \p{superiore}, \p{inferiore}
\p{latino}, \p{greco}
\p{script=latino}, \p{script=greco}
\p{East_Asian_Width=Largo}, \p{EA=W}
\p{Line_Break=Trattino}, \p{LB=HY}
\p{Valore_numerico=4}, \p{VN=4}

X 26: Custom carattere proprietà
Definisci in fase di compilazione le tue proprietà dei caratteri personalizzate da utilizzare nelle espressioni regolari.

# utilizzo di caratteri per uso privato
sub In_Tengwar { "E000\tE07F\n" }

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

# fusione di proprietà esistenti
sub Is_GraecoRoman_Title {<<'END_OF_SET'}
+utf8::È latino
+utf8::è greco
&utf8::IsTitle
END_OF_SET

if (/\p{È_GraecoRoman_Title}/ { ... }

X 27: Unicode normalizzazione
Tipicamente renderizza in NFD in input e NFC in output. Utilizzo delle funzioni NFKC o NFKD
migliora il richiamo sulle ricerche, supponendo che tu abbia già fatto lo stesso testo da cercare.
Nota che si tratta di molto più che semplici glifi di compatibilità precombinati; anche
riordina i segni in base alle loro classi combinate canoniche ed elimina i singoli.

usa Unicode :: Normalizza;
il mio $nfd = NFD($orig);
il mio $nfc = NFC($orig);
mio $nfkd = NFKD($orig);
mio $nfkc = NFKC($orig);

X 28: convertire non ASCII Unicode numerici
A meno che tuX non abbia usato "/a" o "/aa", "\d" corrisponde solo a più di cifre ASCII, ma PerlXs
la conversione implicita da stringa a numero attualmente non li riconosce. Ecco come fare
convertire tali stringhe manualmente.

usa v5.14; # necessario per la funzione num()
usa Unicode::UCD qw(num);
my $str = "ho ottenuto X e XXXX e X e qui";
i miei @num = ();
while ($str =~ /(\d+|\N)/g) { # non solo ASCII!
premi @num, num($1);
}
dire "@num"; # 12 4567 0.875

usa i nomi dei caratteri qw(:full);
my $nv = num("\N{RUMI CIFRA UNO}\N{RUMI CIFRA DUE}");

X 29: partita Unicode grafema gruppo in regex
XcharactersX visibili dal programmatore sono codepoint abbinati da "/./s", ma visibili dall'utente
XcharactersX sono grafemi abbinati da "/\X/".

# Trova vocale *più* qualsiasi combinazione di segni diacritici, sottolineatura, ecc.
il mio $nfd = NFD($orig);
$nfd =~ / (?=[aiou]) \X /xi

X 30: Estratto by grafema invece of by punto di codice (espressione regolare)
# abbina e prendi i primi cinque grafemi
mio($first_cinque) = $str =~ /^ ( \X{5} ) /x;

X 31: Estratto by grafema invece of by punto di codice (sottostrato)
# cpan -i Unicode::GCStringa
usa Unicode::GCString;
my $gcs = Unicode::GCString->new($str);
my $first_five = $gcs->substr(0, 5);

X 32: Invertire stringa by grafema
L'inversione tramite codepoint incasina i segni diacritici, convertendo erroneamente "creme brulée" in
"eelXurb emXerc" invece di in "eelurb emerc"; quindi invertire invece con il grafema. Entrambi
questi approcci funzionano bene indipendentemente dalla normalizzazione in cui si trova la stringa:

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

# OPPURE: cpan -i Unicode::GCString
usa Unicode::GCString;
$str = Unicode inverso::GCString->new($str);

X 33: Corda lunghezza in grafemi
La stringa "brulée" ha sei grafemi ma fino a otto codepoint. Questo conta per
grafema, non per codepoint:

my $str = "brulée";
mio $conto = 0;
mentre ($str =~ /\X/g) { $conteggio++ }

# OPPURE: cpan -i Unicode::GCString
usa Unicode::GCString;
my $gcs = Unicode::GCString->new($str);
my $count = $gcs->length;

X 34: Unicode larghezza della colonna per stampa
PerlX "printf", "sprintf" e "format" pensano che tutti i codepoint occupino 1 colonna di stampa, ma
molti prendono 0 o 2. Qui per mostrare che la normalizzazione non fa differenza, stampiamo entrambi
le forme:

usa Unicode::GCString;
usa Unicode :: Normalizza;

le mie @parole = qw/creme brulee/;
@parole = mappa { NFC($_), NFD($_) } @parole;

per il mio $str (@words) {
my $gcs = Unicode::GCString->new($str);
my $cols = $gcs->colonne;
my $pad = " " x (10 - $cols);
say str, $pad, " |";
}

genera questo per mostrare che si riempie correttamente indipendentemente dalla normalizzazione:

crema |
creXme |
brulée |
bruXleXe |

X 35: Unicode confronto
Il testo ordinato per punto di codice numerico non segue un ragionevole ordine alfabetico; usa l'UCA per
ordinamento del testo.

usa Unicode::Fascicola;
my $col = Unicode::Collate->new();
my @list = $col->sort(@old_list);

Vedere la ucsort programma dal modulo Unicode::Tussle CPAN per una comoda riga di comando
interfaccia a questo modulo.

X 36: Caso- e insensibile all'accento Unicode sorta
Specificare una forza di confronto di livello 1 per ignorare maiuscole e minuscole e segni diacritici, osservando solo il
carattere fondamentale.

usa Unicode::Fascicola;
my $col = Unicode::Collate->new(level => 1);
my @list = $col->sort(@old_list);

X 37: Unicode località confronto
Alcune impostazioni locali hanno regole di ordinamento speciali.

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

Il Marketplace per le ucsort il programma menzionato sopra accetta un parametro "--locale".

X 38: Fare "cmp" lavoro on testo invece of punti di codice
Invece di questo:

@srecs = ordina {
$b->{ETÀ} <=> $a->{ETÀ}
||
$a->{NOME} cmp $b->{NOME}
} @recs;

Usa questo:

my $coll = Unicode::Collate->new();
per il mio $rec (@recs) {
$rec->{NAME_key} = $coll->getSortKey( $rec->{NAME} );
}
@srecs = ordina {
$b->{ETÀ} <=> $a->{ETÀ}
||
$a->{NAME_key} cmp $b->{NAME_key}
} @recs;

X 39: Caso- e insensibile all'accento confronto
Utilizzare un oggetto fascicolatore per confrontare il testo Unicode per carattere anziché per punto di codice.

usa Unicode::Fascicola;
my $es = Unicode::Fascicola->new(
livello => 1,
normalizzazione => undef
);

# ora entrambi sono veri:
$es->eq("Garcia", "GARCIA");
$es->eq("Marquez", "MARQUEZ");

X 40: Caso- e insensibile all'accento località confronto
Lo stesso, ma in un luogo specifico.

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

# ora questo è vero:
$de->eq("tschuess", "TSCHUESS"); # avviso ue => UE, ss => SS

X 41: Unicode interruzione di riga
Suddividi il testo in righe secondo le regole Unicode.

# cpan -i Unicode::Interruzione di riga
usa Unicode::LineBreak;
usa i nomi dei caratteri qw(:full);

my $para = "Questa è una stringa super\N{HYPHEN}lunga. " x 20;
my $fmt = Unicode::LineBreak->new;
print $fmt->break($para), "\n";

X 42: Unicode testo in DBM hash, , il noioso modo
L'uso di una normale stringa Perl come chiave o valore per un hash DBM attiverà un carattere wide
eccezione se qualsiasi codepoint non entrerà in un byte. Ecco come gestire manualmente il
traduzione:

usa DB_File;
usa Encode qw (codifica decodifica);
tie %dbhash, "DB_File", "percorso";

# NEGOZIO

# supponiamo che $uni_key e $uni_value siano stringhe Unicode astratte
my $enc_key = encode("UTF-8", $uni_key, 1);
my $valore_enc = encode("UTF-8", $valore_uni, 1);
$dbhash{$chiave_enc} = $valore_enc;

# ANDARE A PRENDERE

# supponiamo che $uni_key contenga una normale stringa Perl (astratto Unicode)
my $enc_key = encode("UTF-8", $uni_key, 1);
il mio $enc_value = $dbhash{$enc_key};
my $uni_value = decode("UTF-8", $enc_value, 1);

X 43: Unicode testo in DBM hash, , il facile modo
Ecco come gestire implicitamente la traduzione; tutta la codifica e la decodifica sono state eseguite
automaticamente, proprio come con i flussi a cui è collegata una codifica particolare:

usa DB_File;
usa DBM_Filter;

my $dbobj = tie %dbhash, "DB_File", "percorso";
$dbobj->Filter_Value("utf8"); # questo è il pezzo magico

# NEGOZIO

# supponiamo che $uni_key e $uni_value siano stringhe Unicode astratte
$dbhash{$chiave_uni} = $valore_uni;

# ANDARE A PRENDERE

# $uni_key contiene una normale stringa Perl (Unicode astratto)
il mio $uni_value = $dbhash{$uni_key};

X 44: PROGRAMMA: Demo of Unicode confronto e stampa
HereXs un programma completo che mostra come utilizzare l'ordinamento sensibile alle impostazioni locali, l'involucro Unicode,
e gestire le larghezze di stampa quando alcuni caratteri occupano zero o due colonne, non
solo una colonna ogni volta. Quando viene eseguito, il seguente programma produce questo ben allineato
produzione:

Creme Brulee.......X2.00
Eclair.............X1.60
Fideua................... X4.20
Hamburger......... X6.00
Prosciutto Serrano...... X4.45
Linguica.......... X7.00
Paté ............. X4.15
Pere ............. X2.00
Pesche............. X2.25
Smorbrod......... X5.75
Spaetzle......... X5.50
Xorico................... X3.00
XXXX.............. X6.50
XXX...................X4.00
XXX...................X2.65
XXXX......... X8.00
XXXXXXX.....X1.85
XX.............. X9.99
XX.............. X7.50

Ecco quel programma; testato su v5.14.

#!/usr/bin/env perl
# umenu - demo smistamento e stampa di cibo Unicode
#
# (preambolo obbligatorio e sempre più lungo)
#
usa utf8;
usa v5.14; # per l'ordinamento locale
usare rigorosamente;
utilizzare gli avvisi;
usa gli avvertimenti qw(FATAL utf8); # fatalize errori di codifica
usa open qw(:std:utf8); # stream non dichiarati in UTF-8
usa i nomi dei caratteri qw(:full :short); # non necessario nella v5.16

# moduli standard
usa Unicode :: Normalizza; # distribuzione perl standard a partire dalla v5.8
usa Lista::Util qw(massimo); # std perl distro a partire dalla v5.10
usa Unicode::Collate::Locale; # distribuzione perl standard a partire dalla v5.14

# moduli cpan
usa Unicode::GCString; # da CPAN

# avanti defs
sottopad($$$);
sotto larghezza di banda (_);
sottotitolo (_);

il mio %prezzo = (
"XXXXX" => 6.50, # giroscopi
"pears" => 2.00, # come um, pere
"linguica" => 7.00, # salsiccia piccante, portoghese
"xorico" => 3.00, # chorizo, Catalan
"hamburger" => 6.00, # burgermeister meisterburger
"eclair" => 1.60, # dessert, francese
"smorbrod" => 5.75, # panini, Norvegese
"spaetzle" => 5.50, # Tagliatelle alla Bayerisch, passerotti
"XX" => 7.50, # bao1 zi5, panini di maiale al vapore, Mandarino
"jamon serrano" => 4.45, # prosciutto di campagna, spagnolo
"peches" => 2.25, # pesche, Francese
"XXXXXXX" => 1.85, # pasta frolla ripiena di crema tipo eclair
"XXX" => 4.00, # makgeolli, vino di riso coreano
"XX" => 9.99, # sushi, giapponese
"XXX" => 2.65, # omochi, gallette di riso, giapponese
"creme brulee" => 2.00, # crema catalana
"fideua" => 4.20, # più noodles, valenciano
# (catalano=fideuada)
"pate" => 4.15, # pasta di fegato d'oca, francese
"XXXXX" => 8.00, # okonomiyaki, giapponese
);

my $width = 5 + max map { colwidth } chiavi %prezzo;

# Quindi le cose asiatiche escono in un ordine che qualcuno
# chi legge quegli script non andrà fuori di testa; il
# Le cose CJK saranno nell'ordine JIS X 0208 in questo modo.
my $coll = Unicode::Collate::Locale->new(locale => "ja");

per il mio $elemento ($coll->sort(keys %price)) {
print pad(entitle($item), $width, ".");
printf " X%.2f\n", $prezzo{$oggetto};
}

sottopad($$$) {
mio($str, $larghezza, $carattere) = @_;
restituire $str. ($padchar x ($width - colwidth($str)));
}

sotto colwidth(_) {
mio($str) = @_;
return Unicode::GCString->new($str)->colonne;
}

sottotitolo(_) {
mio($str) = @_;
$str =~ s{ (?=\pL)(\S) (\S*) }
{ ucfirst($1) . lc($2) }xge;
restituire $str;
}

Utilizzare perlunicook online utilizzando i servizi onworks.net