perlunicook - Online en la nube

PROGRAMA:

NOMBRE

perlunicook - ejemplos de libros de cocina sobre el manejo de Unicode en Perl

DESCRIPCIÓN

Esta página de manual contiene recetas breves que demuestran cómo manejar operaciones Unicode comunes
en Perl, más un programa completo al final. Cualquier variable no declarada en individuo
Se supone que las recetas tienen un valor previo apropiado en ellas.

EJEMPLOS

X 0: Estándar preámbulo
A menos que se indique lo contrario, todos los ejemplos a continuación requieren que este preámbulo estándar funcione
correctamente, con el "#!" ajustado para trabajar en su sistema:

#!/ usr / bin / env perl

use utf8; # para que los literales y los identificadores puedan estar en UTF-8
utilizar v5.12; # o posterior para obtener la función "unicode_strings"
uso estricto # citar cadenas, declarar variables
use advertencias; # activado por defecto
use advertencias qw (FATAL utf8); # fatalize los fallos de codificación
use open qw (: std: utf8); # transmisiones no declaradas en UTF-8
use charnames qw (: completo: corto); # innecesario en v5.16

Este sí incluso los programadores de Unix "binmode" sus flujos binarios, o ábralos con
": raw", pero esa es la única forma de llegar a ellos de forma portátil de todos modos.

ADVERTENCIA: "use autodie" (anterior a 2.26) y "use open" no se llevan bien entre sí.

X 1: Generic Experto en Unicode filtrar
Siempre se descompone al entrar y luego se recompone al salir.

use Unicode :: Normalize;

while (<>) {
$ _ = NFD ($ _); # descomponer + reordenar canónicamente
...
} Seguir {
imprimir NFC ($ _); # recomponer (donde sea posible) + reordenar canónicamente
}

X 2: Sintonia FINA Unicode advertencias
A partir de la versión 5.14, Perl distingue tres subclases de advertencias UTFX8.

utilizar v5.14; # advertencias secundarias no disponibles antes
sin advertencias "nonchar"; # los 66 no personajes prohibidos
no hay advertencias "sustitutas"; # UTF-16 / CESU-8 sin sentido
sin advertencias "non_unicode"; # para puntos de código superiores a 0x10_FFFF

X 3: Declarar fuente in utf8 for Identificadores y literales
Sin la declaración crítica "use utf8", poner UTFX8 en sus literales y
Los identificadores no funcionarán correctamente. Si utilizó el preámbulo estándar que se acaba de dar, este
ya pasó. Si lo hizo, puede hacer cosas como esta:

usa utf8;

my $ medida = "Aangstroem";
mi @Xsoft = qw (cp852 cp1251 cp1252);
mi @XXXXXXXXX = qw (XXXX XXXXX);
mi @X = qw (koi8-f koi8-u koi8-r);
my $ lema = "XXX"; # FAMILIA, CORAZÓN CRECIENTE, CAMEL DROMEDARIO

Si olvida "use utf8", los bytes altos se malinterpretarán como caracteres separados y
nada funcionará bien.

X 4: Personajes y their números
Las funciones "ord" y "chr" funcionan de forma transparente en todos los puntos de código, no solo en ASCII
solo X ni, de hecho, ni siquiera solo en Unicode.

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

# caracteres del plano multilingüe básico
ord ("X")
chr(0x3A3)

# más allá del BMP
ord ("X") # MATEMÁTICO ITALICO PEQUEÑO N
chr(0x1D45B)

# ¡más allá de Unicode! (hasta MAXINT)
ord ("\ x {20_0000}")
chr(0x20_0000)

X 5: Unicode literales by personaje número
En un literal interpolado, ya sea una cadena entre comillas dobles o una expresión regular, puede especificar una
carácter por su número usando el "\ x {HHHHHH} " escapar.

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

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

# incluso los rangos que no son BMP en expresiones regulares funcionan bien
/ [\ x {1D434} - \ x {1D467}] /

X 6: Get personaje nombre by número
usar nombres de caracteres ();
my $ nombre = nombres de caracteres ::vía código(0x03A3);

X 7: Get personaje número by nombre
usar nombres de caracteres ();
my $ number = charnames :: vianame ("LETRA GRIEGA MAYÚSCULA SIGMA");

X 8: Unicode llamado personajes
Utilice el "\ N {nombre del personaje}" notación para obtener el carácter con ese nombre para su uso en interpolados
literales (cadenas entre comillas dobles y expresiones regulares). En v5.16, hay un implícito

