perluniintro - Online en la nube

PROGRAMA:

NOMBRE

perluniintro - Introducción a Perl Unicode

DESCRIPCIÓN

Este documento da una idea general de Unicode y cómo usar Unicode en Perl. Ver
"Recursos adicionales" para obtener referencias a tratamientos más detallados de Unicode.

Unicode
Unicode es un estándar de juego de caracteres que planea codificar todos los sistemas de escritura de
el mundo, además de muchos otros símbolos.

Unicode e ISO / IEC 10646 son estándares coordinados que unifican casi todos los demás
estándares de juegos de caracteres, que cubren más de 80 sistemas de escritura y cientos de idiomas,
incluyendo todos los lenguajes modernos comercialmente importantes. Todos los personajes de la mayor
Los diccionarios de chino, japonés y coreano también están codificados. Los estándares eventualmente
cubre casi todos los caracteres en más de 250 sistemas de escritura y miles de idiomas.
Unicode 1.0 se lanzó en octubre de 1991 y 6.0 en octubre de 2010.

Unicode personaje es una entidad abstracta. No está vinculado a ningún número entero en particular.
ancho, especialmente no para el lenguaje C "char". Unicode es lenguaje neutro y display-
neutral: no codifica el lenguaje del texto, y generalmente no define
fuentes u otros detalles de diseño gráfico. Unicode opera en caracteres y en texto construido
de esos personajes.

Unicode define caracteres como "LETRA A MAYÚSCULA LATINA" o "LETRA ALFA GRIEGA MINÚSCULA" y
números únicos para los caracteres, en este caso 0x0041 y 0x03B1, respectivamente. Estos
se llaman números únicos código puntos. Un punto de código es esencialmente la posición del
carácter dentro del conjunto de todos los caracteres Unicode posibles y, por lo tanto, en Perl, el término
ordinal a menudo se usa indistintamente con él.

El estándar Unicode prefiere usar notación hexadecimal para los puntos de código. Si numeros
como 0x0041 no le resultan familiares, eche un vistazo a una sección posterior, "Notación hexadecimal".
El estándar Unicode utiliza la notación "U+0041 LETRA A MAYÚSCULA LATINA", para dar la
punto de código hexadecimal y el nombre normativo del carácter.

Unicode también define varios propiedades para los caracteres, como "mayúsculas" o
"minúscula", "dígito decimal" o "puntuación"; estas propiedades son independientes de la
nombres de los personajes. Además, varias operaciones en los personajes como
se definen mayúsculas, minúsculas y clasificación (clasificación).

Unicode lógico "personaje" en realidad puede constar de más de un real
"carácter" o punto de código. Para las lenguas occidentales, esto está adecuadamente modelado por un bases
personaje (como "LETRA A MAYÚSCULA LATINA") seguida de una o más modificadores (como el
"COMBINACIÓN DE ACENTO AGUDO"). Esta secuencia de caracteres base y modificadores se llama
combinar personaje secuencia. Algunos idiomas no occidentales requieren modelos más complicados,
por lo que Unicode creó el grafema grupo concepto, que luego se refinó aún más en el
extendido grafema grupo. Por ejemplo, una sílaba Hangul coreana se considera una sola
carácter lógico, pero la mayoría de las veces consta de tres caracteres Unicode reales: un
consonante seguida de una vocal interior seguida de una consonante final.

El hecho de llamar "caracteres" a estos grupos de grafemas extendidos depende de su punto de vista
vista. Si es un programador, probablemente tenderá a ver cada elemento en el
secuencias como una unidad, o "carácter". Sin embargo, desde el punto de vista del usuario, el conjunto
La secuencia podría verse como un "carácter", ya que probablemente sea así como se ve en la
contexto del idioma del usuario. En este documento, tomamos el punto de vista del programador:
un "carácter" es un punto de código Unicode.

Para algunas combinaciones de caracteres base y modificadores, hay precompuesto personajes.
Hay un solo carácter equivalente, por ejemplo, para la secuencia "LATIN CAPITAL
LETRA A "seguida de" COMBINACIÓN DE ACENTO AGUDO ". Se llama" LETRA A MAYÚSCULA LATINA
CON AGUDO". Sin embargo, estos caracteres precompuestos solo están disponibles para algunos
combinaciones, y están destinadas principalmente a admitir conversiones de ida y vuelta entre Unicode y
estándares heredados (como ISO 8859). El uso de secuencias, como hace Unicode, permite necesitar
menos bloques de construcción básicos (puntos de código) para expresar muchos más grafemas potenciales
racimos. Para admitir la conversión entre formas equivalentes, varios normalización Formularios están
también definido. Por lo tanto, "LETRA A MAYÚSCULA LATINA CON AGUDO" está en Normalización Formulario
Compuesto, (NFC abreviado), y la secuencia "LETRA A MAYÚSCULA LATINA" seguida de
"COMBINING AGUTE ACCENT" representa el mismo carácter en Normalización Formulario Descompuesto
(DFN).

Debido a la compatibilidad con las codificaciones heredadas, "un número único para cada
carácter "la idea se desglosa un poco: en cambio, hay" al menos un número para cada
personaje". El mismo personaje podría ser representado de manera diferente en varios legados
codificaciones. Lo contrario no es cierto: algunos puntos de código no tienen un carácter asignado.
En primer lugar, hay puntos de código no asignados dentro de bloques que de otro modo se usarían. En segundo lugar, hay
son caracteres especiales de control Unicode que no representan caracteres verdaderos.

