perldata - Online en la nube

PROGRAMA:

NOMBRE

perldata - Tipos de datos de Perl

DESCRIPCIÓN

Variable nombres
Perl tiene tres tipos de datos integrados: escalares, matrices de escalares y matrices asociativas de
escalares, conocidos como "hashes". Un escalar es una sola cadena (de cualquier tamaño, limitada solo por el
memoria disponible), número o una referencia a algo (que se discutirá en
perlref). Las matrices normales son listas ordenadas de escalares indexados por número, comenzando con 0.
Los hash son colecciones desordenadas de valores escalares indexados por su clave de cadena asociada.

Por lo general, se hace referencia a los valores por su nombre o mediante una referencia con nombre. El primer personaje
del nombre le indica a qué tipo de estructura de datos se refiere. El resto del nombre
le dice el valor particular al que se refiere. Por lo general, este nombre es un solo
identificador, es decir, una cadena que comienza con una letra o un guión bajo y que contiene
letras, guiones bajos y dígitos. En algunos casos, puede ser una cadena de identificadores,
separados por "::" (o por el ligeramente arcaico "'"); todos menos el último se interpretan como
nombres de paquetes, para ubicar el espacio de nombres en el que buscar el identificador final (ver
"Paquetes" en perlmod para más detalles). Para una discusión más profunda sobre identificadores, vea
"Análisis de identificadores". Es posible sustituir un identificador simple, una expresión
que produce una referencia al valor en tiempo de ejecución. Esto se describe con más detalle.
abajo y en perlref.

Perl también tiene sus propias variables integradas cuyos nombres no siguen estas reglas. Ellos tienen
nombres extraños para que no choquen accidentalmente con una de sus variables normales.
Las cadenas que coinciden con partes entre paréntesis de una expresión regular se guardan con nombres
que contiene solo dígitos después del "$" (ver perlop y perlre). Además, varios
las variables especiales que proporcionan ventanas al funcionamiento interno de Perl tienen nombres
que contiene caracteres de puntuación y caracteres de control. Estos están documentados en
perlvar.

Los valores escalares siempre se nombran con '$', incluso cuando se refieren a un escalar que es parte de
una matriz o un hash. El símbolo '$' funciona semánticamente como la palabra inglesa "the" en ese
indica que se espera un solo valor.

$ días # el valor escalar simple "días"
$ days [28] # el elemento 29 de la matriz @days
$ days {'Feb'} # el valor de 'Feb' de hash% days
$ # days # el último índice de la matriz @days

Las matrices completas (y las porciones de matrices y hashes) se indican con '@', que funciona de forma muy similar a
la palabra "estos" o "esos" en inglés, ya que indica que varios valores son
esperado.

@days # ($ días [0], $ días [1], ... $ días [n])
@days [3,4,5] # igual que ($ days [3], $ days [4], $ days [5])
@days {'a', 'c'} # igual que ($ days {'a'}, $ days {'c'})

Los hash completos se indican con '%':

% días # (clave1, val1, clave2, val2 ...)

Además, las subrutinas se nombran con una '&' inicial, aunque esto es opcional cuando
inequívoco, al igual que la palabra "do" suele ser redundante en inglés. Entradas de la tabla de símbolos
se puede nombrar con un '*' inicial, pero eso realmente no te importa todavía (si es que alguna vez :-).

Cada tipo de variable tiene su propio espacio de nombres, al igual que varios identificadores no variables. Esta
significa que puede, sin temor a conflictos, usar el mismo nombre para una variable escalar, una
matriz, o un hash - o, para el caso, para un identificador de archivo, un identificador de directorio, una subrutina
nombre, un nombre de formato o una etiqueta. Esto significa que $ foo y @foo son dos diferentes
variables. También significa que $ foo [1] es parte de @foo, no de $ foo. Esto puede
parece un poco extraño, pero está bien, porque es extraño.

Debido a que las referencias de variables siempre comienzan con '$', '@' o '%', las palabras "reservadas"
de hecho, no están reservados con respecto a los nombres de las variables. Ellos están reservado con respecto a
etiquetas y identificadores de archivo, sin embargo, que no tienen un carácter especial inicial. No puedes
tener un identificador de archivo llamado "log", por ejemplo. Sugerencia: podría decir "abrir (LOG, 'logfile')"
en lugar de "abrir (registro, 'archivo de registro')". El uso de identificadores de archivos en mayúsculas también mejora la legibilidad
y te protege de conflictos con futuras palabras reservadas. Caso is significativo - "FOO",
"Foo" y "foo" son nombres diferentes. Nombres que comienzan con una letra o un guión bajo
también puede contener dígitos y guiones bajos.

Es posible reemplazar dicho nombre alfanumérico con una expresión que devuelva un
referencia al tipo apropiado. Para obtener una descripción de esto, consulte perlref.

Los nombres que comienzan con un dígito pueden contener solo más dígitos. Nombres que no comienzan con
una letra, un guión bajo, un dígito o un signo de intercalación (es decir, un carácter de control) se limitan a uno
carácter, por ejemplo, $% o $$. (La mayoría de estos nombres de un carácter tienen un nombre predefinido
significado para Perl. Por ejemplo, $$ es el ID del proceso actual).

Identificador Analizando
Hasta Perl 5.18, las reglas reales de lo que era un identificador válido eran un poco confusas.
Sin embargo, en general, todo lo que se defina aquí debería funcionar en versiones anteriores de Perl, mientras que
lo contrario: casos extremos que funcionan en versiones anteriores, pero que no se definen aquí.
probablemente no funcione en versiones más nuevas. Como nota al margen importante, tenga en cuenta que el
lo siguiente solo se aplica a los identificadores de palabras simples que se encuentran en el código fuente de Perl, no
identificadores introducidos a través de referencias simbólicas, que tienen muchas menos restricciones.
Si trabaja bajo el efecto de "use utf8;" pragma, se aplican las siguientes reglas:

/ (? [(\ p {Word} & \ p {XID_Start}) + [_]])
(? [(\ p {Word} & \ p {XID_Continue})]) * / x

Es decir, un carácter de "inicio" seguido de cualquier número de caracteres de "continuación". Perl
requiere que todos los caracteres de un identificador coincidan también con "\ w" (esto evita
casos problemáticos); y Perl acepta además nombres identificadores que comienzan con un
guion bajo.