use charnames qw (: completo: corto);

Pero antes de v5.16, debe ser explícito sobre qué conjunto de nombres de caracteres desea. El
Los nombres ": completos" son el nombre, el alias o la secuencia oficial de caracteres Unicode, que todos comparten
un espacio de nombres.

use charnames qw (: completo: griego latino corto);

"\ N {MATHEMATICAL ITALIC SMALL N}" #: completo
"\ N {LETRA MAYÚSCULA GRIEGA SIGMA}" #: completo

Cualquier otra cosa es una abreviatura de conveniencia específica de Perl. Especifique uno o más scripts por
nombres si desea nombres cortos que sean específicos del script.

"\ N {Griego: Sigma}" #: corto
"\ N {ae}" # latín
"\ N {épsilon}" # griego

La versión v5.16 también admite una importación ": suelta" para coincidencias sueltas de nombres de caracteres,
que funciona como una coincidencia imprecisa de nombres de propiedad: es decir, ignora las mayúsculas y minúsculas,
espacios en blanco y guiones bajos:

"\ N {símbolo del euro}" #: suelto (de v5.16)

X 9: Unicode llamado secuencias
Estos se parecen a los nombres de los personajes, pero devuelven varios puntos de código. Observe el% vx
funcionalidad de impresión vectorial en "printf".

usar nombres de caracteres qw (: completo);
my $ seq = "\ N {LETRA A MAYÚSCULA LATINA CON MACRON Y GRAVE}";
printf "U +% v04X \ n", $ seq;
U + 0100.0300

X 10: Personalizado llamado personajes
Utilice ": alias" para dar sus propios apodos de ámbito léxico a los caracteres existentes, o incluso
para dar nombres útiles a los caracteres de uso privado sin nombre.

use charnames ": full", ": alias" => {
ecute => "LETRA E MINÚSCULA LATINA CON AGUDO",
"APPLE LOGO" => 0xF8FF, # carácter de uso privado
};

"\ N {ecute}"
"\ N {LOGOTIPO DE APPLE}"

X 11: nombres of CJK puntos de código
Los sinogramas como XXXX vuelven con los nombres de los caracteres "CJK UNIFIED IDEOGRAPH-6771" y
"CJK UNIFIED IDEOGRAPH-4EAC", porque sus XnamesX varían. El CPAN "Unicode :: Unihan"
El módulo tiene una gran base de datos para decodificar estos (y muchos más), siempre que sepa
cómo entender su salida.

# cpan -i Unicode :: Unihan
use Unicode :: Unihan;
my $ str = "XX";
my $ unhan = Unicode :: Unihan-> nuevo;
para mi $ lang (qw (mandarín cantonés coreano JapaneseOn JapaneseKun)) {
printf "CJK $ str en% -12s es", $ lang;
digamos $ unhan -> $ lang ($ str);
}

huellas dactilares:

CJK XX en mandarín es DONG1JING1
CJK XX en cantonés es estiércol1
CJK XX en coreano es TONGKYENG
CJK XX en japonésOn es TOUKYOU KEI KIN
CJK XX en japonésKun es HIGASHI AZUMAMIYAKO

Si tiene un esquema de romanización específico en mente, use el módulo específico:

# cpan -i Lingua :: JA :: Romanize :: Japonés
use Lingua :: JA :: Romanize :: Japanese;
my $ k2r = Lingua :: JA :: Romanize :: Japanese-> new;
my $ str = "XX";
decir "japonés para $ str es", $ k2r-> chars ($ str);

huellas dactilares

Japonés para XX es toukyou

X 12: Explícito codificar descodificar
En raras ocasiones, como la lectura de una base de datos, es posible que se le proporcione texto codificado que necesita
descodificar.

use Codificar qw (codificar decodificar);

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

Para todos los flujos en la misma codificación, no use codificar / decodificar; en su lugar, configure el archivo
codificación al abrir el archivo o inmediatamente después con "binmode" como se describe más adelante
abajo.

X 13: Descodificar programa argumentos as utf8
$ perl-CA...
or
$ exportación PERL_UNICODE = A
or
use Codificar qw (decode_utf8);
@ARGV = mapa {decode_utf8 ($ _, 1)} @ARGV;

X 14: Descodificar programa argumentos as local codificación
# cpan -i Encode :: Locale
use Encode qw (configuración regional);
use Encode :: Locale;