Cuando se concibió Unicode por primera vez, se pensó que todos los personajes del mundo podrían ser
representado mediante una palabra de 16 bits; que es un máximo de 0x10000 (o 65,536) caracteres
ser necesario, de 0x0000 a 0xFFFF. Esto pronto resultó ser incorrecto, y dado que Unicode 2.0
(Julio de 1996), Unicode se ha definido hasta 21 bits (0x10FFFF) y Unicode
3.1 (marzo de 2001) definió los primeros caracteres por encima de 0xFFFF. Los primeros caracteres 0x10000
se llaman los Avión 0, o el Básico Multilingüe Avión (BMP). Con Unicode 3.1, 17 (sí,
diecisiete) planos en total fueron definidos, pero no están ni cerca de estar llenos de definidos
personajes, todavía.

Cuando se codifica un nuevo idioma, Unicode generalmente elegirá un "bloque" de
puntos de código consecutivos no asignados para sus caracteres. Hasta ahora, la cantidad de puntos de código
en estos bloques siempre ha sido uniformemente divisible por 16. Extras en un bloque, no actualmente
necesarios, se dejan sin asignar, para el crecimiento futuro. Pero ha habido ocasiones en las que un
la versión posterior necesitaba más puntos de código que los extras disponibles, y un nuevo bloque tenía que
asignado en otro lugar, no contiguo al inicial, para manejar el desbordamiento.
Por lo tanto, se hizo evidente desde el principio que "bloque" no era un principio organizativo adecuado,
y así se creó la propiedad "Script". (Más tarde se agregó una propiedad de script mejorada como
bueno, la propiedad "Script_Extensions".) Los puntos de código que están en bloques de desbordamiento
aún pueden tener el mismo guión que los originales. El concepto de guión encaja mejor
con lenguaje natural: hay escritura "latina", escritura "griega", etc. y aquí están
varios guiones artificiales, como "Común" para los caracteres que se utilizan en varios
guiones, como símbolos matemáticos. Los guiones suelen abarcar partes variadas de varios
bloques. Para obtener más información sobre los scripts, consulte "Scripts" en perlunicode. La división
en bloques existe, pero es casi completamente accidental - un artefacto de cómo el
Se han asignado y todavía se asignan caracteres. (Tenga en cuenta que este párrafo tiene
cosas demasiado simplificadas en aras de que esto sea una introducción. Unicode realmente no
codificar idiomas, pero los sistemas de escritura para ellos: sus escrituras; y un guión puede ser
utilizado por muchos idiomas. Unicode también codifica cosas que no se tratan realmente de idiomas,
como símbolos como "RECLAMO DE EQUIPAJE".)

Los puntos de código Unicode son solo números abstractos. Para ingresar y sacar estos resúmenes
números, los números deben ser codificado or serializado de algun modo. Unicode define varios
personaje codificación Formularios, De los cuales UTF-8 es el más popular. UTF-8 es una longitud variable
codificación que codifica caracteres Unicode de 1 a 4 bytes. Otras codificaciones incluyen UTF-16
y UTF-32 y sus variantes big y little-endian (UTF-8 es independiente del orden de bytes).
La ISO / IEC 10646 define las formas de codificación UCS-2 y UCS-4.

Para obtener más información acerca de las codificaciones, por ejemplo, para saber qué sustitutas y byte
solicite marcas (BOM) son - ver perlunicode.

Perl's Unicode Soporte
A partir de Perl v5.6.0, Perl ha tenido la capacidad de manejar Unicode de forma nativa. Perl
La v5.8.0, sin embargo, es la primera versión recomendada para trabajos Unicode serios. El
La versión de mantenimiento 5.6.1 solucionó muchos de los problemas del Unicode inicial.
implementación, pero por ejemplo, las expresiones regulares todavía no funcionan con Unicode en
5.6.1. Perl v5.14.0 es la primera versión en la que la compatibilidad con Unicode es (casi) perfecta
integrable sin algunas trampas (la excepción son algunas diferencias en quotemeta, y
que está arreglado a partir de Perl 5.16.0). Para habilitar este soporte perfecto, debe "utilizar
feature 'unicode_strings' "(que se selecciona automáticamente si" usa 5.012 "o superior).
Ver característica. (5.14 también corrige una serie de errores y desviaciones del estándar Unicode).

Antes de Perl v5.8.0, el uso de "use utf8" se usaba para declarar que las operaciones en el
El bloque o archivo actual sería compatible con Unicode. Se encontró que este modelo era incorrecto, o en
menos torpe: el "Unicodeness" ahora se lleva con los datos, en lugar de estar adjunto a
las operaciones. A partir de Perl v5.8.0, solo queda un caso en el que un "uso explícito
utf8 "es necesario: si su propio script de Perl está codificado en UTF-8, puede usar UTF-8 en su
nombres de identificadores, y en cadenas y literales de expresiones regulares, diciendo "use utf8".
Este no es el valor predeterminado porque los scripts con datos heredados de 8 bits se romperían. Ver
utf8.