Si no está en "use utf8", la fuente se trata como controles adicionales ASCII + 128, y
los identificadores deben coincidir

/ (? aa) (?! \ d) \ w + / x

Es decir, cualquier carácter de palabra en el rango ASCII, siempre que el primer carácter no sea un
dígito.

Hay dos separadores de paquetes en Perl: dos puntos dobles ("::") y una comilla simple ("'").
Los identificadores normales pueden comenzar o terminar con dos puntos dobles y pueden contener varias partes
delimitado por dos puntos dobles. Las comillas simples tienen reglas similares, pero con la excepción de que
no son legales al final de un identificador: es decir, "$ 'foo" y "$ foo'bar" son legales,
pero "$ foo'bar '" no lo es.

Además, si el identificador está precedido por un sigilo, es decir, si el identificador es
parte de un nombre de variable; opcionalmente, puede incluirse entre llaves.

Si bien puede mezclar dos puntos dobles con comillas simples, las comillas deben ir después del
dos puntos: "$ :::: 'foo" y "$ foo ::' bar" son legales, pero "$ :: ':: foo" y "$ foo' :: bar" no lo son.

En conjunto, una gramática que coincida con un identificador básico se convierte en

/
(?(DEFINIR)
(?
(? y sigilo)
†
(? & identificador_normal)
| \ {\ s * (? & identificador_normal) \ s * \}
)
)
(?
(?: ::) * '?
(? & identificador_básico)
(?: (? = (?: ::) + '? | (?: ::) *') (? & identificador_normal))?
(?: ::) *
)
(?
# ¿Está activado el uso de utf8?
(? (? {(llamador(0)) [8] & $ utf8 :: hint_bits})
(? & Perl_XIDS) (? & Perl_XIDC) *
| (? aa) (?! \ d) \ w +
)
)
(? PS
(? (? [(\ p {Word} & \ p {XID_Start}) + [_]]))
(? (? [\ p {Word} & \ p {XID_Continue}]))
)
/x

Mientras tanto, los identificadores especiales no siguen las reglas anteriores; En su mayor parte, todos los
Los identificadores de esta categoría tienen un significado especial dado por Perl. Porque tienen
reglas especiales de análisis, estas generalmente no pueden ser completamente calificadas. Vienen en cuatro formas:

· Un sigilo, seguido únicamente por dígitos que coincidan con "\ p {POSIX_Digit}", como $ 0, $ 1 o $ 10000.

· Un sigilo, seguido de un signo de intercalación y cualquiera de los caracteres "[] [AZ ^ _? \]", Como $ ^ V o
$ ^], o un sigilo seguido de una coincidencia literal de caracteres de control sin espacios ni "NUL"
la propiedad "\ p {POSIX_Cntrl}". Debido a una rareza histórica, si no se ejecuta bajo "use
utf8 ", los 128 caracteres del rango" [0x80-0xff] "se consideran controles,
y también se puede utilizar en variables de longitud uno. Sin embargo, el uso de no gráficos
Los caracteres están obsoletos a partir de la versión 5.22, y su compatibilidad se eliminará en un futuro.
versión de perl. Los caracteres de espacio ASCII y "NUL" ya no están permitidos, por lo que
significa que un nombre de variable de un solo carácter con ese nombre es cualquier otro control C0
"[0x01-0x1F]" o "DEL" generarán una advertencia obsoleta. Ya, en "usar
utf8 ", los caracteres que no sean ASCII deben coincidir con" Perl_XIDS ". A partir de la versión 5.22, cuando no esté en" use
utf8 "Controles C1" [0x80-0x9F] ", SIN ESPACIO DE INTERRUPCIÓN y GUIÓN SUAVE (" SHY ")) generan un
advertencia obsoleta.

· Similar al anterior, un sigilo, seguido de un texto sin palabras entre llaves, donde el primer
carácter es un signo de intercalación seguido de cualquiera de los caracteres "[] [AZ ^ _? \]", como
"$ {^ GLOBAL_PHASE}", o un control literal sin espacio ni "NUL" como "$ {\ 7LOBAL_PHASE}".
Como el anterior, cuando no está en "use utf8", los caracteres en "[0x80-0xFF]" son
controles considerados, pero a partir de la v5.22, el uso de cualquiera que no sea gráfico
en desuso, y a partir de la v5.20 el uso de cualquier control literal de rango ASCII está en desuso.
La compatibilidad con estos se eliminará en una versión futura de perl.

· Un sigilo seguido de un solo carácter que coincida con la propiedad "\ p {POSIX_Punct}", como
PS o "% +", excepto que el carácter "{" no funciona.

Tenga en cuenta que a partir de Perl 5.20, los caracteres de control literal en los nombres de las variables están obsoletos;
ya partir de Perl 5.22, cualquier otro carácter no gráfico también está obsoleto.

Contexto
La interpretación de operaciones y valores en Perl a veces depende de los requisitos
del contexto en torno a la operación o valor. Hay dos contextos principales: lista y
escalar. Ciertas operaciones devuelven valores de lista en contextos que desean una lista y escalar
valores de lo contrario. Si esto es cierto para una operación, se mencionará en el
documentación para esa operación. En otras palabras, Perl sobrecarga ciertas operaciones basadas
sobre si el valor de retorno esperado es singular o plural. Algunas palabras en inglés funcionan
de esta manera, como "pez" y "oveja".

De manera recíproca, una operación proporciona un contexto escalar o de lista para cada
de sus argumentos. Por ejemplo, si dices

En t( )

la operación entera proporciona contexto escalar para el operador <>, que responde por
leyendo una línea de STDIN y devolviéndola a la operación de entero, que luego
encuentra el valor entero de esa línea y devuélvelo. Si, por el contrario, dices

clasificar( )

luego la operación de clasificación proporciona un contexto de lista para <>, que procederá a leer cada
línea disponible hasta el final del archivo, y pasar esa lista de líneas de nuevo al orden
rutina, que luego ordenará esas líneas y las devolverá como una lista a cualquier
contexto del tipo era.

La asignación es un poco especial porque usa su argumento izquierdo para determinar el
contexto para el argumento correcto. La asignación a un escalar evalúa el lado derecho en
contexto escalar, mientras que la asignación a una matriz o hash evalúa el lado derecho en la lista
contexto. La asignación a una lista (o sector, que de todos modos es solo una lista) también evalúa la
lado derecho en el contexto de la lista.