# use "locale" como un argumento para codificar / decodificar
@ARGV = mapa {decodificar (configuración regional => $ _, 1)} @ARGV;

X 15: Declarar STD {ENTRADA, SALIDA, ERR} a be utf8
Utilice una opción de línea de comandos, una variable de entorno o, de lo contrario, llame a "binmode" explícitamente:

$ perl-CS...
or
$ exportación PERL_UNICODE = S
or
use open qw (: std: utf8);
or
binmode (STDIN, ": utf8");
binmode (STDOUT, ": utf8");
binmode (STDERR, ": utf8");

X 16: Declarar STD {ENTRADA, SALIDA, ERR} a be in local codificación
# cpan -i Encode :: Locale
usar Codificar;
use Encode :: Locale;

# o como flujo para binmode o open
binmode STDIN, ": codificación (consola_en)" if -t STDIN;
binmode STDOUT, ": codificación (consola_salida)" if -t STDOUT;
binmode STDERR, ": codificación (consola_salida)" if -t STDERR;

X 17: Haz presentar I / O tu préstamo estudiantil a utf8
Los archivos abiertos sin un argumento de codificación estarán en UTF-8:

$ perl-CD...
or
$ exportación PERL_UNICODE = D
or
use open qw (: utf8);

X 18: Haz all I / O y args tu préstamo estudiantil a utf8
$ perl-CSDA...
or
$ exportación PERL_UNICODE = SDA
or
use open qw (: std: utf8);
use Codificar qw (decode_utf8);
@ARGV = mapa {decode_utf8 ($ _, 1)} @ARGV;

X 19: Abierto presentar con soluciones y codificación
Especifique la codificación de la transmisión. Esta es la forma normal de tratar el texto codificado, no llamando
funciones de bajo nivel.

# fichero de entrada
open (my $ in_file, "<: codificación (UTF-16)", "wintext");
OR
open (my $ in_file, "<", "wintext");
binmode ($ in_file, ": codificación (UTF-16)");
ENTONCES
my $ línea = <$ in_file>;

# archivo de salida
open ($ out_file, ">: codificación (cp1252)", "wintext");
OR
open (mi $ out_file, ">", "wintext");
binmode ($ out_file, ": codificación (cp1252)");
ENTONCES
print $ out_file "algún texto \ n";

Aquí se pueden especificar más capas además de la codificación. Por ejemplo, el encantamiento
": raw: encoding (UTF-16LE): crlf" incluye manejo CRLF implícito.

X 20: Unicode caja
La carcasa Unicode es muy diferente a la carcasa ASCII.

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

# ambos son verdaderos:
"tschuess" = ~ / TSCHUeSS / i # aviso ss => SS
"XXXXXXX" = ~ / XXXXXXX / i # note la igualdad de X, X, X

X 21: Unicode no distingue entre mayúsculas y minúsculas comparaciones
También disponible en el módulo CPAN Unicode :: CaseFold, la nueva función "fc" XfoldcaseX de
v5.16 otorga acceso al mismo plegado de mayúsculas y minúsculas Unicode que tiene el modificador de patrón "/ i"
siempre usado:

utilizar la función "fc"; La función # fc () es de v5.16

# ordenar sin distinción entre mayúsculas y minúsculas
my @sorted = sort {fc ($ a) cmp fc ($ b)} @list;

# ambos son verdaderos:
fc ("tschuess") eq fc ("TSCHUeSS")
fc ("XXXXXXX") eq fc ("XXXXXXX")

X 22: Match Unicode salto de línea secuencia in expresiones regulares
Un salto de línea Unicode coincide con el grafema CRLF de dos caracteres o cualquiera de los siete verticales
caracteres de espacio en blanco. Bueno para tratar con archivos de texto provenientes de diferentes operaciones
.

\R

s / \ R / \ n / g; # normalizar todos los saltos de línea a \ n

X 23: Get personaje categoría
Busque la categoría general de un punto de código numérico.

use Unicode :: UCD qw (charinfo);
mi $ gato = charinfo(0x3A3) -> {categoría}; # "Lu"

X 24: Inhabilitando Conciencia Unicode in incorporado clases de char
Desactive "\ w", "\ b", "\ s", "\ d" y las clases POSIX para que no funcionen correctamente en Unicode
ya sea en este ámbito, o en una sola expresión regular.

utilizar v5.14;
use re "/ a";

# O

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