Perl's Unicode Modelo
Perl admite cadenas de bytes nativos de ocho bits anteriores a 5.6 y cadenas de Unicode
caracteres. El principio general es que Perl intenta mantener sus datos en bytes de ocho bits.
durante el mayor tiempo posible, pero tan pronto como no se pueda evitar la Unicodeness, los datos se
actualizado de forma transparente a Unicode. Antes de Perl v5.14.0, la actualización no estaba completamente
transparente (ver "El" Error Unicode "" en perlunicode), y para compatibilidad con versiones anteriores,
no se obtiene transparencia total a menos que "use la función 'unicode_strings'" (ver función) o
Está seleccionado "use 5.012" (o superior).

Internamente, Perl utiliza actualmente cualquiera de los conjuntos de caracteres nativos de ocho bits del
La plataforma (por ejemplo, Latin-1) es, por defecto, UTF-8, para codificar cadenas Unicode.
Específicamente, si todos los puntos de código en la cadena son 0xFF o menos, Perl usa el nativo
conjunto de caracteres de ocho bits. De lo contrario, utiliza UTF-8.

Un usuario de Perl normalmente no necesita saber ni preocuparse de cómo Perl codifica su
cadenas internas, pero se vuelve relevante cuando se generan cadenas Unicode en una secuencia
sin una capa PerlIO (una con la codificación "predeterminada"). En tal caso, los bytes sin procesar
utilizado internamente (el juego de caracteres nativo o UTF-8, según corresponda para cada cadena)
se utilizará, y se emitirá una advertencia de "carácter ancho" si esas cadenas contienen un
carácter más allá de 0x00FF.

Por ejemplo,

perl -e 'imprimir "\ x {DF} \ n", "\ x {0100} \ x {DF} \ n"'

produce una mezcla bastante inútil de bytes nativos y UTF-8, así como una advertencia:

Amplio carácter impreso en ...

Para generar UTF-8, use la capa de salida ": encoding" o ": utf8". Anteponiendo

binmode (STDOUT, ": utf8");

a este programa de muestra asegura que la salida sea completamente UTF-8, y elimina el
advertencia del programa.

Puede habilitar la UTF-8-ificación automática de sus identificadores de archivo estándar, por defecto "open ()"
layer, y @ARGV usando el modificador de línea de comando "-C" o el "PERL_UNICODE"
variable de entorno, consulte perlrun para obtener la documentación del conmutador "-C".

Tenga en cuenta que esto significa que Perl espera que otro software funcione de la misma manera: si Perl tiene
se le ha hecho creer que STDIN debería ser UTF-8, pero luego STDIN procedente de otro
El comando no es UTF-8, Perl probablemente se quejará del formato UTF-8 incorrecto.

Todas las funciones que combinan Unicode y E / S también requieren el uso de la nueva función PerlIO.
Sin embargo, casi todas las plataformas Perl 5.8 usan PerlIO: puede ver si la suya es por
ejecutando "perl -V" y buscando "useperlio = define".

Unicode y EBCDIC
Perl 5.8.0 agregó soporte para Unicode en plataformas EBCDIC. Este apoyo se permitió
caduca en versiones posteriores, pero se revivió en 5.22. El soporte Unicode es algo más
complejo de implementar ya que se necesitan conversiones adicionales. Ver perlebcdic para más