Cuando usa el pragma "use warnings" o Perl's -w opción de línea de comandos, puede ver
advertencias sobre usos inútiles de constantes o funciones en "contexto nulo". Contexto vacío
solo significa que el valor ha sido descartado, como una declaración que contiene solo "" fred ";" o
"obtenerpwuid(0); ". Sigue contando como contexto escalar para funciones a las que les importa si
se les llama en el contexto de la lista.

Las subrutinas definidas por el usuario pueden optar por cuidar si se las llama en un vacío,
contexto escalar o de lista. Sin embargo, la mayoría de las subrutinas no necesitan molestarse. Eso es porque
tanto los escalares como las listas se interpolan automáticamente en listas. Ver "wantarray" en
perlfunc para saber cómo discerniría dinámicamente el contexto de llamada de su función.

Escalar valores
Todos los datos en Perl son escalares, una matriz de escalares o un hash de escalares. Un escalar puede
contener un solo valor en cualquiera de tres sabores diferentes: un número, una cadena o un
referencia. En general, la conversión de una forma a otra es transparente. Aunque un
escalar puede no contener directamente varios valores, puede contener una referencia a una matriz o
hash que a su vez contiene varios valores.

Los escalares no son necesariamente una cosa u otra. No hay lugar para declarar un escalar
variable para ser de tipo "cadena", tipo "número", tipo "referencia", o cualquier otra cosa.
Debido a la conversión automática de escalares, las operaciones que devuelven escalares no necesitan
preocuparse (y de hecho, no me importa) si la persona que llama está buscando una cadena, un número,
o una referencia. Perl es un lenguaje contextualmente polimórfico cuyos escalares pueden ser cadenas,
números o referencias (que incluye objetos). Aunque las cadenas y los números son
Considerado más o menos lo mismo para casi todos los propósitos, las referencias son fuertemente-
punteros tipeados, no escalables con recuento de referencias incorporado e invocación de destructor.

Un valor escalar se interpreta como FALSO en el sentido booleano si no está definido, el valor nulo
cadena o el número 0 (o su cadena equivalente, "0"), y VERDADERO si es cualquier otra cosa.
El contexto booleano es solo un tipo especial de contexto escalar donde no hay conversión a un
alguna vez se ejecuta una cadena o un número.

En realidad, existen dos variedades de cadenas nulas (a veces denominadas "vacías"
cadenas), uno definido y uno indefinido. La versión definida es solo una cadena de
longitud cero, como "". La versión indefinida es el valor que indica que hay
sin valor real para algo, como cuando hubo un error, o al final del archivo, o cuando
se refiere a una variable o elemento no inicializado de una matriz o hash. Aunque a principios
versiones de Perl, un escalar indefinido podría definirse cuando se usa por primera vez en un lugar
esperando un valor definido, esto ya no sucede excepto en casos raros de
autovivificación como se explica en perlref. Puedes usar el definido () operador para determinar
si se define un valor escalar (esto no tiene significado en matrices o hashes), y el
undef () operador para producir un valor indefinido.

Para saber si una cadena dada es un número válido distinto de cero, a veces es suficiente
pruébelo contra 0 numérico y también léxico "0" (aunque esto causará ruidos si
las advertencias están encendidas). Eso es porque las cadenas que no son números cuentan como 0, al igual que lo hacen
in awk:

if ($ str == 0 && $ str ne "0") {
advertir "Eso no parece un número";
}

Ese método puede ser el mejor porque, de lo contrario, no tratará las notaciones IEEE como "NaN" o
"Infinito" correctamente. En otras ocasiones, es posible que prefiera determinar si los datos de la cadena
se puede utilizar numéricamente llamando al POSIX :: strtod () función o inspeccionando su
cadena con una expresión regular (como se documenta en perlre).

advertir "no tiene dígitos" si / \ D /;
advertir "no es un número natural" a menos que / ^ \ d + $ /; # rechaza -3
advertir "no es un entero" a menos que / ^ -? \ d + $ /; # rechaza +3
advertir "no es un entero" a menos que / ^ [+ -]? \ d + $ /;
advertir "no es un número decimal" a menos que /^-?\d+\.?\d*$/; # rechaza .2
advertir "no es un número decimal" a menos que /^-?(?:\d+(?:\.\d*)?|\.\d+)$/;
advertir "no es un flotador C"
a menos que /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;

La longitud de una matriz es un valor escalar. Puede encontrar la longitud de la matriz @days por
evaluando $ # días, como en csh. Sin embargo, esta no es la longitud de la matriz; es el
subíndice del último elemento, que es un valor diferente ya que normalmente hay un 0th
elemento. Asignar a $ # días en realidad cambia la duración de la matriz. Acortando un
array de esta manera destruye los valores intermedios. Alargando una matriz que antes
abreviado no recupera los valores que estaban en esos elementos.

También puede obtener una minúscula medida de eficiencia al extender previamente una matriz que es
va a hacerse grande. También puede extender una matriz asignando a un elemento que está fuera del
final de la matriz. Puede truncar una matriz a nada asignando la lista nula ()
lo. Los siguientes son equivalentes:

@ lo que sea = ();
$ # lo que sea = -1;

Si evalúa una matriz en contexto escalar, devuelve la longitud de la matriz. (Nota
que esto no es cierto para las listas, que devuelven el último valor, como el operador de coma C,
ni de las funciones integradas, que devuelven lo que les apetezca devolver).
siempre es cierto:

escalar (@ lo que sea) == $ # lo que sea + 1;

Algunos programadores optan por utilizar una conversión explícita para no dejar lugar a dudas:

$ element_count = escalar (@ lo que sea);

Si evalúa un hash en contexto escalar, devuelve falso si el hash está vacío. Sí hay
son pares clave / valor, devuelve verdadero; más precisamente, el valor devuelto es una cadena
que consta del número de depósitos usados ​​y el número de depósitos asignados, separados por
una barra. Esto es bastante útil solo para averiguar si el hash interno de Perl
El algoritmo funciona mal en su conjunto de datos. Por ejemplo, pones 10,000 cosas en
un hash, pero la evaluación de% HASH en contexto escalar revela "1/16", lo que significa que solo uno de
Se han tocado dieciséis cubos, y presumiblemente contiene los 10,000 de sus artículos. Esta
no se supone que suceda. Si un hash vinculado se evalúa en un contexto escalar, el "ESCALAR"
se llama al método (con una reserva a "FIRSTKEY").