O use propiedades específicas un-Unicode, como "\ p {ahex}" y "\ p {POSIX_Digit"}. Propiedades
todavía funcionan normalmente sin importar qué modificadores de juego de caracteres ("/ d / u / l / a / aa") deberían tener efecto.

X 25: Match Unicode propiedades in expresiones regulares con \pags, \P
Todos estos coinciden con un solo punto de código con la propiedad dada. Utilice "\ P" en lugar de "\ p" para
coincidir con un punto de código que carece de esa propiedad.

\ pL, \ pN, \ pS, \ pP, \ pM, \ pZ, \ pC
\ p {Sk}, \ p {Ps}, \ p {Lt}
\ p {alpha}, \ p {superior}, \ p {inferior}
\ p {latín}, \ p {griego}
\ p {script = Latin}, \ p {script = griego}
\ p {East_Asian_Width = Wide}, \ p {EA = W}
\ p {Line_Break = Guión}, \ p {LB = HY}
\ p {Numeric_Value = 4}, \ p {NV = 4}

X 26: Personalizado personaje propiedades
Defina en tiempo de compilación sus propias propiedades de carácter personalizadas para usar en expresiones regulares.

# usando caracteres de uso privado
sub In_Tengwar {"E000 \ tE07F \ n"}

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

# mezcla de propiedades existentes
sub Is_GraecoRoman_Title {<< 'END_OF_SET'}
+ utf8 :: IsLatin
+ utf8 :: IsGreek
& utf8 :: IsTitle
END_OF_SET

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

X 27: Unicode normalización
Normalmente se procesa en NFD en la entrada y NFC en la salida. Uso de funciones NFKC o NFKD
mejora la memoria en las búsquedas, asumiendo que ya ha realizado la búsqueda en el mismo texto.
Tenga en cuenta que esto es mucho más que glifos de compatibilidad combinados previamente; también
reordena las marcas de acuerdo con sus clases canónicas de combinación y elimina los singletons.

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

X 28: Convertir no ASCII Unicode numéricos
A menos que haya usado "/ a" o "/ aa", "\ d" solo coincide con más dígitos ASCII, pero PerlXs
La conversión implícita de cadena a número no los reconoce actualmente. Aquí le explicamos cómo
convertir dichas cadenas manualmente.

utilizar v5.14; # necesario para la función num ()
use Unicode :: UCD qw (num);
my $ str = "tengo X y XXXX y X y aquí";
mi @nums = ();
while ($ str = ~ / (\ d + | \ N) / g) {# ¡no solo ASCII!
presione @nums, num ($ 1);
}
di "@nums"; # 12 4567 0.875

usar nombres de caracteres qw (: completo);
my $ nv = num ("\ N {RUMI DIGIT ONE} \ N {RUMI DIGIT DOS}");

X 29: Match Unicode grafema grupo in expresiones regulares
Los caracteres X visibles para el programador son puntos de código que coinciden con "/./s", pero son visibles para el usuario.
XcaracteresX son grafemas que coinciden con "/ \ X /".

# Busque la vocal * más * cualquier combinación de signos diacríticos, subrayado, etc.
my $ nfd = NFD ($ orig);
$ nfd = ~ / (? = [aeiou]) \ X / xi

X 30: Extraer by grafema of by punto de código (expresión regular)
# empareja y agarra cinco primeros grafemas
mi ($ primeros_cinco) = $ str = ~ / ^ (\ X {5}) / x;

X 31: Extraer by grafema of by punto de código (sustancia)
# cpan -i Unicode :: GCString
use Unicode :: GCString;
my $ gcs = Unicode :: GCString-> nuevo ($ str);
my $ first_five = $ gcs-> substr (0, 5);

X 32: Marcha atrás cadena by grafema
Invertir por punto de código estropea los diacríticos, convirtiendo por error "creme brulee" en
"eelXurb emXerc" en lugar de "eelurb emerc"; así que invierte por grafema en su lugar. Ambos
estos enfoques funcionan correctamente sin importar en qué normalización se encuentre la cadena:

$ str = unirse ("", invertir $ str = ~ / \ X / g);

# O: cpan -i Unicode :: GCString
use Unicode :: GCString;
$ str = Unicode inverso :: GCString-> nuevo ($ str);

X 33: Cordón de largo in grafemas
La cadena "brulee" tiene seis grafemas pero hasta ocho puntos de código. Esto cuenta por
grafema, no por punto de código:

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