En las plataformas EBCDIC, la forma de codificación Unicode interna es UTF-EBCDIC en lugar de UTF-8.
La diferencia es que, dado que UTF-8 es "seguro para ASCII", los caracteres ASCII se codifican en UTF-8
tal cual, mientras que UTF-EBCDIC es "seguro para EBCDIC", ya que todos los caracteres básicos (que incluyen
todos aquellos que tienen equivalentes ASCII (como "A", "0", "%", etc.) son iguales en ambos
EBCDIC y UTF-EBCDIC. A menudo, la documentación utilizará el término "UTF-8" para referirse a UTF-EBCDIC
también. Este es el caso de este documento.

Creamos Unicode
Esta sección se aplica completamente a Perls a partir de v5.22. Varias advertencias para antes
las versiones se encuentran en la subsección "Advertencias de versiones anteriores" a continuación.

Para crear caracteres Unicode en literales, utilice la notación "\ N {...}" entre comillas dobles
instrumentos de cuerda:

my $ smiley_from_name = "\ N {CARA SONRIENTE BLANCA}";
my $ smiley_from_code_point = "\ N {U + 263a}";

De manera similar, se pueden usar en literales de expresiones regulares.

$ smiley = ~ / \ N {CARA SONRIENTE BLANCA} /;
$ emoticón = ~ / \ N {U + 263a} /;

En tiempo de ejecución puede utilizar:

usar nombres de caracteres ();
my $ hebrew_alef_from_name
= charnames :: string_vianame ("LETRA HEBREA ALEF");
my $ hebrew_alef_from_code_point = charnames :: string_vianame ("U + 05D0");

Naturalmente, "ord ()" hará lo contrario: convierte un carácter en un punto de código.

También hay otras opciones de tiempo de ejecución. Puede utilizar "pack ()":

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

O puede usar "chr ()", aunque es menos conveniente en el caso general:

$ hebrew_alef_from_code_point = chr (utf8 ::unicode_to_nativo(0x05d0));
utf8 :: actualización ($ hebrew_alef_from_code_point);

"Utf8 :: unicode_to_native ()" y "utf8 :: upgrade ()" no son necesarios si el argumento es
por encima de 0xFF, por lo que lo anterior podría haberse escrito como

$ hebrew_alef_from_code_point = chr(0x05d0);

ya que 0x5d0 está por encima de 255.

"\ x {}" y "\ o {}" también se pueden usar para especificar puntos de código en tiempo de compilación en doble
entre comillas, pero, para compatibilidad con versiones anteriores de Perls, se aplican las mismas reglas que
con "chr ()" para puntos de código inferiores a 256.

Se usa "utf8::unicode_to_native()" para que el código Perl sea portátil a las plataformas EBCDIC.
Puedes omitirlo si estás realmente seguro que nadie querrá usar su código en un
Plataforma ASCII. A partir de Perl v5.22, las llamadas a él en plataformas ASCII están optimizadas,
por lo que no hay ninguna penalización de rendimiento al agregarlo. O simplemente puede usar el otro
construcciones que no lo requieren.

Consulte "Recursos adicionales" para saber cómo encontrar todos estos nombres y códigos numéricos.

Más temprano lanzamientos advertencias

En plataformas EBCDIC, antes de v5.22, el uso de "\ N {U + ...}" no funciona correctamente.

Antes de v5.16, se usaba "\ N {...}" con un nombre de carácter (en lugar de un punto de código "U + ...")
requirió un "use charnames: full".

Antes de v5.14, había algunos errores en "\ N {...}" con el nombre de un personaje (a diferencia de un
Punto de código "U + ...").

"charnames :: string_vianame ()" se introdujo en v5.14. Antes de eso,
"charnames :: vianame ()" debería funcionar, pero solo si el argumento tiene la forma "U + ...". Tu
La mejor apuesta que existe para Unicode en tiempo de ejecución por nombre de personaje es probablemente:

usar nombres de caracteres ();
my $ hebrew_alef_from_name
= paquete ("U", charnames :: vianame ("LETRA HEBREA ALEF"));

Manejo Unicode
El manejo de Unicode es en su mayor parte transparente: simplemente use las cadenas como de costumbre.
Funciones como "index ()", "length ()" y "substr ()" funcionarán con los caracteres Unicode;
las expresiones regulares funcionarán en los caracteres Unicode (ver perlunicode y perlretut).

Tenga en cuenta que Perl considera que los grupos de grafemas son caracteres separados, por ejemplo

longitud de impresión ("\ N {LETRA A MAYÚSCULA LATINA A} \ N {COMBINACIÓN DE ACENTO AGUDO}"),
"\norte";

imprimirá 2, no 1. La única excepción es que las expresiones regulares tienen "\ X" para
emparejar un grupo de grafemas extendido. (Por lo tanto, "\X" en una expresión regular coincidiría con el
secuencia completa de ambos personajes de ejemplo).

Sin embargo, la vida no es tan transparente cuando se trabaja con codificaciones heredadas, E / S y
ciertos casos especiales:

Legado Codificaciones
Cuando combina datos heredados y Unicode, los datos heredados deben actualizarse a Unicode.
Normalmente, se supone que los datos heredados son ISO 8859-1 (o EBCDIC, si corresponde).

El módulo "Codificar" conoce muchas codificaciones y tiene interfaces para realizar conversiones.
entre esas codificaciones:

use Codificar 'decodificar';
$ datos = decodificar ("iso-8859-3", $ datos); # convertir de heredado a utf-8

Unicode I / O
Normalmente, escribir datos Unicode

imprimir FH $ alguna_cadena_con_unicode, "\ n";

produce bytes sin procesar que Perl usa para codificar internamente la cadena Unicode.
La codificación interna de Perl depende del sistema, así como de los caracteres que se encuentran en
la cuerda en ese momento. Si alguno de los caracteres se encuentra en los puntos de código 0x100 o superiores,
recibirá una advertencia. Para asegurarse de que la salida se represente explícitamente en la codificación,
deseo, y para evitar la advertencia, abra el flujo con la codificación deseada. Algunos
ejemplos:

abrir FH, ">: utf8", "archivo";

abrir FH, ">: codificación (ucs2)", "archivo";
abra FH, ">: codificación (UTF-8)", "archivo";
abrir FH, ">: codificación (shift_jis)", "archivo";

y en transmisiones ya abiertas, use "binmode ()":

binmode (STDOUT, ": utf8");

binmode (STDOUT, ": codificación (ucs2)");
binmode (STDOUT, ": codificación (UTF-8)");
binmode (STDOUT, ": codificación (shift_jis)");

La coincidencia de nombres de codificación es imprecisa: las mayúsculas y minúsculas no importan, y muchas codificaciones tienen
varios alias. Tenga en cuenta que la capa ": utf8" siempre debe especificarse exactamente así;
es No sujeto a la coincidencia imprecisa de los nombres de codificación. También tenga en cuenta que actualmente
": utf8" no es seguro para la entrada, porque acepta los datos sin validar que son
de hecho UTF-8 válido; en su lugar, debería utilizar ": encoding (utf-8)" (con o sin un guión).

Consulte PerlIO para la capa ": utf8", PerlIO :: encoding y Encode :: PerlIO para
capa ": encoding ()" y Encode :: Compatible con muchas codificaciones compatibles con "Encode"
módulo.

Leer un archivo que sabe que está codificado en uno de los formatos Unicode o heredados
codificaciones no convierte mágicamente los datos en Unicode a los ojos de Perl. Para hacer eso,
especificar la capa apropiada al abrir archivos

open (my $ fh, '<: encoding (utf8)', 'cualquier cosa');
my $ line_of_unicode = <$ fh>;

open (my $ fh, '<: codificación (Big5)', 'cualquier cosa');
my $ line_of_unicode = <$ fh>;

Las capas de E / S también se pueden especificar de forma más flexible con el pragma "abierto". Ver abierto, o
mira el siguiente ejemplo.

use open ': encoding (utf8)'; # La codificación predeterminada de entrada / salida será
#UTF-8
abrir X, "> archivo";
imprimir X chr(0x100), "\ n";
cerrar X;
abre Y "
printf "% # x \ n", ord ( ); # esto debería imprimir 0x100
cerrar Y;

Con el pragma "abierto" puede utilizar la capa ": locale"

COMIENZO {$ ENV {LC_ALL} = $ ENV {LANG} = 'ru_RU.KOI8-R'}
# the: locale sondeará las variables de entorno locale como
#LC_TODOS
use open OUT => ': locale'; # russki parusski
abierto (O, "> koi8");
imprimir O chr(0x430); # Unicode LETRA CIRILICA MINÚSCULA A = KOI8-R 0xc1
cerrar O;
abierto (yo, "
printf "% # x \ n", ord ( ), "\ n"; # esto debería imprimir 0xc1
cerrar yo;

Estos métodos instalan un filtro transparente en el flujo de E / S que convierte los datos del
codificación especificada cuando se lee desde la secuencia. El resultado es siempre Unicode.

El pragma abierto afecta a todas las llamadas "open()" después del pragma al establecer capas predeterminadas.
Si desea afectar solo a determinadas transmisiones, utilice capas explícitas directamente en "open ()"
llamada.

Puede cambiar las codificaciones en una secuencia ya abierta utilizando "binmode ()"; ver "binmode"
en perlfunc.

El ": locale" no funciona actualmente con "open ()" y "binmode ()", solo con el "open"
pragma. Los métodos ": utf8" y ": encoding (...)" funcionan con todos los métodos "open ()",
"binmode ()" y el pragma "abrir".

De manera similar, puede usar estas capas de E / S en flujos de salida para convertir automáticamente Unicode
a la codificación especificada cuando se escribe en la secuencia. Por ejemplo, lo siguiente
fragmento copia el contenido del archivo "text.jis" (codificado como ISO-2022-JP, también conocido como JIS) a
el archivo "text.utf8", codificado como UTF-8:

open (my $ nihongo, '<: codificación (iso-2022-jp)', 'text.jis');
open (mi $ unicode, '>: utf8', 'text.utf8');
while (<$ nihongo>) {imprimir $ unicode $ _}

El nombre de las codificaciones, tanto con el pragma "open ()" como con el pragma "abierto", permite
nombres: "koi8-r" y "KOI8R" se entenderán ambos.

Codificaciones comunes reconocidas por ISO, MIME, IANA y varias otras estandarizaciones
las organizaciones son reconocidas; para obtener una lista más detallada, consulte Encode :: Supported.

"read ()" lee caracteres y devuelve el número de caracteres. "buscar ()" y "decir ()"
operan con recuentos de bytes, al igual que "sysread ()" y "sysseek ()".

Tenga en cuenta que debido al comportamiento predeterminado de no realizar ninguna conversión en la entrada si
no hay una capa predeterminada, es fácil escribir por error código que sigue expandiendo un
archivo codificando repetidamente los datos:

# ADVERTENCIA DE CÓDIGO MALO
abrir F, "archivo";
$ local /; ## leer en el archivo completo de caracteres de 8 bits
$ t = ;
cerrar F;
abrir F, ">: codificación (utf8)", "archivo";
imprimir F $ t; ## convertir a UTF-8 en la salida
cerrar F;

Si ejecuta este código dos veces, el contenido del presentar estará codificado dos veces en UTF-8. Un "uso
open ': encoding (utf8)' "habría evitado el error, o abrir explícitamente también el presentar
para la entrada como UTF-8.

NOTA: las funciones ": utf8" y ": encoding" funcionan solo si su Perl se ha creado con
PerlIO, que es el predeterminado en la mayoría de los sistemas.

Viendo Unicode As Texto
A veces, es posible que desee mostrar escalares de Perl que contienen Unicode como ASCII simple (o
EBCDIC) texto. La siguiente subrutina convierte su argumento para que los caracteres Unicode
con puntos de código mayores que 255 se muestran como "\ x {...}", caracteres de control (como
"\ n") se muestran como "\ x ..", y el resto de los caracteres como ellos mismos:

sub bonita_cadena {
entrar("",
mapa {$ _> 255 # si carácter ancho ...
? sprintf ("\\ x {% 04X}", $ _) # \ x {...}
: chr ($ _) = ~ / [[: cntrl:]] / # else if carácter de control ...
? sprintf ("\\ x% 02X", $ _) # \ x ..
: quotemeta (chr ($ _)) # más entre comillas o como ellos mismos
} desempaquetar ("W *", $ _ [0])); # desempaquetar caracteres Unicode
}

Por ejemplo,

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

devuelve la cadena

'foo \ x {0100} bar \ x0A'

que está listo para ser impreso.

("\\ x {}" se usa aquí en lugar de "\\ N {}", ya que lo más probable es que quieras ver qué
los valores nativos son.)

Especial Casos
· Operador de complemento de bits ~ Y vec ()

El operador de complemento de bits "~" puede producir resultados sorprendentes si se usa en cadenas
que contienen caracteres con valores ordinales superiores a 255. En tal caso, los resultados son
coherente con la codificación interna de los caracteres, pero no con mucho más. Entonces
no hagas eso. De manera similar para "vec ()": estará operando en el codificado internamente
patrones de bits de los caracteres Unicode, no en los valores de los puntos de código, que es muy
probablemente no sea lo que quieres.

· Echando un vistazo a la codificación interna de Perl

Los usuarios normales de Perl nunca deberían preocuparse de cómo Perl codifica una cadena Unicode en particular.
(porque las formas normales de acceder al contenido de una cadena con Unicode - a través de la entrada
y salida: siempre debe ser a través de capas de E / S definidas explícitamente). Pero si debes
hay dos formas de mirar detrás de escena.

Una forma de mirar dentro de la codificación interna de caracteres Unicode es usar
"desempaquetar (" C * ", ..." para obtener los bytes de lo que sea que sea la codificación de cadena, o
"unpack("U0..", ...)" para obtener los bytes de la codificación UTF-8:

# esto imprime c4 80 para los bytes UTF-8 0xc4 0x80
imprimir unir ("", desempaquetar ("U0 (H2) *", empaquetar ("U", 0x100))), "\ n";

Otra forma más sería usar el módulo Devel::Peek:

perl -MDevel :: Peek -e 'Dump (chr(0x100)) '

Eso muestra la bandera "UTF8" en BANDERAS y tanto los bytes UTF-8 como los caracteres Unicode en
"PV". Vea también más adelante en este documento la discusión sobre "utf8 :: is_utf8 ()"
función.

Temas
· Equivalencia de cadenas

La cuestión de la equivalencia de cadenas se vuelve algo complicada en Unicode: ¿qué
¿Quiere decir "igual"?

(¿Es "LETRA A MAYÚSCULA LATINA CON AGUDO" igual a "LETRA A MAYÚSCULA LATINA"?)

La respuesta corta es que, por defecto, Perl compara la equivalencia ("eq", "ne") basándose únicamente
en puntos de código de los caracteres. En el caso anterior, la respuesta es no (porque 0x00C1
! = 0x0041). Pero a veces, cualquier LETRA MAYÚSCULA A debe considerarse igual, o incluso
A de cualquier caso.

La respuesta larga es que debes considerar la normalización de caracteres y el uso de mayúsculas y minúsculas.
problemas: consulte Unicode :: Normalizar, Informe técnico de Unicode n. ° 15, Normalización de Unicode
Formularioshttp://www.unicode.org/unicode/reports/tr15> y secciones sobre mapeo de casos en
el estándar Unicodehttp://www.unicode.org>.

A partir de Perl 5.8.0, el plegado "completo" de la caja Caso Mapeos / SpecialCasing is
implementado, pero los errores permanecen en "qr // i" con ellos, en su mayoría corregidos por 5.14, y
esencialmente en su totalidad por 5.18.

· Intercalación de cadenas

A la gente le gusta ver sus cadenas bien ordenadas o, como dice el lenguaje Unicode, clasificadas.
Pero, de nuevo, ¿a qué te refieres con cotejar?

(¿Viene "LETRA A MAYÚSCULA LATINA CON AGUDO" antes o después de "LETRA A MAYÚSCULA LATINA?
CON GRAVE "?)

La respuesta corta es que, por defecto, Perl compara cadenas ("lt", "le", "cmp", "ge",
"gt") basado únicamente en los puntos de código de los caracteres. En el caso anterior, la respuesta
es "después", ya que 0x00C1> 0x00C0.

La respuesta larga es que "depende", y no se puede dar una buena respuesta sin
conociendo (como mínimo) el contexto del lenguaje. Consulte Unicode :: Collate y Unicode
Colación Algoritmo <http://www.unicode.org/unicode/reports/tr10/>

Misceláneos
· Rangos y clases de personajes

Rangos de caracteres en clases de caracteres entre corchetes de expresiones regulares (p. Ej., "/ [Az] /")
y en el operador "tr ///" (también conocido como "y ///") no son mágicamente compatibles con Unicode.
Lo que esto significa es que "[A-Za-z]" no comenzará mágicamente a significar "todo alfabético
letras "(no es que signifique que incluso para caracteres de 8 bits; para esos, si está
usando locales (perllocale), use "/ [[: alpha:]] /"; y si no es así, utilice la función de reconocimiento de 8 bits
propiedad "\ p {alpha}").

Todas las propiedades que comienzan con "\ p" (y su inversa "\ P") son en realidad caracteres
clases que son compatibles con Unicode. Hay docenas de ellos, ver perluniprops.

A partir de la v5.22, puede utilizar puntos de código Unicode como puntos finales de
rangos de caracteres del patrón de expresión, y el rango incluirá todo el código Unicode
puntos que se encuentran entre esos puntos finales, inclusive.

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

incluye los puntos de código "\N{U+03}", "\N{U+04}", ..., "\N{U+20}".

(Se planea extender este comportamiento a rangos en "tr///" en Perl v5.24).

· Conversiones de cadena a número

Unicode define varios otros caracteres decimales y numéricos además del
familiar de 0 a 9, como los dígitos árabe e índico. Perl no admite cadenas
conversión a número para dígitos que no sean ASCII 0 a 9 (y ASCII "a" a "f" para
hexadecimal). Para obtener conversiones seguras de cualquier cadena Unicode, use "num ()"En
Unicode :: UCD.

Preguntas Con respuestas
· ¿Se romperán mis antiguos scripts?

Probablemente no. A menos que esté generando caracteres Unicode de alguna manera, los viejos
el comportamiento debe ser preservado. Sobre el único comportamiento que ha cambiado y que
podría comenzar a generar Unicode es el antiguo comportamiento de "chr ()" donde se proporciona un
argumento más de 255 produjo un módulo de carácter 255. "chr(300)", por ejemplo, fue
igual a "chr(45) "o" - "(en ASCII), ahora es LETRA I MAYÚSCULA LATINA CON BREVE.

· ¿Cómo puedo hacer que mis scripts funcionen con Unicode?

Debería ser necesario muy poco trabajo ya que nada cambia hasta que genera Unicode
datos. Lo más importante es obtener la entrada como Unicode; para eso, vea el anterior
Discusión de E / S. Para obtener una compatibilidad total con Unicode sin problemas, agregue la función de uso
'unicode_strings' "(o" use 5.012 "o superior) en su secuencia de comandos.

· ¿Cómo puedo saber si mi cadena está en Unicode?

No debería tener que preocuparse. Pero puede hacerlo si su Perl es anterior a 5.14.0 o no
especificó "use feature 'unicode_strings'" o "use 5.012" (o superior) porque de lo contrario
las reglas para los puntos de código en el rango de 128 a 255 son diferentes dependiendo de
si la cadena en la que están contenidos está en Unicode o no. (Consulte "Cuando Unicode
No sucede "en perlunicode.)

Para determinar si una cadena está en Unicode, use:

imprimir utf8 :: is_utf8 ($ cadena)? 1: 0, "\ n";

Pero tenga en cuenta que esto no significa que ninguno de los caracteres de la cadena sea necesario
Codificado en UTF-8, o que alguno de los caracteres tiene puntos de código mayores que 0xFF (255)
o incluso 0x80 (128), o que la cadena tiene algún carácter. Todo el "is_utf8 ()"
lo que hace es devolver el valor de la bandera interna "utf8ness" adjunta a la cadena $.
Si el indicador está desactivado, los bytes del escalar se interpretan como una codificación de un solo byte.
Si la bandera está activada, los bytes del escalar se interpretan como (longitud variable,
potencialmente multibyte) puntos de código codificados en UTF-8 de los caracteres. Bytes agregados a un
Las cadenas codificadas en UTF-8 se actualizan automáticamente a UTF-8. Si se mezclan no UTF-8 y
Los escalares UTF-8 se fusionan (interpolación entre comillas dobles, concatenación explícita o
sustitución del parámetro printf / sprintf), el resultado será codificado en UTF-8 como si se copiara
de las cadenas de bytes se actualizaron a UTF-8: por ejemplo,

$ a = "ab \ x80c";
$ b = "\ x {100}";
imprimir "$ a = $ b \ n";

la cadena de salida estará codificada en UTF-8 "ab \ x80c = \ x {100} \ n", pero $ a permanecerá byte-
codificado.

A veces, es posible que realmente necesite saber la longitud en bytes de una cadena en lugar de la
longitud de caracteres. Para eso, use la función "Encode :: encode_utf8 ()" o la
pragma "bytes" y la función "length ()":

my $ unicode = chr(0x100);
longitud de impresión ($ unicode), "\ n"; # imprimirá 1
requiere codificar;
longitud de impresión (Encode :: encode_utf8 ($ unicode)), "\ n"; # imprimirá 2
utilizar bytes;
longitud de impresión ($ unicode), "\ n"; # también imprimirá 2
# (el 0xC4 0x80 del UTF-8)
sin bytes;

· ¿Cómo averiguo qué codificación tiene un archivo?

Puede probar Encode::Guess, pero tiene una serie de limitaciones.

· ¿Cómo puedo detectar datos que no son válidos en una codificación particular?

Utilice el paquete "Encode" para intentar convertirlo. Por ejemplo,

use Encode 'decode_utf8';

if (eval {decode_utf8 ($ cadena, Codificar :: FB_CROAK); 1}) {
# $ string es utf8 válido
} Else {
# $ string no es válido utf8
}

O use "desempaquetar" para intentar decodificarlo:

use advertencias;
@chars = desempaquetar ("C0U *", $ string_of_bytes_that_I_think_is_utf8);

Si no es válido, se produce una advertencia de "carácter UTF-8 mal formado". El "C0" significa "proceso
el carácter de cadena por carácter ". Sin eso, el" desempaquetar ("U *", ...) "funcionaría
en el modo "U0" (el valor predeterminado si la cadena de formato comienza con "U") y devolvería
los bytes que componen la codificación UTF-8 de la cadena de destino, algo que
siempre trabajo.

· ¿Cómo convierto datos binarios en una codificación particular, o viceversa?

Probablemente esto no sea tan útil como podría pensar. Normalmente, no debería ser necesario.

En cierto sentido, lo que estás preguntando no tiene mucho sentido: las codificaciones son para
caracteres, y los datos binarios no son "caracteres", por lo que convertir "datos" en algunos
la codificación no tiene sentido a menos que sepa en qué juego de caracteres y codificación de la
Los datos binarios están en, en cuyo caso no son solo datos binarios, ¿verdad?

Si tiene una secuencia de bytes sin procesar que sabe que debe interpretarse mediante un
codificación particular, puede utilizar "Codificar":

use Encode 'from_to';
from_to ($ datos, "iso-8859-1", "utf-8"); # de latin-1 a utf-8

La llamada a "from_to ()" cambia los bytes en $ data, pero nada material sobre el
La naturaleza de la cadena ha cambiado en lo que respecta a Perl. Tanto antes como después
la llamada, la cadena $ data contiene solo un grupo de bytes de 8 bits. En lo que respecta a Perl
en cuestión, la codificación de la cadena permanece como "bytes de 8 bits nativos del sistema".

Puede relacionar esto con un módulo de 'Traducir' ficticio:

usa traductor;
my $ frase = "Sí";
Traducir :: from_to ($ frase, 'inglés', 'deutsch');
## frase ahora contiene "Ja"

El contenido de la cadena cambia, pero no la naturaleza de la cadena. Perl no
saber más después de la llamada que antes que el contenido de la cadena indica el
afirmativo.

Volvamos a convertir datos. Si tiene (o quiere) datos en la versión nativa de 8 bits de su sistema
codificación (por ejemplo, Latin-1, EBCDIC, etc.), puede usar pack / unpack para convertir a / desde
Unicode

$ native_string = paquete ("W *", desempaquetar ("U *", $ Unicode_string));
$ Unicode_string = paquete ("U *", desempaquetar ("W *", $ native_string));

Si tiene una secuencia de bytes, know es UTF-8 válido, pero Perl aún no lo sabe,
también puedes convertir a Perl en un creyente:

use Encode 'decode_utf8';
$ Unicode = decode_utf8 ($ bytes);

o bien:

$ Unicode = paquete ("U0a *", $ bytes);

Puede encontrar los bytes que componen una secuencia UTF-8 con

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

y puede crear Unicode bien formado con

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

· ¿Cómo visualizo Unicode? ¿Cómo ingreso Unicode?

Verhttp://www.alanwood.net/unicode/> y
<http://www.cl.cam.ac.uk/~mgk25/unicode.html>

· ¿Cómo funciona Unicode con las configuraciones regionales tradicionales?

Si su configuración regional es una configuración regional UTF-8, a partir de Perl v5.20, Perl funciona bien para todos
categorías excepto "LC_COLLATE" que se ocupa de la ordenación y el operador "cmp".

Para otras configuraciones regionales, a partir de Perl 5.16, puede especificar

use locale ': not_characters';

para que Perl funcione bien con ellos. El problema es que tienes que traducir del
conjunto de caracteres de configuración regional a / desde Unicode usted mismo. Consulte "E / S Unicode" más arriba para saber cómo

use open ': locale';

para lograr esto, pero los detalles completos están en "Unicode y UTF-8" en perllocale,
incluidas las trampas que suceden si no especifica ": not_characters".

Hexadecimal Calificación
El estándar Unicode prefiere usar la notación hexadecimal porque muestra más claramente
la división de Unicode en bloques de 256 caracteres. Hexadecimal también es simplemente más corto
que decimal. También puede usar la notación decimal, pero aprender a usar hexadecimal simplemente
hace la vida más fácil con el estándar Unicode. La notación "U + HHHH" utiliza hexadecimal, para
ejemplo.

El prefijo "0x" significa un número hexadecimal, los dígitos son 0-9 y af (o AF, caso
no importa). Cada dígito hexadecimal representa cuatro bits o medio byte. "impresión
0x ..., "\ n" "mostrará un número hexadecimal en decimal, y" printf "% x \ n", $ decimal "lo hará
mostrar un número decimal en hexadecimal. Si solo tiene los "dígitos hexadecimales" de un hexadecimal
número, puede utilizar la función "hex ()".

imprimir 0x0009, "\ n"; # 9
imprimir 0x000a, "\ n"; # 10
imprimir 0x000f, "\ n"; # 15
imprimir 0x0010, "\ n"; # 16
imprimir 0x0011, "\ n"; # 17
imprimir 0x0100, "\ n"; # 256

imprimir 0x0041, "\ n"; # 65

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

imprimir hexadecimal ("41"), "\ n"; # sesenta y cinco

Promover Recursos
· Consorcio Unicode

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

· Preguntas frecuentes sobre Unicode

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

· Glosario Unicode

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

· Lista de lecturas recomendadas de Unicode

El Consorcio Unicode tiene una lista de artículos y libros, algunos de los cuales dan una gran
tratamiento más en profundidad de Unicode:http://unicode.org/resources/readinglist.html>

· Recursos útiles Unicode

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

· Soporte Unicode y multilingüe en HTML, fuentes, navegadores web y otras aplicaciones

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

· Preguntas frecuentes sobre UTF-8 y Unicode para Unix / Linux

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

· Juegos de caracteres heredados

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

· Puede explorar diversa información de los archivos de datos Unicode usando el
Módulo "Unicode :: UCD".

UNICODE IN MAYOR PERLAS

Si no puede actualizar su Perl a 5.8.0 o posterior, aún puede usar Unicode
procesamiento utilizando los módulos "Unicode :: String", "Unicode :: Map8" y "Unicode :: Map",
disponible en CPAN. Si tiene la recodificación GNU instalada, también puede usar Perl
front-end "Convert :: Recode" para conversiones de caracteres.

Las siguientes son conversiones rápidas de bytes ISO 8859-1 (Latin-1) a bytes UTF-8 y
atrás, el código funciona incluso con versiones anteriores de Perl 5.

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

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

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