Puede preasignar espacio para un hash asignando al llaves() función. Esto redondea
los cubos asignados a la siguiente potencia de dos:

claves (% usuarios) = 1000; # asignar 1024 cubos

Escalar propuesta de constructores
Los literales numéricos se especifican en cualquiera de los siguientes formatos de punto flotante o entero:

12345
12345.67
.23E-10 # un número muy pequeño
3.14_15_92 # un número muy importante
4_294_967_296 # subrayado para legibilidad
0xff # hexadecimal
0xdead_beef # más hexadecimal
0377 # octal (solo números, comienza con 0)
0b011011 # binario
0x1.999ap-4 # punto flotante hexadecimal (se requiere la 'p')

Puede usar guiones bajos (subrayados) en literales numéricos entre dígitos para
legibilidad (pero no varios guiones bajos seguidos: "23__500" no es legal; "23_500" lo es).
Podría, por ejemplo, agrupar dígitos binarios de tres en tres (como para un argumento de modo de estilo Unix
como 0b110_100_100) o por cuatro (para representar nibbles, como en 0b1010_0110) o en otros
grupos.

Los literales de cadena generalmente están delimitados por comillas simples o dobles. Ellos trabajan mucho
comillas similares en los shells estándar de Unix: los literales de cadena entre comillas dobles están sujetos a
barra invertida y sustitución de variables; las cadenas entre comillas simples no lo son (excepto para "\ '" y
"\\"). Se aplican las reglas habituales de barra invertida de estilo C para crear caracteres como nueva línea,
tab, etc., así como algunas formas más exóticas. Consulte "Operadores de cotizaciones y similares a cotizaciones" en
perlop para una lista.

Las representaciones hexadecimales, octales o binarias en cadenas literales (por ejemplo, '0xff') no son
convertido automáticamente a su representación entera. El maleficio() y oct() funciones
haga estas conversiones por usted. Consulte "hex" en perlfunc y "oct" en perlfunc para obtener más información.
Detalles.

El punto flotante hexadecimal puede comenzar como un literal hexadecimal, y puede ser
seguida de una parte hexadecimal fraccional opcional, pero debe ir seguida de "p", una
signo opcional y una potencia de dos. El formato es útil para presentar con precisión
valores de coma flotante, evitando conversiones hacia o desde coma flotante decimal, y
evitando así posibles pérdidas de precisión. Tenga en cuenta que, si bien la mayoría de las plataformas actuales
utilizan el punto flotante IEEE 64 de 754 bits, no todos lo hacen. Otra fuente potencial de
orden) las diferencias son los modos de redondeo de punto flotante, que pueden diferir entre las CPU,
sistemas operativos y compiladores, y que Perl no controla.

También puede incrustar nuevas líneas directamente en sus cadenas, es decir, pueden terminar en un diferente
línea de lo que comienzan. Esto es bueno, pero si olvida su cotización final, el error
no se informará hasta que Perl encuentre otra línea que contenga el carácter de comillas, que puede ser
mucho más adelante en el guión. La sustitución de variables dentro de las cadenas se limita a escalar
variables, matrices y matrices o porciones hash. (En otras palabras, los nombres que comienzan con $ o
@, seguido de una expresión opcional entre corchetes como subíndice). El siguiente código
el segmento imprime "El precio es $ 100".

$ Precio = '$ 100'; # no interpolado
imprimir "El precio es $ Precio. \ n"; # interpolado

No hay doble interpolación en Perl, por lo que los $ 100 se dejan como están.

Por defecto, los números de punto flotante sustituidos dentro de las cadenas utilizan el punto (".") Como
separador decimal. Si "use locale" está en vigor, y POSIX :: setlocale () ha sido llamado,
el carácter utilizado para el separador decimal se ve afectado por la configuración regional LC_NUMERIC. Ver
perllocale y POSIX.

Como en algunos shells, puede encerrar el nombre de la variable entre llaves para eliminar la ambigüedad de
siguientes alfanuméricos (y guiones bajos). También debe hacer esto al interpolar un
variable en una cadena para separar el nombre de la variable de los siguientes dos puntos dobles o un
apóstrofe, ya que de lo contrario se tratarían como un separador de paquetes:

$ quién = "Larry";
imprimir PASSWD "$ {who} :: 0: 0: Superusuario: /: / bin / perl \ n";
print "Usamos $ {quién} habla cuando $ {quién} está aquí. \ n";

Sin las llaves, Perl habría buscado un $ whospeak, un $ who :: 0 y un "$ who's"
variable. Los dos últimos serían las variables $ 0 y $ s en la (presumiblemente) no-
paquete existente "quién".

De hecho, un identificador simple dentro de tales curlies se ve obligado a ser una cadena, y del mismo modo
dentro de un subíndice hash. No es necesario citar. Nuestro ejemplo anterior, $ days {'Feb'} puede ser
escrito como $ días {Feb} y las cotizaciones se asumirán automáticamente. Pero nada mas
complicado en el subíndice se interpretará como una expresión. Esto significa, por ejemplo
que "$ versión {2.0} ++" es equivalente a "$ versión {2} ++", no a "$ versión {'2.0'} ++".

Especial flotante punto: infinito (Inf.) y no un número (Yaya)

Los valores de coma flotante incluyen los valores especiales "Inf" y "NaN", para infinito y not-a-
número. El infinito también puede ser negativo.

El infinito es el resultado de ciertas operaciones matemáticas que desbordan el punto flotante
rango, como 9 ** 9 ** 9. El no-número es el resultado cuando el resultado es indefinido o
irrepresentable. Aunque tenga en cuenta que no puede obtener "NaN" de algunos "indefinidos" o
operaciones "fuera de rango", como dividir por cero o la raíz cuadrada de un número negativo,
ya que Perl genera errores fatales para esos.