# O: cpan -i Unicode :: GCString
use Unicode :: GCString;
my $ gcs = Unicode :: GCString-> nuevo ($ str);
my $ count = $ gcs-> length;

X 34: Unicode ancho de columna for impresión
PerlXs "printf", "sprintf" y "format" creen que todos los puntos de código ocupan 1 columna de impresión, pero
muchos toman 0 o 2. Aquí para mostrar que la normalización no hace ninguna diferencia, imprimimos ambos
formas:

use Unicode :: GCString;
use Unicode :: Normalize;

mis @palabras = qw / creme brulee /;
@palabras = mapa {NFC ($ _), NFD ($ _)} @palabras;

para mis $ str (@words) {
my $ gcs = Unicode :: GCString-> nuevo ($ str);
mis $ cols = $ gcs-> columnas;
my $ pad = "" x (10 - $ columnas);
say str, $ pad, "|";
}

genera esto para mostrar que se rellena correctamente sin importar la normalización:

crema |
crema |
brulée |
bruXleXe |

X 35: Unicode colación
El texto ordenado por punto de código numérico no sigue un orden alfabético razonable; utilizar la UCA para
ordenar texto.

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

Consulte las sortear programa desde el módulo Unicode :: Tussle CPAN para una conveniente línea de comandos
interfaz a este módulo.

X 36: Caso- y insensible al acento Unicode sort
Especifique una fuerza de intercalación de nivel 1 para ignorar mayúsculas y minúsculas y signos diacríticos, solo mirando el
carácter básico.

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

X 37: Unicode local colación
Algunas configuraciones regionales tienen reglas de clasificación especiales.

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

El sistema sortear El programa mencionado anteriormente acepta un parámetro "--locale".

X 38: Realizar "cmp" Trabaja on texto of puntos de código
En lugar de esto:

@srecs = ordenar {
$ b -> {EDAD} <=> $ a -> {EDAD}
||
$ a -> {NOMBRE} cmp $ b -> {NOMBRE}
} @recs;

Utilizar esta:

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

X 39: Caso- y insensible al acento comparaciones
Utilice un objeto clasificador para comparar texto Unicode por carácter en lugar de por punto de código.

use Unicode :: Collate;
my $ es = Unicode :: Collate-> new (
nivel => 1,
normalización => indef
);

# ahora ambos son verdaderos:
$ es-> eq ("García", "GARCIA");
$ es-> eq ("Márquez", "MÁRQUEZ");

X 40: Caso- y insensible al acento local comparaciones
Lo mismo, pero en un lugar específico.

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

# ahora esto es cierto:
$ de> eq ("tschuess", "TSCHUESS"); # aviso ue => UE, ss => SS

X 41: Unicode saltos de línea
Divida el texto en líneas de acuerdo con las reglas Unicode.

# cpan -i Unicode :: LineBreak
use Unicode :: LineBreak;
usar nombres de caracteres qw (: completo);

my $ para = "Esta es una cadena super \ N {GUIÓN} larga." x 20;
my $ fmt = Unicode :: LineBreak-> nuevo;
print $ fmt-> break ($ ​​para), "\ n";

X 42: Unicode texto in DBM hashes de la forma más tedioso way
El uso de una cadena de Perl normal como clave o valor para un hash de DBM activará un carácter ancho
Excepción si algún punto de código no cabe en un byte. Aquí se explica cómo gestionar manualmente el
traducción:

utilizar DB_Archivo;
use Codificar qw (codificar decodificar);
tie% dbhash, "DB_File", "nombre de ruta";

# TIENDA

# suponga que $ uni_key y $ uni_value son cadenas Unicode abstractas
my $ enc_key = encode ("UTF-8", $ uni_key, 1);
my $ enc_value = encode ("UTF-8", $ uni_value, 1);
$ dbhash {$ enc_key} = $ enc_value;

# HA PODIDO RECUPERAR

# suponga que $ uni_key contiene una cadena Perl normal (Unicode abstracto)
my $ enc_key = encode ("UTF-8", $ uni_key, 1);
my $ enc_value = $ dbhash {$ enc_key};
my $ uni_value = decode ("UTF-8", $ enc_value, 1);

X 43: Unicode texto in DBM hashes de la forma más de forma sencilla way
Aquí se explica cómo gestionar implícitamente la traducción; toda la codificación y decodificación está hecha
automáticamente, al igual que con las transmisiones que tienen una codificación particular adjunta:

utilizar DB_Archivo;
usar DBM_Filtro;

my $ dbobj = tie% dbhash, "DB_File", "nombre de ruta";
$ dbobj-> Filter_Value ("utf8"); # esta es la parte mágica

# TIENDA

# suponga que $ uni_key y $ uni_value son cadenas Unicode abstractas
$ dbhash {$ uni_key} = $ uni_value;

# HA PODIDO RECUPERAR

# $ uni_key contiene una cadena Perl normal (Unicode abstracto)
my $ uni_value = $ dbhash {$ uni_key};

X 44: PROGRAMA: Demostración of Unicode colación y impresión
HereXs un programa completo que muestra cómo hacer uso de la clasificación sensible a la configuración regional, mayúsculas y minúsculas Unicode,
y administrar los anchos de impresión cuando algunos de los caracteres ocupan cero o dos columnas, no
solo una columna cada vez. Cuando se ejecuta, el siguiente programa produce este bien alineado
salida:

Creme Brulee ....... X2.00
Eclair ............. X1.60
Fideua ............. X4.20
Hamburguesa .......... X6.00
Jamón Serrano ...... X4.45
Linguica ........... X7.00
Paté ............... X4.15
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

Aquí está ese programa; probado en v5.14.

#!/ usr / bin / env perl
# umenu - clasificación e impresión de demostración de alimentos Unicode
#
# (preámbulo obligatorio y cada vez más largo)
#
usa utf8;
utilizar v5.14; # para ordenar la configuración regional
uso estricto
use advertencias;
use advertencias qw (FATAL utf8); # fatalize las fallas de codificación
use open qw (: std: utf8); # transmisiones no declaradas en UTF-8
use charnames qw (: completo: corto); # innecesario en v5.16

# módulos std
use Unicode :: Normalize; # std perl distro a partir de v5.8
use List :: Util qw(máx.); # std perl distro a partir de v5.10
use Unicode :: Collate :: Locale; # std perl distro a partir de v5.14

# módulos cpan
use Unicode :: GCString; # de CPAN

# defs hacia adelante
sub pad ($$$);
sub colwidth (_);
sub derecho (_);

mi% precio = (
"XXXXX" => 6.50, # giroscopios
"peras" => 2.00, # como um, peras
"linguica" => 7.00, # salchicha picante, portugués
"xorico" => 3.00, # chorizo, catalán
"hamburguesa" => 6.00, # burgermeister meisterburger
"eclair" => 1.60, # postre, francés
"smorbrod" => 5.75, # sándwiches, noruego
"spaetzle" => 5.50, # Fideos Bayerisch, gorriones pequeños
"XX" => 7.50, # bao1 zi5, bollos de cerdo al vapor, mandarina
"jamon serrano" => 4.45, # jamon campestre, español
"peches" => 2.25, # melocotones, francés
"XXXXXXX" => 1.85, # pasteles rellenos de crema como eclair
"XXX" => 4.00, # makgeolli, vino de arroz coreano
"XX" => 9.99, # sushi, japonés
"XXX" => 2.65, # omochi, pasteles de arroz, japonés
"creme brulee" => 2.00, # crema catalana
"fideua" => 4.20, # más fideos, valenciano
# (Catalán = fideuada)
"paté" => 4.15, # pasta gooseliver, francés
"XXXXX" => 8.00, # okonomiyaki, japonés
);

my $ width = 5 + max map {colwidth} claves% precio;

# Entonces las cosas asiáticas salen en un orden en el que alguien
# quien lea esos guiones no se asustará; el
# Las cosas de CJK estarán en el orden JIS X 0208 de esa manera.
my $ coll = Unicode :: Collate :: Locale-> new (locale => "ja");

para mi $ artículo ($ coll-> sort (keys% price)) {
almohadilla de impresión (titular ($ artículo), $ ancho, ".");
printf "X% .2f \ n", $ precio {$ artículo};
}

sub pad ($$$) {
my ($ str, $ ancho, $ padchar) = @_;
return $ str. ($ padchar x ($ ancho - colwidth ($ str)));
}

sub colwidth (_) {
mi ($ str) = @_;
return Unicode :: GCString-> new ($ str) -> columnas;
}

sub derecho (_) {
mi ($ str) = @_;
$ str = ~ s {(? = \ pL) (\ S) (\ S *)}
{ucfirst ($ 1). lc ($ 2)} xge;
return $ str;
}

Use perlunicook en línea usando los servicios de onworks.net