El infinito y el no-número tienen sus propias reglas aritméticas especiales. La regla general
es que son "contagiosas": "Inf" más uno es "Inf", y "NaN" más uno es "NaN".
Donde las cosas se ponen interesantes es cuando combinas infinitos y no números: "Inf" menos
"Inf" e "Inf" divididos por "INf" son "NaN" (mientras que "Inf" más "Inf" es "Inf" e "Inf"
veces "Inf" es "Inf"). "NaN" también es curioso porque no es igual a ningún número,
de alta calidad que incluyen sí mismo: "NaN"! = "NaN".

Perl no entiende "Inf" y "NaN" como literales numéricos, pero puede tenerlos como
cadenas, y Perl las convertirá según sea necesario: "Inf" + 1. (Sin embargo, puede importarlas
desde la extensión POSIX; "use POSIX qw (Inf NaN);" y luego utilícelos como literales).

Tenga en cuenta que en la entrada (cadena a número) Perl acepta "Inf" y "NaN" en muchas formas. Caso
se ignora y los formularios específicos de Win32 como "1. # INF" se entienden, pero en la salida
los valores se normalizan a "Inf" y "NaN".

Versión Tangas

Un literal de la forma "v1.20.300.4000" se analiza como una cadena compuesta de caracteres con
los ordinales especificados. Esta forma, conocida como v-strings, proporciona una alternativa, más
forma legible de construir cadenas, en lugar de utilizar el algo menos legible
forma de interpolación "\ x {1} \ x {14} \ x {12c} \ x {fa0}". Esto es útil para representar Unicode
cadenas, y para comparar "números" de versión utilizando los operadores de comparación de cadenas, "cmp",
"gt", "lt", etc. Si hay dos o más puntos en el literal, la "v" inicial puede ser
omitido.

imprimir v9786; # imprime SMILEY, "\ x {263a}"
imprimir v102.111.111; # imprime "foo"
imprimir 102.111.111; # mismo

Estos literales son aceptados tanto por "require" como por "use" para realizar una verificación de versión. Nota
que el uso de cadenas virtuales para direcciones IPv4 no es portátil a menos que también use el
inet_aton ()/inet_ntoa () rutinas del paquete Socket.

Tenga en cuenta que desde Perl 5.8.1 las cadenas v de un solo número (como "v65") no son cadenas v
antes del operador "=>" (que generalmente se usa para separar una clave hash de un valor hash);
en su lugar, se interpretan como cadenas literales ('v65'). Eran cuerdas en V de Perl
5.6.0 a Perl 5.8.0, pero eso causó más confusión y rotura que bien. Numero múltiple
V-strings como "v65.66" y 65.66.67 siguen siendo v-strings siempre.

Especial Literales

Los literales especiales __FILE__, __LINE__ y __PACKAGE__ representan el nombre de archivo actual,
número de línea y nombre del paquete en ese punto de su programa. __SUB__ da una referencia a
la subrutina actual. Pueden usarse solo como tokens separados; ellos no serán
interpolado en cadenas. Si no hay ningún paquete actual (debido a un "paquete" vacío;
directiva), __PACKAGE__ es el valor indefinido. (Pero el "paquete" vacío ya no es
admitido, a partir de la versión 5.10.) Fuera de una subrutina, __SUB__ es el valor indefinido.
__SUB__ solo está disponible en 5.16 o superior, y solo con una función "usar v5.16" o "usar
Declaración "current_sub" ".

Los dos caracteres de control ^ D y ^ Z, y los tokens __END__ y __DATA__ pueden usarse para
indicar el final lógico del script antes del final real del archivo. Cualquier texto siguiente
se ignora.

El texto después de __DATA__ se puede leer mediante el identificador de archivo "PACKNAME :: DATA", donde "PACKNAME" es
el paquete que estaba actualizado cuando se encontró el token __DATA__. El identificador de archivo es
dejó abierto apuntando a la línea después de __DATA__. El programa debe "cerrar DATA" cuando esté
terminado de leerlo. (Dejarlo abierto filtra los identificadores de archivos si el módulo se recarga por
por cualquier motivo, por lo que es una práctica más segura cerrarlo). Para compatibilidad con scripts más antiguos
escrito antes de que se introdujera __DATA__, __END__ se comporta como __DATA__ en el nivel superior
script (pero no en archivos cargados con "require" o "do") y deja el contenido restante
del archivo accesible a través de "main :: DATA".

Consulte SelfLoader para obtener una descripción más detallada de __DATA__ y un ejemplo de su uso. Tenga en cuenta que usted
no se puede leer desde el identificador de archivo DATA en un bloque BEGIN: el bloque BEGIN se ejecuta tan pronto
como se ve (durante la compilación), en cuyo punto el correspondiente __DATA__ (o __END__)
el token aún no se ha visto.

Palabras desnudas

Una palabra que no tiene otra interpretación en la gramática será tratada como si fuera una
cadena entre comillas. Estos se conocen como "palabras clave". Al igual que con los identificadores de archivos y las etiquetas,
palabra desnuda que consta completamente de letras minúsculas corre el riesgo de entrar en conflicto con el futuro reservado
palabras, y si utiliza el pragma "use advertencias" o el -w cambiar, Perl le advertirá sobre
cualquiera de esas palabras. Perl limita las palabras simples (como los identificadores) a unos 250 caracteres. Futuro
Es probable que las versiones de Perl eliminen estas limitaciones arbitrarias.

Algunas personas pueden desear prohibir las palabras desnudas por completo. Si usted dice

use 'subs' estrictos;

entonces cualquier palabra desnuda que NO se interprete como una llamada de subrutina produce una compilación
error de tiempo en su lugar. La restricción dura hasta el final del bloque adjunto. Un interior
block puede contrarrestar esto diciendo "no hay 'subs' estrictos".

Formación Interpolación

Las matrices y los cortes se interpolan en cadenas entre comillas dobles uniendo los elementos con
el delimitador especificado en la variable $ "($ LIST_SEPARATOR si" use English; "es
especificado), espacio por defecto. Los siguientes son equivalentes:

$ temp = unirse ($ ", @ARGV);
sistema "echo $ temp";

sistema "echo @ARGV";

Dentro de los patrones de búsqueda (que también se someten a una sustitución entre comillas dobles) hay una
ambigüedad desafortunada: "/ $ foo [bar] /" debe interpretarse como "/ $ {foo} [bar] /" (donde
"[bar]" es una clase de caracteres para la expresión regular) o como "/ $ {foo [bar]} /" (donde
"[bar]" es el subíndice de la matriz @foo)? Si @foo no existe de otra manera, entonces es
obviamente una clase de personaje. Si @foo existe, Perl hace una buena suposición sobre "[bar]", y
casi siempre tiene razón. Si adivina mal, o si simplemente estás paranoico, puedes
fuerce la interpretación correcta con llaves como arriba.

Si está buscando información sobre cómo utilizar here-documents, que solía estar aquí,
que se ha movido a "Cotizaciones y operadores similares a cotizaciones" en perlop.

Lista propuesta de constructores
Los valores de lista se indican separando los valores individuales por comas (y encerrando la lista
entre paréntesis donde la precedencia lo requiera):

(LISTA)

En un contexto que no requiere un valor de lista, el valor de lo que parece ser un literal de lista es
simplemente el valor del elemento final, como con el operador de coma C. Por ejemplo,

@foo = ('cc', '-E', $ barra);

asigna todo el valor de la lista a la matriz @foo, pero

$ foo = ('cc', '-E', $ barra);

asigna el valor de la variable $ bar a la variable escalar $ foo. Tenga en cuenta que el valor de un
la matriz real en contexto escalar es la longitud de la matriz; lo siguiente asigna el valor
3 a $ foo:

@foo = ('cc', '-E', $ barra);
$ foo = @foo; # $ foo obtiene 3

Puede tener una coma opcional antes del paréntesis de cierre de un literal de lista, de modo que
puedes decir:

@foo = (
1,
2,
3,
);

Para usar un documento aquí para asignar una matriz, una línea por elemento, puede usar un enfoque
Me gusta esto:

@sacetas = <
tomate normal
tomate picante
chile verde
pesto
vino blanco
Líneas_finales

Las LISTAS hacen interpolación automática de sublistas. Es decir, cuando se evalúa una LISTA, cada
elemento de la lista se evalúa en el contexto de lista, y el valor de lista resultante es
interpolado en LIST como si cada elemento individual fuera un miembro de LIST. Por lo tanto
matrices y hashes pierden su identidad en una LISTA - la lista

(@ foo, @ bar y SomeSub,% glarch)

contiene todos los elementos de @foo seguidos de todos los elementos de @bar, seguidos de todos
los elementos devueltos por la subrutina llamada SomeSub llamada en el contexto de la lista, seguidos de
los pares clave / valor de% glarch. Para hacer una referencia de lista que no NO interpolar, ver
perlref.

La lista nula está representada por (). Interpolarlo en una lista no tiene ningún efecto. Por lo tanto
((),(),()) es equivalente a (). De manera similar, la interpolación de una matriz sin elementos es la
lo mismo que si no se hubiera interpolado ninguna matriz en ese punto.

Esta interpolación se combina con el hecho de que los paréntesis de apertura y cierre son
opcional (excepto cuando sea necesario para la precedencia) y las listas pueden terminar con una coma opcional
en el sentido de que varias comas dentro de listas son sintaxis legal. La lista "1, 3" es una
concatenación de dos listas, "1" y 3, la primera de las cuales termina con esa coma opcional.
"1,, 3" es "(1,), (3)" es "1,3" (Y de manera similar para "1 ,,, 3" es "(1,), (,), 3" es "1,3 , XNUMX "y así
on.) No es que le aconsejemos que utilice esta ofuscación.

Un valor de lista también se puede incluir en un subíndice como una matriz normal. Debes poner la lista en
paréntesis para evitar ambigüedades. Por ejemplo:

# Stat devuelve el valor de la lista.
$ tiempo = (stat ($ archivo)) [8];

# ERROR DE SINTAXIS AQUÍ.
$ tiempo = stat ($ archivo) [8]; # OOPS, OLVIDÓ A LOS PADRES

# Encuentra un dígito hexadecimal.
$ hexdigit = ('a', 'b', 'c', 'd', 'e', ​​'f') [$ dígito-10];

# Un "operador de coma inversa".
return (pop (@foo), pop (@foo)) [0];

Las listas se pueden asignar solo cuando cada elemento de la lista es legal para asignar a:

($ a, $ b, $ c) = (1, 2, 3);

($ mapa {'rojo'}, $ mapa {'azul'}, $ mapa {'verde'}) = (0x00f, 0x0f0, 0xf00);

Una excepción a esto es que puede asignar "undef" en una lista. Esto es útil para
desechando algunos de los valores de retorno de una función:

($ dev, $ ino, undef, undef, $ uid, $ gid) = stat ($ archivo);

A partir de Perl 5.22, también puede utilizar "(undef) x2" en lugar de "undef, undef". (También puedes hacer
"($ x) x 2", que es menos útil, porque asigna a la misma variable dos veces,
golpeando el primer valor asignado.)

La asignación de lista en contexto escalar devuelve el número de elementos producidos por el
expresión en el lado derecho de la asignación:

$ x = (($ foo, $ bar) = (3,2,1)); # establece $ x en 3, no en 2
$ x = (($ foo, $ barra) = f ()); # establecer el recuento de devoluciones de $ x af ()

Esto es útil cuando desea hacer una asignación de lista en un contexto booleano, porque la mayoría
Las funciones de lista devuelven una lista nula cuando terminan, que cuando se asignan produce un 0, que
se interpreta como FALSO.

También es la fuente de un lenguaje útil para ejecutar una función o realizar una operación.
en el contexto de la lista y luego contando el número de valores devueltos, asignando a un vacío
list y luego usar esa asignación en contexto escalar. Por ejemplo, este código:

$ cuenta = () = $ cadena = ~ / \ d + / g;

colocará en $ count el número de grupos de dígitos encontrados en $ string. Esto sucede porque
la coincidencia de patrón está en el contexto de la lista (ya que se está asignando a la lista vacía), y
por lo tanto, devolverá una lista de todas las partes coincidentes de la cadena. La lista de asignaciones en
El contexto escalar traducirá eso en el número de elementos (aquí, el número de veces
el patrón coincide) y asígnelo a $ count. Tenga en cuenta que simplemente usando

$ cuenta = $ cadena = ~ / \ d + / g;

no hubiera funcionado, ya que una coincidencia de patrón en un contexto escalar solo devolverá verdadero o
falso, en lugar de un recuento de coincidencias.

El elemento final de una asignación de lista puede ser una matriz o un hash:

($ a, $ b, @rest) = dividir;
my ($ a, $ b,% resto) = @_;

De hecho, puede poner una matriz o hash en cualquier lugar de la lista, pero el primero de la lista
absorberá todos los valores, y cualquier cosa posterior quedará indefinida. Esto podría ser
útil en un mi() or local().

Un hash se puede inicializar usando una lista literal que contiene pares de elementos para ser interpretados como
una clave y un valor:

# igual que la asignación de mapa anterior
%map = ('red',0x00f,'blue',0x0f0,'green',0xf00);

Si bien las listas literales y las matrices con nombre a menudo son intercambiables, ese no es el caso de
hashes. El hecho de que pueda subíndice un valor de lista como una matriz normal no significa
que puede subíndice un valor de lista como un hash. Del mismo modo, los hash incluidos como partes de
otras listas (incluidas listas de parámetros y listas de retorno de funciones) siempre se aplanan
en pares clave / valor. Por eso es bueno usar referencias a veces.

A menudo es más legible utilizar el operador "=>" entre pares clave / valor. El "=>"
operador es principalmente un sinónimo más distintivo visual de una coma, pero también
hace arreglos para que su operando de la izquierda se interprete como una cadena si es una palabra desnuda que
sería un identificador simple legal. "=>" no cita identificadores compuestos, que contienen
dos puntos dobles. Esto lo hace bueno para inicializar hashes:

% mapa = (
rojo => 0x00f,
azul => 0x0f0,
verde => 0xf00,
);

o para inicializar referencias hash que se utilizarán como registros:

$ rec = {
bruja => 'Mable el Despiadado',
gato => 'Fluffy el Feroz',
fecha => '10 / 31/1776 ',
};

o para usar call-by-named-parameter para funciones complicadas:

$ campo = $ consulta-> grupo_de_radio (
nombre => 'nombre_grupo',
valores => ['eenie', 'meenie', 'minie'],
predeterminado => 'meenie',
linebreak => 'verdadero',
etiquetas => \% etiquetas
);

Tenga en cuenta que el hecho de que un hash se inicialice en ese orden no significa que salga
en ese orden. Consulte "ordenar" en perlfunc para ver ejemplos de cómo organizar una salida.
ordenando

Si una clave aparece más de una vez en la lista de inicializadores de un hash, la última aparición
gana:

% círculo = (
centro => [5, 10],
centro => [27, 9],
radio => 100,
color => [0xDF, 0xFF, 0x00],
radio => 54,
);

# igual que
% círculo = (
centro => [27, 9],
color => [0xDF, 0xFF, 0x00],
radio => 54,
);

Esto se puede utilizar para proporcionar valores predeterminados de configuración reemplazables:

# valores en% args tienen prioridad sobre% config_defaults
% config = (% config_defaults,% args);

Subíndices
Se puede acceder a una matriz un escalar a la vez especificando un signo de dólar ("$"), luego el
nombre de la matriz (sin la "@" inicial), luego el subíndice entre corchetes.
Por ejemplo:

@myarray = (5, 50, 500, 5000);
print "El tercer elemento es", $ myarray [2], "\ n";

Los índices de la matriz comienzan con 0. Un subíndice negativo recupera su valor desde el final.
En nuestro ejemplo, $ myarray [-1] habría sido 5000 y $ myarray [-2] habría sido 500.

Los subíndices hash son similares, solo que en lugar de corchetes se utilizan corchetes. Para
ejemplo:

% científicos =
(
"Newton" => "Isaac",
"Einstein" => "Albert",
"Darwin" => "Charles",
"Feynman" => "Richard",
);

imprimir "El nombre de Darwin es", $ scientist {"Darwin"}, "\ n";

También puede subíndice una lista para obtener un solo elemento de ella:

$ dir = (getpwnam ("demonio")) [7];

Multidimensional matriz emulación
Las matrices multidimensionales se pueden emular subindicando un hash con una lista. Los elementos
de la lista se unen con el separador de subíndices (ver "$;" en perlvar).

$ foo {$ a, $ b, $ c}

es equivalente a

$ foo {unirse ($ ;, $ a, $ b, $ c)}

El separador de subíndice predeterminado es "\ 034", lo mismo que SUBSEP en awk.

rebanadas
Un segmento accede a varios elementos de una lista, una matriz o un hash simultáneamente mediante un
lista de subíndices. Es más conveniente que escribir los elementos individuales como un
lista de valores escalares separados.

($ él, $ ella) = @folks [0, -1]; # sector de matriz
@them = @folks [0 .. 3]; # sector de matriz
($ quién, $ casa) = @ENV {"USUARIO", "CASA"}; # rebanada de hash
($ uid, $ dir) = (getpwnam ("demonio")) [2,7]; # sector de lista

Dado que puede asignar a una lista de variables, también puede asignar a una matriz o hash
rebanada.

@days [3..5] = qw / Wed Thu Fri /;
@colors {'rojo', 'azul', 'verde'}
= (0xff0000, 0x0000ff, 0x00ff00);
@folks [0, -1] = @folks [-1, 0];

Las asignaciones anteriores son exactamente equivalentes a

($ días [3], $ días [4], $ días [5]) = qw / Wed Thu Fri /;
($ colores {'rojo'}, $ colores {'azul'}, $ colores {'verde'})
= (0xff0000, 0x0000ff, 0x00ff00);
($ gente [0], $ gente [-1]) = ($ gente [-1], $ gente [0]);

Dado que el cambio de un segmento cambia la matriz o el hash original que está dividiendo, un "foreach"
La construcción alterará algunos, o incluso todos, los valores de la matriz o hash.

foreach (@array [4 .. 10]) {s / peter / paul /}

foreach (@hash {qw [key1 key2]}) {
s / ^ \ s + //; # recortar los espacios en blanco iniciales
s / \ s + $ //; # recortar los espacios en blanco finales
s / (\ w +) / \ u \ L $ 1 / g; # palabras "titlecase"
}

Como excepción especial, cuando divide una lista (pero no una matriz o un hash), si la lista
se evalúa como vacío, luego tomar una porción de esa lista vacía siempre dará como resultado el vacío
lista a su vez. Por lo tanto:

@a = () [0,1]; # @a no tiene elementos
@b = (@a) [0,1]; # @b no tiene elementos
@c = (sub {} -> ()) [0,1]; # @c no tiene elementos
@d = ('a', 'b') [0,1]; # @d tiene dos elementos
@e = (@d) [0,1,8,9]; # @e tiene cuatro elementos
@f = (@d) [8,9]; # @f tiene dos elementos

Esto facilita la escritura de bucles que terminan cuando se devuelve una lista nula:

while (($ hogar, $ usuario) = (getpwent) [7,0]) {
printf "% -8s% s \ n", $ usuario, $ inicio;
}

Como se señaló anteriormente en este documento, el sentido escalar de asignación de lista es el número de
elementos en el lado derecho de la tarea. La lista nula no contiene elementos, por lo que
cuando se agota el archivo de contraseña, el resultado es 0, no 2.

Los sectores en contexto escalar devuelven el último elemento del sector.

@a = qw / primer segundo tercio /;
% h = (primero => 'A', segundo => 'B');
$ t = @a [0, 1]; # $ t ahora es 'segundo'
$ u = @h {'primero', 'segundo'}; # $ u ahora es 'B'

Si está confundido acerca de por qué usa una '@' allí en un trozo de hash en lugar de un '%', piense
de ella así. El tipo de corchete (cuadrado o rizado) determina si es una matriz o una
hash que se mira. Por otro lado, el símbolo inicial ('$' o '@') en la matriz o
hash indica si está recuperando un valor singular (un escalar) o uno plural (un
lista).

Valor clave Hash rebanadas

A partir de Perl 5.20, una operación de trozo de hash con el símbolo% es una variante de segmento
operación que devuelve una lista de pares clave / valor en lugar de solo valores:

% h = (blonk => 2, foo => 3, squink => 5, bar => 8);
% subconjunto =% h {'foo', 'bar'}; # segmento de hash clave / valor
#% subconjunto es ahora (foo => 3, bar => 8)

Sin embargo, el resultado de dicho segmento no se puede localizar, eliminar ni utilizar en una asignación.
Por lo demás, estos son muy consistentes con los cortes de hash que usan el símbolo @.

Índice / Valor Formación rebanadas

Similar a los segmentos de hash clave / valor (y también introducido en Perl 5.20), el segmento de matriz%
la sintaxis devuelve una lista de pares índice / valor:

@a = "a" .. "z";
@list =% a [3,4,6];
# @list es ahora (3, "d", 4, "e", 6, "g")

Tipoglobs y Manijas de archivo
Perl usa un tipo interno llamado tipoglob para contener una entrada completa de la tabla de símbolos. El
El prefijo de tipo de un typeglob es un "*", porque representa todos los tipos. Este solía ser el
forma preferida de pasar matrices y hashes por referencia a una función, pero ahora que tenemos
referencias reales, esto rara vez es necesario.

El uso principal de typeglobs en Perl moderno es crear alias de tablas de símbolos. Esta asignación:

* esto = * eso;

hace que $ this sea un alias para $ eso, @this un alias para @that,% this un alias para% eso, & this
un alias para & that, etc. Es mucho más seguro utilizar una referencia. Esta:

local * Aquí :: azul = \ $ Allí :: verde;

temporalmente hace que $ Here :: blue sea un alias para $ There :: green, pero no hace que @Here :: blue sea un
alias para @There :: verde, o% Here :: azul un alias para% There :: verde, etc. Consulte "Símbolo
Tablas "en perlmod para ver más ejemplos de esto. Por extraño que parezca, este es el
base para todo el sistema de importación / exportación de módulos.

Otro uso de typeglobs es pasar identificadores de archivos a una función o crear nuevos
identificadores de archivo. Si necesita usar un typeglob para guardar un identificador de archivo, hágalo de esta manera:

$ fh = * STDOUT;

o quizás como una referencia real, así:

$ fh = \ * STDOUT;

Consulte perlsub para ver ejemplos de cómo usarlos como identificadores de archivos indirectos en funciones.

Typeglobs también es una forma de crear un identificador de archivo local usando el local() operador. Estos
duran hasta que se sale de su bloque, pero se pueden devolver. Por ejemplo:

sub nuevoabierto {
my $ path = shift;
local * FH; # ¡no es mio!
abrir (FH, $ ruta) o devolver undef;
return * FH;
}
$ fh = newopen ('/ Etc / passwd');

Ahora que tenemos la notación * foo {THING}, typeglobs no se usa tanto para filehandle
manipulaciones, aunque todavía son necesarias para pasar nuevos identificadores de archivos y directorios
dentro o fuera de funciones. Eso es porque * HANDLE {IO} solo funciona si HANDLE ya ha
Se ha utilizado como asa. En otras palabras, se debe usar * FH para crear una nueva tabla de símbolos
entradas; * foo {COSA} no puede. En caso de duda, utilice * FH.

Todas las funciones que son capaces de crear identificadores de archivos (open(), opendir (), tubo(),
socketpair (), sysopen (), zócalo ()y aceptar ()) crea automáticamente un anónimo
filehandle si el identificador que se les pasa es una variable escalar no inicializada. Esto permite
las construcciones como "open (my $ fh, ...)" y "open (local $ fh, ...)" que se utilizarán para crear
identificadores de archivo que se cerrarán convenientemente automáticamente cuando finalice el alcance, siempre
no hay otras referencias a ellos. Esto elimina en gran medida la necesidad de typeglobs.
al abrir identificadores de archivos que deben pasarse, como en el siguiente ejemplo:

sub miabierto {
abre mi $ fh, "@_"
o morir "No se puede abrir '@_': $!";
return $ fh;
}

{
my $ f = myopen ("
imprimir <$ f>;
# $ f implícitamente cerrado aquí
}

Tenga en cuenta que si se utiliza una variable escalar inicializada en su lugar, el resultado es diferente: "mi
$ fh = 'zzz'; open ($ fh, ...) "es equivalente a" open (* {'zzz'}, ...) "." use 'refs' estrictos "
prohíbe tal práctica.

Otra forma de crear identificadores de archivos anónimos es con el módulo Símbolo o con el
IO :: Módulo de asa y similares. Estos módulos tienen la ventaja de no esconder diferentes
tipos del mismo nombre durante el local(). Consulte la parte inferior de "abrir" en perlfunc para obtener una
ejemplo.

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