perlvar - Online en la nube

PROGRAMA:

NOMBRE

perlvar - Variables predefinidas de Perl

DESCRIPCIÓN

El Sintaxis of Variable nombres
Los nombres de variables en Perl pueden tener varios formatos. Por lo general, deben comenzar con una letra.
o subrayado, en cuyo caso pueden ser arbitrariamente largos (hasta un límite interno de 251
caracteres) y puede contener letras, dígitos, guiones bajos o la secuencia especial "::" o
"'". En este caso, la parte anterior al último "::" o "'" se toma como un PARA DOS
índice; ver perlmod.

Los nombres de las variables de Perl también pueden ser una secuencia de dígitos o una sola puntuación o control
carácter (con la forma de carácter de control literal en desuso). Estos nombres son todos
reservado para usos especiales por Perl; por ejemplo, los nombres de todos los dígitos se utilizan para contener datos
capturado por referencias inversas después de una coincidencia de expresión regular. Perl tiene una sintaxis especial
para los nombres de caracteres de control único: se entiende que "^ X" (intercalación "X") significa el
control- Carácter "X". Por ejemplo, la notación $ ^ W (signo de dólar intercalado "W") es la
variable escalar cuyo nombre es el control de un solo carácter - "W". Esto es mejor que
escribiendo un control literal - "W" en su programa.

Desde Perl v5.6.0, los nombres de las variables de Perl pueden ser cadenas alfanuméricas que comienzan con un signo de intercalación.
(o un personaje de control, pero esta forma está en desuso). Estas variables deben escribirse en
el formulario "$ {^ Foo}"; las llaves no son opcionales. "$ {^ Foo}" denota la variable escalar
cuyo nombre es un control- "F" seguida de dos "o". Estas variables están reservadas para
futuros usos especiales de Perl, excepto los que comienzan con "^ _" (control-subrayado
o signo de intercalación-subrayado). Ningún nombre de carácter de control que comience con "^ _" adquirirá un
significado especial en cualquier versión futura de Perl; Por tanto, dichos nombres se pueden utilizar de forma segura en
programas. $ ^ _ en sí mismo, sin embargo, is reservado.

Los identificadores de Perl que comienzan con dígitos, caracteres de control o caracteres de puntuación son
exentos de los efectos de la declaración de "paquete" y siempre están obligados a estar en
paquete "principal"; también están exentos de errores "estrictos 'vars'". Algunos otros nombres son
también exentos de estas formas:

ESTÁNDAR ENV
INC SALIDA ESTÁNDAR
ARGV ESTDERR
ARGV SALIDA
SIG

En particular, las variables especiales "$ {^ _ XYZ}" siempre se consideran en el paquete "main",
independientemente de cualquier declaración de "paquete" actualmente en el alcance.

SPECIAL VARIABLES

Los siguientes nombres tienen un significado especial para Perl. La mayoría de los nombres de puntuación tienen razonables
mnemotécnicos o análogos en las conchas. Sin embargo, si desea utilizar una variable larga
nombres, solo necesitas decir:

usa el inglés;

en la parte superior de su programa. Esto alias todos los nombres cortos a los nombres largos en el
El paquete actual. Algunos incluso tienen nombres medianos, generalmente tomados de awk. Para obtener más
información, consulte inglés.

Antes de continuar, observe el orden de clasificación de las variables. En general, primero enumeramos los
variables en orden casi lexigráfico que no distingue entre mayúsculas y minúsculas (ignorando el "{" o "^"
palabras anteriores, como en "$ {^ UNICODE}" o $ ^ T), aunque $ _ y @_ suben a la parte superior de la
pila. Para las variables con el mismo identificador, lo enumeramos en orden de escalar, matriz, hash,
y palabra desnuda.

General Variables
$ ARG
$ _ El espacio predeterminado de entrada y búsqueda de patrones. Los siguientes pares son
equivalente:

while (<>) {...} # equivalente solo en while!
while (definido ($ _ = <>)) {...}

/ ^ Asunto: /
$ _ = ~ / ^ Asunto: /

tr / az / AZ /
$ _ = ~ tr / az / AZ /

chomp
masticar ($ _)

Estos son los lugares donde Perl asumirá $ _ incluso si no lo usa:

· Las siguientes funciones usan $ _ como argumento predeterminado:

abs, alarma, chomp, chop, chr, chroot, cos, definido, eval, evalbytes, exp, fc,
glob, hex, int, lc, lcfirst, longitud, iniciar sesión, lstat, mkdir, oct, ord, pos, imprimir,
printf, quotemeta, readlink, readpipe, ref, require, reverse (en contexto escalar
solo), rmdir, digamos, sin, dividir (para su segundo argumento), sqrt, stat, study, uc,
ucfirst, desvincular, desempaquetar.

· Todas las pruebas de archivo ("-f", "-d") excepto "-t", que por defecto es STDIN. Ver "-X"
en perlfunc

· Las operaciones de coincidencia de patrones "m //", "s ///" y "tr ///" (también conocidas como "y ///") cuando
utilizado sin un operador "= ~".

· La variable de iterador predeterminada en un bucle "foreach" si no hay otra variable
suministrado.

· La variable iteradora implícita en las funciones "grep ()" y "map ()".

· La variable implícita de "dado ()".

· El lugar predeterminado para colocar el siguiente valor o registro de entrada cuando un " ",
"readline", "readdir" o "cada" resultado de la operación se prueba por sí mismo como el
único criterio de una prueba "mientras". Fuera de una prueba de "mientras", esto no
suceder.

$ _ es por defecto una variable global. Sin embargo, a partir de perl v5.10.0, puede utilizar un
versión léxica de $ _ declarándolo en un archivo o en un bloque con "my".
Además, declarar "nuestro $ _" restaura el $ _ global en el ámbito actual. Sin embargo
esto parecía una buena idea en el momento de su introducción, el léxico $ _ en realidad
causa más problemas de los que resuelve. Si llama a una función que espera ser
pasa información a través de $ _, puede que funcione o no, dependiendo de cómo la función
está escrito, no hay una manera fácil de resolver esto. Simplemente evite el léxico $ _,
a menos que se sienta particularmente masoquista. Por esta razón, el léxico $ _ es
sigue siendo experimental y producirá una advertencia a menos que se hayan desactivado las advertencias.
Al igual que con otras características experimentales, el comportamiento del léxico $ _ está sujeto a
cambiar sin previo aviso, incluido el cambio a un error fatal.

Mnemónico: se entiende por subrayado en determinadas operaciones.

@ARG
@_ Dentro de una subrutina, la matriz @_ contiene los parámetros pasados ​​a esa
subrutina. Dentro de una subrutina, @_ es la matriz predeterminada para los operadores de matriz
"pop" y "shift".

Ver perlsub.

$ LIST_SEPARATOR
$ "Cuando una matriz o un segmento de matriz se interpola en una cadena entre comillas dobles o una
contexto similar como "/.../", sus elementos están separados por este valor.
El valor predeterminado es un espacio. Por ejemplo, esto:

print "La matriz es: @array \ n";

es equivalente a esto:

imprimir "La matriz es:". unirse ($ ", @array)." \ n ";

Mnemotécnico: funciona en contexto entre comillas dobles.

$ PROCESS_ID
$ PID
$$ El número de proceso de Perl que ejecuta este script. Aunque tu can establecer esto
variable, hacerlo generalmente no se recomienda, aunque puede ser invaluable para
algunos propósitos de prueba. Se restablecerá automáticamente a través de las llamadas "fork ()".

Nota para usuarios de Linux y Debian GNU / kFreeBSD: Antes de Perl v5.16.0, perl
emular la semántica POSIX en sistemas Linux utilizando LinuxThreads, una
implementación de subprocesos POSIX que desde entonces ha sido reemplazada por el POSIX nativo
Biblioteca de subprocesos (NPTL).

LinuxThreads ahora está obsoleto en Linux, y el almacenamiento en caché de "getpid ()" como este hizo
incrustar perl innecesariamente complejo (ya que tendría que actualizar manualmente el
valor de $$), por lo que ahora $$ y "getppid ()" siempre devolverán los mismos valores que el
biblioteca C subyacente.

Los sistemas Debian GNU / kFreeBSD también usaban LinuxThreads hasta la versión 6.0 inclusive.
release, pero luego se trasladó a la semántica de subprocesos de FreeBSD, que son similares a POSIX.

Para ver si su sistema se ve afectado por esta discrepancia, verifique si "getconf
GNU_LIBPTHREAD_VERSION | grep -q NPTL "devuelve un valor falso. Subprocesos NTPL
preservar la semántica POSIX.

Mnemotécnico: igual que las conchas.

$ PROGRAM_NAME
$ 0 Contiene el nombre del programa que se está ejecutando.

En algunos (pero no todos) los sistemas operativos, la asignación a $ 0 modifica el área de argumentos
que ve el programa "ps". En algunas plataformas, es posible que deba usar "ps" especiales
opciones o un "ps" diferente para ver los cambios. Modificar el $ 0 es más útil
como una forma de indicar el estado actual del programa que para ocultar el programa
estás corriendo.

Tenga en cuenta que existen limitaciones específicas de la plataforma sobre la longitud máxima de $ 0. En
el caso más extremo puede estar limitado al espacio ocupado por el $ 0 original.

En algunas plataformas puede haber una cantidad arbitraria de relleno, por ejemplo, espacio
caracteres, después del nombre modificado como se muestra con "ps". En algunas plataformas esto
el relleno puede extenderse hasta la longitud original del área de argumento, no
importa lo que haga (este es el caso, por ejemplo, de Linux 2.2).

Nota para los usuarios de BSD: configurar $ 0 no elimina completamente "perl" del ps(1)
producción. Por ejemplo, establecer $ 0 en "foobar" puede resultar en "perl: foobar (perl)"
(si se muestran tanto el prefijo "perl:" como el sufijo "(perl)" depende de
su variante y versión exacta de BSD). Esta es una característica del sistema operativo, Perl
no puedo evitarlo.

En scripts multiproceso, Perl coordina los subprocesos para que cualquier subproceso pueda
modifica su copia del $ 0 y el cambio se vuelve visible para ps(1) (asumiendo el
el sistema operativo sigue el juego). Tenga en cuenta que la vista de $ 0 que tienen los otros hilos
no cambiará ya que tienen sus propias copias.

Si el programa ha sido entregado a perl a través de los interruptores "-e" o "-E", $ 0 será
contienen la cadena "-e".

En Linux a partir de perl v5.14.0, el nombre del proceso heredado se establecerá con prctl(2), en
además de alterar el nombre POSIX a través de "argv [0]" como lo ha hecho Perl desde la versión
4.000. Ahora, las utilidades del sistema que leen el nombre del proceso heredado, como ps, top y
killall reconocerá el nombre que configuró al asignar $ 0. La cuerda que
el suministro se cortará a 16 bytes, esta es una limitación impuesta por Linux.

Mnemónico: igual que sh y ksh.

$ REAL_GROUP_ID
$ GID
$ (El verdadero gid de este proceso. Si está en una máquina que admite la membresía en
varios grupos simultáneamente, proporciona una lista separada por espacios de los grupos en los que se encuentra.
El primer número es el devuelto por "getgid ()", y los siguientes por
"getgroups ()", uno de los cuales puede ser el mismo que el primer número.

Sin embargo, un valor asignado a $ (debe ser un único número utilizado para establecer el gid real.
Entonces, el valor dado por $ (debería no ser asignado de nuevo a $ (sin ser forzado
numérico, como la suma de cero. Tenga en cuenta que esto es diferente al gid efectivo
($)) que sí toma una lista.

Puede cambiar tanto el gid real como el gid efectivo al mismo tiempo usando
"POSIX :: setgid ()". Cambios en $ (requiere un cheque en $! Para detectar cualquier posible
errores después de un intento de cambio.

Mnemotécnico: los paréntesis se utilizan para grupo de XNUMX cosas. El verdadero gid es el grupo que
left, si está ejecutando setgid.

$ EFFECTIVE_GROUP_ID
$ EGID
$) El gid efectivo de este proceso. Si está en una máquina que admite
membresía en varios grupos simultáneamente, da una lista separada por espacios de
grupos en los que se encuentra. El primer número es el que devuelve "getegid ()", y el
los siguientes por "getgroups ()", uno de los cuales puede ser el mismo que el primero
número.

De manera similar, un valor asignado a $) también debe ser una lista de números separados por espacios.
El primer número establece el gid efectivo y el resto (si corresponde) se pasa a
"grupos de conjuntos ()". Para obtener el efecto de una lista vacía para "setgroups ()", simplemente repita
el nuevo gid efectivo; es decir, forzar un gid efectivo de 5 y un efectivo
lista vacía "setgroups ()", digamos "$) =" 5 5 "".

Puede cambiar tanto el gid efectivo como el gid real al mismo tiempo usando
"POSIX :: setgid ()" (use solo un único argumento numérico). Los cambios en $) requieren un
cheque a $! para detectar posibles errores después de un intento de cambio.

$ <, $>, $ (y $) solo se pueden configurar en máquinas que admitan el correspondiente
establecer [re] [ug] id () rutina. $ (y $) solo se pueden intercambiar en máquinas que admitan
"setregid ()".

Mnemotécnico: los paréntesis se utilizan para grupo de XNUMX cosas. El gid efectivo es el grupo
Diseñado un Derecho para usted, si está ejecutando setgid.

$ REAL_USER_ID
$ UID
$ <El uid real de este proceso. Puede cambiar tanto el fluido real como el efectivo
uid al mismo tiempo usando "POSIX :: setuid ()". Dado que los cambios a $ <requieren un
llamada al sistema, verifique $! después de un cambio, intente detectar posibles errores.

Mnemotécnico: es el uid que viniste obtenidos de, si está ejecutando setuid.

$ EFFECTIVE_USER_ID
$ EUID
$> El uid efectivo de este proceso. Por ejemplo:

$ <= $>; # establecer uid de real a efectivo
($ <, $>) = ($>, $ <); # intercambiar fluidos reales y efectivos

Puede cambiar tanto el uid efectivo como el uid real al mismo tiempo usando
"POSIX :: setuid ()". ¡Los cambios a $> requieren un cheque a $! para detectar cualquier posible
errores después de un intento de cambio.

$ <y $> solo se pueden intercambiar en máquinas que admitan "setreuid ()".

Mnemotécnico: es el uid al que fuiste a, si está ejecutando setuid.

$ SUBSCRIPT_SEPARATOR
$ SUBSEP
PS El separador de subíndices para la emulación de matrices multidimensionales. Si se refiere a un
elemento hash como

$ foo {$ x, $ y, $ z}

realmente significa

$ foo {unirse ($ ;, $ x, $ y, $ z)}

Pero no pongas

@foo {$ x, $ y, $ z} # una porción - tenga en cuenta la @

lo que significa

($ foo {$ x}, $ foo {$ y}, $ foo {$ z})

El valor predeterminado es "\ 034", lo mismo que SUBSEP en awk. Si sus claves contienen datos binarios
puede que no haya ningún valor seguro para $ ;.

Considere el uso de matrices multidimensionales "reales" como se describe en perllol.

Mnemónico: coma (el separador de subíndice sintáctico) es un punto y coma.

$a
$ b Variables de paquete especiales cuando se usa "sort ()", vea "sort" en perlfunc. Porque
esta especialidad $ a y $ b no necesitan ser declaradas (usando "use vars", o
"nuestro ()") incluso cuando se usa el pragma "estricto 'vars'". No los lexicalice con
"my $ a" o "my $ b" si quieres poder usarlos en la comparación "sort ()"
bloque o función.

% ENV El hash% ENV contiene su entorno actual. Establecer un valor en los cambios "ENV"
el entorno para cualquier proceso secundario que posteriormente "bifurque ()".

A partir de la versión 5.18.0, tanto las claves como los valores almacenados en% ENV están en cadena.

my $ foo = 1;
$ ENV {'barra'} = \ $ foo;
if (ref $ ENV {'bar'}) {
diga "Comportamiento anterior a 5.18.0";
} Else {
diga "Post 5.18.0 Behavior";
}

Anteriormente, solo los procesos secundarios recibían valores en cadena:

my $ foo = 1;
$ ENV {'barra'} = \ $ foo;

# Siempre impreso 'no ref'
sistema ($ ^ X, '-e',
q / print (ref $ ENV {'bar'}? 'ref': 'no ref') /);

Esto sucede porque realmente no puede compartir estructuras de datos arbitrarias con
de los empleados.

$ OLD_PERL_VERSION
$] La revisión, versión y subversión del intérprete de Perl, representada como un
decimal de la forma 5.XXXYYY, donde XXX es la versión / 1e3 y YYY es la
subversion / 1e6. Por ejemplo, Perl v5.10.1 sería "5.010001".

Esta variable se puede utilizar para determinar si el intérprete de Perl que ejecuta un
script está en el rango correcto de versiones:

advertir "¡No PerlIO! \ n" si $] lt '5.008';

Al comparar $], los operadores de comparación de cadenas son highly recomendado.
Las limitaciones inherentes de la representación de coma flotante binaria a veces pueden conducir a
comparaciones incorrectas para algunos números en algunas arquitecturas.

Consulte también la documentación de "use VERSION" y "require VERSION" para una conveniente
forma de fallar si el intérprete de Perl en ejecución es demasiado antiguo.

Consulte "$ ^ V" para ver una representación de la versión de Perl como un objeto de versión, que
permite comparaciones de cadenas más flexibles.

La principal ventaja de $] sobre $ ^ V es que funciona igual en cualquier versión de
Perl. Las desventajas son que no se puede comparar fácilmente con versiones de otros
formatos (por ejemplo, cadenas v literales, "v1.2.3" u objetos de versión) y numéricos
las comparaciones pueden fallar ocasionalmente; es bueno para verificaciones de versión literal de cadena y
malo para comparar con una variable que no ha sido revisada.

El formulario $ OLD_PERL_VERSION se agregó en Perl v5.20.0 por razones históricas, pero
se desaconseja su uso. (Si su razón para usar $] es ejecutar código en perls antiguas, entonces
referirse a él como $ OLD_PERL_VERSION sería contraproducente).

Mnemónico: ¿Está esta versión de perl en el corchete correcto?

$ SYSTEM_FD_MAX
$ ^ F El descriptor máximo de archivos del sistema, normalmente 2. Los descriptores de archivos del sistema son
se pasa a los procesos ed "exec ()", mientras que los descriptores de archivo superiores no lo son. También,
durante un "open ()", los descriptores de archivos del sistema se conservan incluso si el "open ()"
falla (los descriptores de archivo ordinarios se cierran antes de intentar "abrir ()").
El estado de cierre en ejecución de un descriptor de archivo se decidirá de acuerdo con el
valor de $ ^ F cuando se abrió el archivo, tubería o enchufe correspondiente, no la hora
del "exec ()".

@F La matriz @F contiene los campos de cada línea leídos cuando el modo de división automática está
encendido. Ver perlrun para el -a cambiar. Esta matriz es específica del paquete y
debe ser declarado o dado un nombre de paquete completo si no está en el paquete principal cuando se ejecuta
en "vars estrictas" ".

@INC La matriz @INC contiene la lista de lugares que "hacen EXPR", "requieren" o "usan"
las construcciones buscan sus archivos de biblioteca. Inicialmente consta de los argumentos
a cualquier -I conmutadores de línea de comandos, seguidos de la biblioteca Perl predeterminada, probablemente
/ usr / local / lib / perl, seguido de ".", para representar el directorio actual. ("."
no se agregará si las comprobaciones de contaminación están habilitadas, ya sea por "-T" o por "-t".) Si
necesita modificar esto en tiempo de ejecución, debe usar el pragma "use lib" para obtener el
biblioteca dependiente de la máquina correctamente cargada también:

use lib '/ mypath / libdir /';
usa SomeMod;

También puede insertar ganchos en el sistema de inclusión de archivos poniendo código Perl
directamente en @INC. Esos ganchos pueden ser referencias de subrutina, referencias de matriz o
objetos benditos. Consulte "require" en perlfunc para obtener más detalles.

% INC El hash% INC contiene entradas para cada nombre de archivo incluido a través de "do", "require",
o "utilizar" operadores. La clave es el nombre de archivo que especificó (con nombres de módulo
convertido a nombres de ruta), y el valor es la ubicación del archivo encontrado. El
El operador "require" usa este hash para determinar si un archivo en particular tiene
ya ha sido incluido.

Si el archivo se cargó a través de un gancho (por ejemplo, una referencia de subrutina, consulte "require" en
perlfunc para obtener una descripción de estos ganchos), este gancho se inserta por defecto en
% INC en lugar de un nombre de archivo. Sin embargo, tenga en cuenta que el gancho puede haber establecido el% INC
entrada por sí misma para proporcionar información más específica.

$ INPLACE_EDIT
$ ^ I El valor actual de la extensión de edición en lugar. Use "undef" para deshabilitar en lugar
edición.

Mnemónico: valor de -i switch.

$ ^ M Por defecto, quedarse sin memoria es un error fatal que no se puede atrapar. Sin embargo, si
adecuadamente construido, Perl puede usar el contenido de $ ^ M como un grupo de memoria de emergencia después
"morir ()" ing. Suponga que su Perl fue compilado con "-DPERL_EMERGENCY_SBRK" y
usó malloc de Perl. Entonces

$ ^ M = 'a' x (1 << 16);

asignaría un búfer de 64 K para su uso en caso de emergencia. Ver el INSTALAR presentar en el
Distribución de Perl para obtener información sobre cómo agregar indicadores de compilación C personalizados cuando
compilando perl. Para desalentar el uso casual de esta función avanzada, no hay
Nombre largo en inglés para esta variable.

Esta variable se agregó en Perl 5.004.

$ OSNAME
$ ^ O El nombre del sistema operativo bajo el cual se construyó esta copia de Perl, como
determinado durante el proceso de configuración. Para ver ejemplos, consulte "PLATAFORMAS" en
puerto perl

El valor es idéntico a $ Config {'osname'}. Consulte también Config y el -V mando-
interruptor de línea documentado en perlrun.

En plataformas Windows, $ ^ O no es muy útil: dado que siempre es "MSWin32",
no dice la diferencia entre 95/98 / ME / NT / 2000 / XP / CE / .NET. Usar
"Win32 :: GetOSName ()" o Win32 :: GetOSVersion () (ver Win32 y perlport) para
distinguir entre las variantes.

Esta variable se agregó en Perl 5.003.

% SIG El hash% SIG contiene manejadores de señales para señales. Por ejemplo:

sub manejador {# el primer argumento es el nombre de la señal
mi ($ sig) = @_;
print "Cogió un SIG $ sig - cerrando \ n";
cerrar (LOG);
salida(0);
}

$ SIG {'INT'} = \ & controlador;
$ SIG {'SALIR'} = \ & handler;
...
$ SIG {'INT'} = 'POR DEFECTO'; # restaurar acción predeterminada
$ SIG {'SALIR'} = 'IGNORAR'; # ignorar SIGQUIT

Usar un valor de 'IGNORAR' generalmente tiene el efecto de ignorar la señal, excepto
para la señal "CHLD". Consulte perlipc para obtener más información sobre este caso especial.

A continuación se muestran algunos otros ejemplos:

$ SIG {"PIPE"} = "Plomero"; # asume main :: Plomero (no
# recomendado)
$ SIG {"TUBO"} = \ & Plomero; # muy bien; asumir actual
# Fontanero
$ SIG {"PIPE"} = * Plomero; # algo esotérico
$ SIG {"TUBO"} = Plomero (); # Ups, ¿qué hizo Fontanero ()
# ¿¿regreso??

Asegúrese de no usar una palabra desnuda como el nombre de un manejador de señales, para que no
inadvertidamente llámalo.

Si su sistema tiene la función "sigaction ()", los manejadores de señales están instalados
usándolo. Esto significa que obtiene un manejo de señal confiable.

La política de entrega predeterminada de señales cambió en Perl v5.8.0 de inmediato (también
conocidas como "inseguras") a diferidas, también conocidas como "señales seguras". Ver perlipc para
más información.

Ciertos ganchos internos también se pueden configurar utilizando el hash% SIG. La rutina indicada
by $ SIG {__ WARN__} se llama cuando un mensaje de advertencia está a punto de imprimirse. El
El mensaje de advertencia se pasa como primer argumento. La presencia de un "__WARN__"
hook hace que se suprima la impresión normal de advertencias en "STDERR". Ustedes
puede usar esto para guardar advertencias en una variable, o convertir las advertencias en errores fatales,
Me gusta esto:

local $ SIG {__ WARN__} = sub {die $ _ [0]};
eval $ proggie;

Como "__WARN__" no admite el enlace 'IGNORE', puede desactivar las advertencias
usando la subrutina vacía:

local $ SIG {__ WARN__} = sub {};

La rutina indicada por $ SIG {__ DIE__} se llama cuando se trata de una excepción fatal.
para ser arrojado. El mensaje de error se pasa como primer argumento. Cuando un
La rutina de enganche "__DIE__" regresa, el procesamiento de excepciones continúa como lo haría
tener en ausencia del gancho, a menos que la rutina del gancho en sí salga a través de un "goto
& sub ", una salida de bucle o un" die () ". El controlador" __DIE__ "está explícitamente deshabilitado
durante la llamada, para que pueda morir a causa de un controlador "__DIE__". Similarmente para
"__ADVERTIR__".

Debido a un error de implementación, se llama al gancho $ SIG {__ DIE__} incluso dentro de un
"eval ()". No use esto para reescribir una excepción pendiente en $ @, o como un extraño
sustituto de anular "CORE :: GLOBAL :: die ()". Esta extraña acción en un
la distancia se puede fijar en una versión futura de modo que $ SIG {__ DIE__} solo se llame si
su programa está a punto de salir, como era la intención original. Cualquier otro uso es
obsoleto.

Los controladores "__DIE __" / "__ WARN__" son muy especiales en un aspecto: pueden llamarse
para informar errores (probables) encontrados por el analizador. En tal caso, el analizador puede ser
en estado inconsistente, por lo que cualquier intento de evaluar el código Perl de dicho controlador
probablemente resultará en una falla secundaria. Esto significa que las advertencias o errores que
El resultado del análisis de Perl debe usarse con extrema precaución, como este:

requiere Carpa si se define $ ^ S;
Carp :: confesar ("Algo anda mal") si está definido & Carp :: confesar;
morir "Algo va mal, pero no se pudo cargar Carp para dar"
. "retroceso ... \ n \ t"
. "Para ver el retroceso, intente iniciar Perl con el modificador -MCarp";

Aquí la primera línea cargará "Carp" a menos que es el analizador que llamó al
manipulador. La segunda línea imprimirá el trazado hacia atrás y morirá si "Carp" estaba disponible.
La tercera línea se ejecutará solo si "Carp" no estaba disponible.

Tener que pensar siquiera en la variable $ ^ S en sus controladores de excepciones es simplemente
incorrecto. $ SIG {__ DIE__}, tal como se implementa actualmente, invita a personas graves y difíciles
rastrear errores. Evítelo y use un "END {}" o CORE :: GLOBAL :: die override
preferiblemente.

Consulte "morir" en perlfunc, "advertir" en perlfunc, "eval" en perlfunc y advertencias para
Información Adicional.

$ TIEMPO BASE
$ ^ T La hora a la que el programa comenzó a ejecutarse, en segundos desde la época (comenzando
de 1970). Los valores devueltos por -M, -Ay -C las pruebas de archivo se basan en esto
.

$ PERL_VERSION
$ ^ V La revisión, versión y subversión del intérprete de Perl, representada como un
objeto de versión.

Esta variable apareció por primera vez en perl v5.6.0; versiones anteriores de perl verán un
valor indefinido. Antes de perl v5.10.0 $ ^ V se representaba como una cadena en v en lugar de
que un objeto de versión.

$ ^ V se puede utilizar para determinar si el intérprete de Perl que ejecuta un script está en
la gama adecuada de versiones. Por ejemplo:

advertir "¡Hashes no aleatorios! \ n" si! $ ^ V o $ ^ V lt v5.8.1

Mientras que los objetos de versión sobrecargan la cadena, para convertir de manera portátil $ ^ V en su
representación de cadena, use la conversión "% vd" de "sprintf ()", que funciona tanto para
v-strings u objetos de versión:

printf "la versión es v% vd \ n", $ ^ V; # Versión de Perl

Consulte la documentación de "use VERSION" y "require VERSION" para una forma conveniente
fallar si el intérprete de Perl en ejecución es demasiado antiguo.

Consulte también $] para obtener una representación decimal de la versión Perl.

La principal ventaja de $ ^ V sobre $] es que, para Perl v5.10.0 o posterior, se sobrecarga
operadores, lo que permite una fácil comparación con otras representaciones de versiones (p. ej.
decimal, literal v-string, "v1.2.3" u objetos). La desventaja es que antes
a v5.10.0, era solo una cadena en v literal, que no se puede imprimir o imprimir fácilmente
comparado.

Mnemónico: use ^ V para un objeto de versión.

$ {^ WIN32_SLOPPY_STAT}
Si esta variable se establece en un valor verdadero, entonces "stat ()" en Windows no intentará
abre el archivo. Esto significa que el recuento de enlaces no se puede determinar y archivar
Los atributos pueden estar desactualizados si existen vínculos físicos adicionales al archivo. Sobre el
Por otro lado, no abrir el archivo es considerablemente más rápido, especialmente para archivos en
unidades de red.

Esta variable se puede establecer en el sitiopersonalizar.pl archivo para configurar el local
Instalación de Perl para usar "descuidado" "stat ()" por defecto. Consulte la documentación para
-f en perlrun para obtener más información sobre la personalización del sitio.

Esta variable se agregó en Perl v5.10.0.

$ EXECUTABLE_NAME
$ ^ X El nombre usado para ejecutar la copia actual de Perl, de "argv [0]" de C o (donde
soportado) / proc / self / exe.

Dependiendo del sistema operativo del host, el valor de $ ^ X puede ser relativo o
nombre de ruta absoluta del archivo de programa perl, o puede ser la cadena utilizada para invocar
perl pero no el nombre de ruta del archivo de programa perl. Además, la mayoría de los sistemas operativos
permitir invocar programas que no están en la variable de entorno PATH, por lo que no
no es garantía de que el valor de $ ^ X esté en PATH. Para VMS, el valor puede o puede
no incluye un número de versión.

Por lo general, puede usar el valor de $ ^ X para volver a invocar una copia independiente del mismo
perl que se está ejecutando actualmente, por ejemplo,

@first_run = `$ ^ X -le" imprime int rand 100 para 1..100 "`;

Pero recuerde que no todos los sistemas operativos admiten la bifurcación o captura de
salida de comandos, por lo que esta compleja declaración puede no ser portátil.

No es seguro utilizar el valor de $ ^ X como nombre de ruta de un archivo, ya que algunos
Los sistemas que tienen un sufijo obligatorio en archivos ejecutables no requieren el uso de la
sufijo al invocar un comando. Para convertir el valor de $ ^ X en un nombre de ruta, use
las siguientes declaraciones:

# Cree un conjunto de nombres de archivos (no nombres de comandos).
usar configuración;
my $ this_perl = $ ^ X;
if ($ ^ O ne 'VMS') {
$ this_perl. = $ Config {_exe}
a menos que $ this_perl = ~ m / $ Config {_exe} $ / i;
}

Porque muchos sistemas operativos permiten que cualquier persona con acceso de lectura al programa Perl
archivo para hacer una copia, parchear la copia y luego ejecutar la copia, el
El programador de Perl consciente de la seguridad debe tener cuidado de invocar la copia instalada
de perl, no la copia a la que hace referencia $ ^ X. Las siguientes declaraciones logran esto
objetivo, y producir un nombre de ruta que se puede invocar como un comando o referenciar como un
archivo.

usar configuración;
my $ ruta_perl_segura = $ Config {ruta_perl};
if ($ ^ O ne 'VMS') {
$ ruta_perl_segura. = $ Config {_exe}
a menos que $ ruta_perl_segura = ~ m / $ Config {_exe} $ / i;
}

Variables relacionado a regular expresiones
La mayoría de las variables especiales relacionadas con las expresiones regulares son efectos secundarios. Conjuntos de perl
estas variables cuando tiene una coincidencia exitosa, por lo que debe verificar el resultado de la coincidencia
antes de usarlos. Por ejemplo:

si (/ P (A) TT (ER) N /) {
print "Encontré $ 1 y $ 2 \ n";
}

Estas variables son de solo lectura y de ámbito dinámico, a menos que indiquemos lo contrario.

La naturaleza dinámica de las variables de expresión regular significa que su valor es limitado
al bloque en el que se encuentran, como lo demuestra este fragmento de código:

my $ exterior = 'Wallace y Grommit';
my $ inner = 'Mutt y Jeff';

mi $ patrón = qr / (\ S +) y (\ S +) /;

sub show_n {print "\ $ 1 es $ 1; \ $ 2 es $ 2 \ n"}

{
EXTERIOR:
show_n () si $ exterior = ~ m / $ patrón /;

INTERNO: {
show_n () si $ interno = ~ m / $ patrón /;
}

mostrado();
}

La salida muestra que mientras que en el bloque "OUTER", los valores de $ 1 y $ 2 son del
coincidir con $ externo. Dentro del bloque "INNER", los valores de $ 1 y $ 2 son del
coincidir con $ inner, pero solo hasta el final del bloque (es decir, el alcance dinámico). Después
el bloque "INNER" se completa, los valores de $ 1 y $ 2 vuelven a los valores de la coincidencia
contra $ externo aunque no hayamos hecho otra coincidencia:

$ 1 es Wallace; $ 2 es Grommit
$ 1 es Mutt; $ 2 es Jeff
$ 1 es Wallace; $ 2 es Grommit

Performance cuestiones

Tradicionalmente en Perl, cualquier uso de cualquiera de las tres variables "$` ", $ & o" $ '"(o sus
"use equivalentes en inglés") en cualquier parte del código, causó todos los patrones posteriores exitosos
coincidencias para hacer una copia de la cadena coincidente, en caso de que el código pueda acceder posteriormente
una de esas variables. Esto impuso una considerable penalización de rendimiento en todo el
programa, por lo que en general se ha desaconsejado el uso de estas variables.

En Perl 5.6.0 se introdujeron las matrices dinámicas "@ -" y "@ +" que proporcionan los índices de
partidos exitosos. Entonces podrías, por ejemplo, hacer esto:

$ str = ~ / patrón /;

imprimir $ `, $ &, $ '; # malo: éxito de desempeño

impresión # buena: sin éxito de rendimiento
substr ($ str, 0, $ - [0]),
substr ($ cadena, $ - [0], $ + [0] - $ - [0]),
substr ($ cadena, $ + [0]);

En Perl 5.10.0, el indicador del operador de coincidencia "/ p" y "$ {^ PREMATCH}", "$ {^ MATCH}" y
Se introdujeron las variables "$ {^ POSTMATCH}", que le permitían sufrir las penalizaciones únicamente
en los patrones marcados con "/ p".

En Perl 5.18.0 en adelante, perl comenzó a notar la presencia de cada una de las tres variables
por separado, y solo copia la parte de la cadena requerida; así que en

$ `; PS "abcdefgh" = ~ / d /

perl solo copiaría la parte "abcd" de la cadena. Eso podría marcar una gran diferencia en
algo como

$ str = 'x' x 1_000_000;
PS # gritos
$ str = ~ / x / g # un carácter copiado un millón de veces, no un millón de caracteres

En Perl 5.20.0, se habilitó un nuevo sistema de copia en escritura por defecto, que finalmente corrige todos los
problemas de rendimiento con estas tres variables y hace que su uso sea seguro en cualquier lugar.

Los módulos "Devel :: NYTProf" y "Devel :: FindAmpersand" pueden ayudarlo a encontrar usos de estos
variables de coincidencia problemáticas en su código.

$<dígitos> ($ 1, $ 2, ...)
Contiene el subpatrón del conjunto correspondiente de captura de paréntesis de
la última coincidencia de patrones exitosa, sin contar los patrones coincidentes en bloques anidados
que ya se han salido.

Estas variables son de solo lectura y de ámbito dinámico.

Mnemónico: como \ dígitos.

$ PARTIDO
$ & La cadena que coincide con la última coincidencia de patrón exitosa (sin contar las coincidencias
oculto dentro de un BLOQUE o "eval ()" encerrado por el BLOQUE actual).

Consulte "Problemas de rendimiento" más arriba para conocer las graves implicaciones de rendimiento del uso
esta variable (incluso una vez) en su código.

Esta variable es de solo lectura y de ámbito dinámico.

Mnemotécnico: como "&" en algunos editores.

$ {^ COINCIDIR}
Esto es similar a $ & ($ MATCH) excepto que no incurre en el rendimiento
pena asociada con esa variable.

Consulte "Problemas de rendimiento" más arriba.

En Perl v5.18 y anteriores, solo se garantiza que devolverá un valor definido cuando
el patrón fue compilado o ejecutado con el modificador "/ p". En Perl v5.20, el
El modificador "/ p" no hace nada, por lo que "$ {^ MATCH}" hace lo mismo que $ MATCH.

Esta variable se agregó en Perl v5.10.0.

Esta variable es de solo lectura y de ámbito dinámico.

$ PREMATCH
$ `La cadena que precede a lo que coincidió con la última coincidencia de patrón exitosa,
sin contar las coincidencias ocultas dentro de un BLOQUE o "eval" encerrado por el actual
CUADRA.

Consulte "Problemas de rendimiento" más arriba para conocer las graves implicaciones de rendimiento del uso
esta variable (incluso una vez) en su código.

Esta variable es de solo lectura y de ámbito dinámico.

Mnemónico: "` "a menudo precede a una cadena entre comillas.

$ {^ PREMATCH}
Esto es similar a "$` "($ PREMATCH) excepto que no incurre en el rendimiento
pena asociada con esa variable.

Consulte "Problemas de rendimiento" más arriba.

En Perl v5.18 y anteriores, solo se garantiza que devolverá un valor definido cuando
el patrón fue compilado o ejecutado con el modificador "/ p". En Perl v5.20, el
El modificador "/ p" no hace nada, por lo que "$ {^ PREMATCH}" hace lo mismo que $ PREMATCH.

Esta variable se agregó en Perl v5.10.0.

Esta variable es de solo lectura y de ámbito dinámico.

$ POSTMATCH
$ 'La cadena que sigue a lo que coincidió con la última coincidencia de patrón exitosa
(sin contar las coincidencias ocultas dentro de un BLOQUE o "eval ()" encerrado por el
BLOQUE actual). Ejemplo:

local $ _ = 'abcdefghi';
/ def /;
imprimir "$`: $ &: $ '\ n "; # imprime abc: def: ghi

Consulte "Problemas de rendimiento" más arriba para conocer las graves implicaciones de rendimiento del uso
esta variable (incluso una vez) en su código.

Esta variable es de solo lectura y de ámbito dinámico.

Mnemónico: "'" a menudo sigue una cadena entre comillas.

$ {^ POSTMATCH}
Esto es similar a "$ '" ($ POSTMATCH) excepto que no incurre en el rendimiento
pena asociada con esa variable.

Consulte "Problemas de rendimiento" más arriba.

En Perl v5.18 y anteriores, solo se garantiza que devolverá un valor definido cuando
el patrón fue compilado o ejecutado con el modificador "/ p". En Perl v5.20, el
El modificador "/ p" no hace nada, por lo que "$ {^ POSTMATCH}" hace lo mismo que $ POSTMATCH.

Esta variable se agregó en Perl v5.10.0.

Esta variable es de solo lectura y de ámbito dinámico.

$ LAST_PAREN_MATCH
$ + El texto que coincide con el último corchete del último patrón de búsqueda exitoso. Esta
es útil si no sabe cuál de un conjunto de patrones alternativos coincidió.
Por ejemplo:

/ Versión: (. *) | Revisión: (. *) / && ($ rev = $ +);

Esta variable es de solo lectura y de ámbito dinámico.

Mnemotécnico: sea positivo y con visión de futuro.

$ LAST_SUBMATCH_RESULT
$ ^ N El texto que coincide con el grupo usado que se cerró más recientemente (es decir, el grupo con el
paréntesis de cierre más a la derecha) del último patrón de búsqueda exitoso.

Esto se usa principalmente dentro de los bloques "(? {...})" para examinar texto recientemente
emparejado. Por ejemplo, para capturar efectivamente texto en una variable (además de
$ 1, $ 2, etc.), reemplace "(...)" con

(?: (...) (? {$ var = $ ^ N}))

Al configurar y luego usar $ var de esta manera, no tendrá que preocuparse por
exactamente qué paréntesis numerados son.

Esta variable se agregó en Perl v5.8.0.

Mnemónico: el (posiblemente) paréntesis anidado que se cerró más recientemente.

@LAST_MATCH_END
@ + Esta matriz contiene las compensaciones de los extremos de las últimas subcoincidencias exitosas en el
Ámbito dinámico actualmente activo. $ + [0] es el desplazamiento en la cadena del final de
todo el partido. Este es el mismo valor que devuelve la función "pos" cuando
invocó la variable con la que se comparó. El nel elemento de esta matriz
sostiene el desplazamiento de la nth subcoincidencia, por lo que $ + [1] es el desplazamiento más allá de donde termina $ 1,
$ + [2] el desplazamiento pasado donde termina $ 2, y así sucesivamente. Puede usar $ # + para determinar cómo
muchos subgrupos estaban en el último partido exitoso. Vea los ejemplos dados para
"@-" variable.

Esta variable se agregó en Perl v5.6.0.

% LAST_PAREN_MATCH
% + Similar a "@ +", el hash "% +" permite el acceso a los búferes de captura nombrados, en caso de que
existen, en la última coincidencia exitosa en el ámbito dinámico actualmente activo.

Por ejemplo, $ + {foo} es equivalente a $ 1 después de la siguiente coincidencia:

'foo' = ~ / (? foo) /;

Las claves del hash "% +" enumeran solo los nombres de los búferes que han capturado (y
que por tanto están asociados a valores definidos).

El comportamiento subyacente de "% +" lo proporciona Tie :: Hash :: NamedCapture
módulo.

Nota: "% -" y "% +" son vistas vinculadas en un hash interno común asociado con el
última expresión regular exitosa. Por lo tanto, mezclar el acceso iterativo a ellos a través de
"cada uno" puede tener resultados impredecibles. Del mismo modo, si la última coincidencia exitosa
cambios, entonces los resultados pueden ser sorprendentes.

Esta variable se agregó en Perl v5.10.0.

Esta variable es de solo lectura y de ámbito dinámico.

@LAST_MATCH_START
@ - "$ - [0]" es el desplazamiento del inicio de la última coincidencia exitosa. PSn"]" es el
desplazamiento del inicio de la subcadena coincidente con n-th subpatrón, o undef si el
el subpatrón no coincidía.

Por lo tanto, después de una coincidencia con $ _, $ & coincide con "substr $ _, $ - [0], $ + [0] -
$ - [0] ". Del mismo modo, $n coincide con "substr $ _, $ - [n], $ + [n] - $ - [n]" si "$ - [n]"
está definido y $ + coincide con "substr $ _, $ - [$ # -], $ + [$ # -] - $ - [$ # -]". Una
puede usar "$ # -" para encontrar el último subgrupo coincidente en la última coincidencia exitosa.
Contraste con $ # +, el número de subgrupos en la expresión regular. Comparar
con "@ +".

Esta matriz contiene las compensaciones de los inicios de las últimas subpartidas exitosas.
en el ámbito dinámico actualmente activo. "$ - [0]" es el desplazamiento en la cadena de
el comienzo de todo el partido. El nEl elemento de esta matriz contiene el desplazamiento
de las nth subcoincidencia, por lo que "$ - [1]" es el desplazamiento donde comienza $ 1, "$ - [2]" el desplazamiento
donde comienza $ 2, y así sucesivamente.

Después de una coincidencia con alguna variable $ var:

"$` "es lo mismo que" substr ($ var, 0, $ - [0]) "
$ & es lo mismo que "substr ($ var, $ - [0], $ + [0] - $ - [0])"
"$ '" es lo mismo que "substr ($ var, $ + [0])"
$ 1 es lo mismo que "substr ($ var, $ - [1], $ + [1] - $ - [1])"
$ 2 es lo mismo que "substr ($ var, $ - [2], $ + [2] - $ - [2])"
$ 3 es lo mismo que "substr ($ var, $ - [3], $ + [3] - $ - [3])"

Esta variable se agregó en Perl v5.6.0.

% LAST_MATCH_START
%: Similar a "% +", esta variable permite el acceso a los grupos de captura nombrados en el
última coincidencia exitosa en el alcance dinámico actualmente activo. A cada captura
nombre de grupo que se encuentra en la expresión regular, asocia una referencia a una matriz
que contiene la lista de valores capturados por todos los búferes con ese nombre (debería haber
ser varios), en el orden en que aparecen.

He aquí un ejemplo:

si ('1234' = ~ / (? 1) (? 2) (? 3) (? 4) /) {
foreach my $ bufname (ordenar claves% -) {
my $ ary = $ - {$ bufname};
foreach my $ idx (0 .. $ # $ ary) {
imprimir "\ $ - {$ bufname} [$ idx]:",
(definido ($ ary -> [$ idx])
? "'$ ary -> [$ idx]'"
: "indef"),
"\norte";
}
}
}

imprimiría:

$ - {A} [0]: '1'
$ - {A} [1]: '3'
$ - {B} [0]: '2'
$ - {B} [1]: '4'

Las claves del hash "% -" corresponden a todos los nombres de búfer que se encuentran en el
expresión.

El comportamiento de "% -" se implementa a través del módulo Tie :: Hash :: NamedCapture.

Nota: "% -" y "% +" son vistas vinculadas en un hash interno común asociado con el
última expresión regular exitosa. Por lo tanto, mezclar el acceso iterativo a ellos a través de
"cada uno" puede tener resultados impredecibles. Del mismo modo, si la última coincidencia exitosa
cambios, entonces los resultados pueden ser sorprendentes.

Esta variable se agregó en Perl v5.10.0.

Esta variable es de solo lectura y de ámbito dinámico.

$ LAST_REGEXP_CODE_RESULT
$ ^ R El resultado de la evaluación de la última expresión regular "(? {Code})" exitosa
afirmación (ver perlre). Puede escribirse a.

Esta variable se agregó en Perl 5.005.

$ {^ RE_DEBUG_FLAGS}
El valor actual de los indicadores de depuración de expresiones regulares. Establecer en 0 para ninguna salida de depuración incluso
cuando se carga el módulo "re 'debug'". Consulte re para obtener más detalles.

Esta variable se agregó en Perl v5.10.0.

$ {^ RE_TRIE_MAXBUF}
Controla cómo se aplican ciertas optimizaciones de expresiones regulares y cuánta memoria
utilizar. Este valor por defecto es 65536 que corresponde a un 512kB temporal
cache. Establezca esto en un valor más alto para intercambiar memoria por velocidad al hacer coincidir grandes
alternancias. Ajústelo a un valor más bajo si desea que las optimizaciones sean como
conservador de la memoria como sea posible pero aún ocurre, y configúrelo en un valor negativo
para evitar la optimización y conservar la mayor cantidad de memoria. En situaciones normales
esta variable no debería interesarle.

Esta variable se agregó en Perl v5.10.0.

Variables relacionado a manijas de archivo
Las variables que dependen del identificador de archivo seleccionado actualmente se pueden configurar llamando a un
método de objeto apropiado en el objeto "IO :: Handle", aunque esto es menos eficiente que
utilizando las variables integradas habituales. (Las líneas de resumen a continuación para esto contienen la palabra
MANIJA.) Primero debes decir

use IO :: Handle;

después de lo cual puede usar

método HANDLE EXPR

o más seguro,

MANIJA-> método (EXPR)

Cada método devuelve el valor anterior del atributo "IO :: Handle". Cada uno de los métodos toma un
EXPR opcional, que, si se proporciona, especifica el nuevo valor para el atributo "IO :: Handle"
en cuestión. Si no se proporciona, la mayoría de los métodos no hacen nada con el valor actual, excepto para
"autoflush ()", que asumirá un 1 para usted, solo para ser diferente.

Debido a que cargar en la clase "IO :: Handle" es una operación costosa, debe aprender cómo
para utilizar las variables integradas habituales.

Algunas de estas variables se consideran "de solo lectura". Esto significa que si intenta asignar
a esta variable, ya sea directa o indirectamente a través de una referencia, generará una ejecución
excepción de tiempo.

Debe tener mucho cuidado al modificar los valores predeterminados de la mayoría de las variables especiales
descrito en este documento. En la mayoría de los casos, desea localizar estas variables antes
cambiarlos, ya que si no lo hace, el cambio puede afectar a otros módulos que dependen de la
valores predeterminados de las variables especiales que ha cambiado. Este es uno de los correctos
formas de leer todo el archivo a la vez:

abre mi $ fh, "<", "foo" o muere $ !;
$ local /; # habilitar el modo de sorber localizado
mi $ contenido = <$ fh>;
cerrar $ fh;

Pero el siguiente código es bastante malo:

abre mi $ fh, "<", "foo" o muere $ !;
undef $ /; # habilitar el modo sorber
mi $ contenido = <$ fh>;
cerrar $ fh;

desde algún otro módulo, es posible que desee leer datos de algún archivo en el "modo de línea" predeterminado,
así que si el código que acabamos de presentar se ha ejecutado, el valor global de $ / ahora es
cambiado para cualquier otro código que se ejecute dentro del mismo intérprete de Perl.

Por lo general, cuando se localiza una variable, debe asegurarse de que este cambio afecte al
alcance más corto posible. Por lo tanto, a menos que ya esté dentro de un bloque "{}" corto,
debería crear uno usted mismo. Por ejemplo:

mi $ contenido = '';
abre mi $ fh, "<", "foo" o muere $ !;
{
$ local /;
$ contenido = <$ fh>;
}
cerrar $ fh;

Aquí hay un ejemplo de cómo su propio código puede fallar:

para (1..3) {
$ \ = "\ r \ n";
nasty_break ();
imprimir "$ _";
}

sub desagradable_break {
$ \ = "\ f";
# haz algo con $ _
}

Probablemente espere que este código imprima el equivalente de

"1 \ r \ n2 \ r \ n3 \ r \ n"

pero en cambio obtienes:

"1 \ f2 \ f3 \ f"

¿Por qué? Porque "nasty_break ()" modifica "$ \" sin localizarlo primero. El valor que estableciste
en "nasty_break ()" todavía está allí cuando regrese. La solución es agregar "local ()" para que el
el valor no se filtra de "nasty_break ()":

local $ \ = "\ f";

Es fácil notar el problema en un ejemplo tan corto, pero en un código más complicado
está buscando problemas si no localiza los cambios en las variables especiales.

$ ARGV Contiene el nombre del archivo actual cuando se lee desde "<>".

@ARGV La matriz @ARGV contiene los argumentos de la línea de comandos previstos para el script.
$ # ARGV es generalmente el número de argumentos menos uno, porque $ ARGV [0] es el
primer argumento, no el nombre del comando del programa. Ver "$ 0" para el comando
nombre.

ARGV El identificador de archivo especial que itera sobre los nombres de archivo de la línea de comandos en @ARGV.
Por lo general, se escribe como identificador de archivo nulo en el operador de ángulo "<>". Tenga en cuenta que
actualmente "ARGV" solo tiene su efecto mágico dentro del operador "<>"; en otra parte
es simplemente un identificador de archivo simple correspondiente al último archivo abierto por "<>". En
en particular, pasando "\ * ARGV" como parámetro a una función que espera un
filehandle puede no hacer que su función lea automáticamente el contenido de todos
los archivos en @ARGV.

ARGVOUT El identificador de archivo especial que apunta al archivo de salida actualmente abierto al hacer
procesamiento de edición en el lugar con -i. Útil cuando tienes que hacer muchas inserciones
y no quiero seguir modificando $ _. Ver perlrun para el -i switch.

IO :: Handle-> output_field_separator (EXPR)
$ OUTPUT_FIELD_SEPARATOR
$ OFS
$, El separador de campo de salida para el operador de impresión. Si se define, este valor es
impreso entre cada uno de los argumentos de print. El valor predeterminado es "indef".

No puede llamar a "output_field_separator ()" en un identificador, solo como un método estático.
Consulte IO :: Handle.

Mnemotécnico: lo que se imprime cuando hay un "," en su declaración impresa.

MANIJA-> input_line_number (EXPR)
$ INPUT_LINE_NUMBER
$ NR
PS Número de línea actual del último identificador de archivo al que se accedió.

Cada identificador de archivo en Perl cuenta el número de líneas que se leyeron.
(Dependiendo del valor de $ /, la idea de Perl de lo que constituye una línea puede no
coincidir con el tuyo). Cuando se lee una línea de un identificador de archivo (a través de "readline ()" o "<>"),
o cuando se llama a "tell ()" o "seek ()", $. se convierte en un alias de la línea
contador para ese identificador de archivo.

Puede ajustar el contador asignando $., Pero esto en realidad no moverá el
buscar puntero. Localizando $. will no localizar los manejador de archivos línea contar.
En su lugar, localizará la noción de Perl de qué filehandle $. es actualmente
alias a.

PS se restablece cuando se cierra el identificador de archivo, pero no cuando un identificador de archivo abierto es
reabierto sin un "close ()" intermedio. Para obtener más detalles, consulte "Operadores de E / S"
en perlop. Debido a que "<>" nunca hace un cierre explícito, los números de línea aumentan
en archivos "ARGV" (pero vea ejemplos en "eof" en perlfunc).

También puede utilizar "HANDLE-> input_line_number (EXPR)" para acceder al contador de línea para
un identificador de archivo determinado sin tener que preocuparse por el identificador al que accedió por última vez.

Mnemónico: muchos programas usan "." para referirse al número de línea actual.

IO :: Handle-> input_record_separator (EXPR)
$ INPUT_RECORD_SEPARATOR
$ RS
$ / El separador de registros de entrada, nueva línea por defecto. Esto influye en la idea de Perl de
lo que es una "línea". Funciona como awkla variable RS, incluido el tratamiento de las líneas vacías como
un terminador si se establece en la cadena nula (una línea vacía no puede contener espacios ni
pestañas). Puede configurarlo en una cadena de varios caracteres para que coincida con un
terminator, o "undef" para leer hasta el final del archivo. Configurándolo en "\ n \ n"
significa algo ligeramente diferente a la configuración en "", si el archivo contiene
líneas vacías consecutivas. Si se establece en "", se tratarán dos o más vacíos consecutivos
líneas como una sola línea vacía. Establecer en "\ n \ n" asumirá ciegamente que el próximo
El carácter de entrada pertenece al siguiente párrafo, incluso si es una nueva línea.

$ local /; # habilitar el modo "sorber"
local $ _ = ; # archivo completo ahora aquí
s / \ n [\ t] + / / g;

Recuerde: el valor de $ / es una cadena, no una expresión regular. awk tiene que ser mejor para
algo. :-)

Establecer $ / en una referencia a un número entero, escalar que contenga un número entero o escalar
que es convertible a un número entero intentará leer registros en lugar de líneas,
siendo el tamaño máximo de registro el número entero de caracteres al que se hace referencia.
Así que esto:

local $ / = \ 32768; # o \ "32768", o \ $ var_containing_32768
abre mi $ fh, "<", $ myfile o muere $ !;
local $ _ = <$ fh>;

leerá un registro de no más de 32768 caracteres de $ fh. Si no estás
lectura de un archivo orientado a registros (o su sistema operativo no tiene
archivos), es probable que obtenga una gran cantidad de datos con cada lectura. Si un récord
es mayor que el tamaño de registro que ha establecido, obtendrá el registro en pedazos.
Intentar establecer el tamaño del registro en cero o menos está obsoleto y hará que $ /
tienen el valor de "undef", lo que provocará la lectura en el (resto del) total
archivo.

A partir de 5.19.9, la configuración de $ / en cualquier otra forma de referencia arrojará un error fatal
excepción. Esto es en preparación para admitir nuevas formas de establecer $ / en el futuro.

Solo en VMS, las lecturas de registros omiten las capas PerlIO y cualquier almacenamiento en búfer asociado, por lo que
no debe mezclar lecturas grabadas y no grabadas en el mismo identificador de archivo. Modo de grabación
se mezcla con el modo de línea solo cuando se utiliza la misma capa de almacenamiento en búfer para ambos modos.

No puede llamar a "input_record_separator ()" en un identificador, solo como un método estático.
Consulte IO :: Handle.

Ver también "Newlines" en perlport. Consulte también "$.".

Mnemónico: / delimita los límites de las líneas al citar poesía.

IO :: Handle-> output_record_separator (EXPR)
$ OUTPUT_RECORD_SEPARATOR
$ ORS
$ \ El separador de registros de salida para el operador de impresión. Si se define, este valor es
impreso después del último de los argumentos de print. El valor predeterminado es "indef".

No puede llamar a "output_record_separator ()" en un identificador, solo como un método estático.
Consulte IO :: Handle.

Mnemónico: establece "$ \" en lugar de agregar "\ n" al final de la impresión. Además, es
como $ /, pero es lo que "recupera" de Perl.

MANIJA-> autoflush (EXPR)
$ OUTPUT_AUTOFLUSH
$ | Si se establece en un valor distinto de cero, fuerza un enjuague inmediatamente y después de cada escritura o impresión en el
canal de salida seleccionado actualmente. El valor predeterminado es 0 (independientemente de si el
el canal está realmente protegido por el sistema o no; $ | te dice solo si has
le pidió a Perl explícitamente que se descargara después de cada escritura). STDOUT normalmente será de línea
almacenado en búfer si la salida es al terminal y bloqueado en búfer en caso contrario. Configurando esto
La variable es útil principalmente cuando se envía a una tubería o enchufe, como
cuando está ejecutando un programa Perl bajo rsh y quiero ver la salida como es
sucediendo. Esto no tiene ningún efecto sobre el almacenamiento en búfer de entrada. Consulte "getc" en perlfunc para
ese. Consulte "seleccionar" en perlfunc sobre cómo seleccionar el canal de salida. Ver también
IO :: Mango.

Mnemotécnico: cuando quieres que tus tuberías estén muy calientes.

$ {^ LAST_FH}
Esta variable de solo lectura contiene una referencia al identificador de archivo de última lectura. Esto es
establecido por " "," readline "," tell "," eof "y" seek ". Este es el mismo identificador
ese $. y "tell" y "eof" sin uso de argumentos. También es el mango utilizado.
cuando Perl agrega ", línea 1 "a un mensaje de error o advertencia.

Esta variable se agregó en Perl v5.18.0.

Variables relacionado a formatos

Las variables especiales para formatos son un subconjunto de las de identificadores de archivos. Ver perlform para
más información sobre los formatos de Perl.

$ ACUMULADOR
$ ^ A El valor actual del acumulador "write ()" para las líneas "format ()". Un formato
contiene llamadas "formline ()" que ponen su resultado en $ ^ A. Después de llamar a su
format, "write ()" imprime el contenido de $ ^ A y lo vacía. Entonces nunca realmente
vea el contenido de $ ^ A a menos que llame a "formline ()" usted mismo y luego lo mire.
Ver perlform y "formline IMAGEN, LISTA" en perlfunc.

IO :: Handle-> format_formfeed (EXPR)
$ FORMAT_FORMFEED
$ ^ L Qué formatea la salida como un avance de formulario. El valor predeterminado es "\ f".

No puede llamar a "format_formfeed ()" en un identificador, solo como un método estático. Ver
IO :: Mango.

HANDLE-> format_page_number (EXPR)
$ FORMAT_PAGE_NUMBER
$% El número de página actual del canal de salida seleccionado actualmente.

Mnemónico: "%" es el número de página en nroff.

MANIJA-> format_lines_left (EXPR)
$ FORMAT_LINES_LEFT
$ - El número de líneas que quedan en la página del canal de salida seleccionado actualmente.

Mnemónico: lines_on_page - lines_printed.

IO :: Handle-> format_line_break_characters EXPR
$ FORMAT_LINE_BREAK_CHARACTERS
$: El conjunto actual de caracteres después del cual se puede romper una cadena para completar
campos de continuación (que comienzan con "^") en un formato. El valor predeterminado es "\ n-", para
romper en un espacio, una nueva línea o un guión.

No puede llamar a "format_line_break_characters ()" en un identificador, solo como un
método. Consulte IO :: Handle.

Mnemotécnico: un "dos puntos" en poesía es parte de una línea.

HANDLE-> format_lines_per_page (EXPR)
$ FORMAT_LINES_PER_PAGE
$ = La longitud de la página actual (líneas imprimibles) de la salida seleccionada actualmente
canal. El valor predeterminado es 60.

Mnemónico: = tiene líneas horizontales.

HANDLE-> format_top_name (EXPR)
$ FORMAT_TOP_NAME
$ ^ El nombre del formato de inicio de página actual para la salida actualmente seleccionada
canal. El valor predeterminado es el nombre del identificador de archivo con "_TOP" agregado. Para
Por ejemplo, el nombre superior del formato predeterminado para el identificador de archivo "STDOUT" es "STDOUT_TOP".

Mnemotécnico: apunta a la parte superior de la página.

MANIJA-> nombre_formato (EXPR)
$ FORMAT_NAME
$ ~ El nombre del formato de informe actual para el canal de salida seleccionado actualmente.
El nombre de formato predeterminado es el mismo que el nombre del identificador de archivo. Por ejemplo, el
El nombre de formato predeterminado para el identificador de archivo "STDOUT" es simplemente "STDOUT".

Mnemónico: hermano de $ ^.

Error Variables
Las variables $ @, $ !, $ ^ E y $? contener información sobre diferentes tipos de error
condiciones que pueden aparecer durante la ejecución de un programa Perl. Las variables se muestran
ordenado por la "distancia" entre el subsistema que informó el error y el Perl
proceso. Corresponden a errores detectados por el intérprete de Perl, biblioteca C, funcionamiento
sistema, o un programa externo, respectivamente.

Para ilustrar las diferencias entre estas variables, considere el siguiente Perl
expresión, que usa una cadena entre comillas simples. Después de la ejecución de esta declaración, perl
puede haber establecido las cuatro variables de error especiales:

eval q {
abre mi $ pipe, "/ cdrom / install |" o morir $ !;
my @res = <$ pipe>;
cierra $ pipe o muere "bad pipe: $ ?, $!";
};

Cuando perl ejecuta la expresión "eval ()", traduce "open ()", " ", y
"cerrar" llamadas en la biblioteca de tiempo de ejecución de C y de allí al kernel del sistema operativo. perl
establece $! al "errno" de la biblioteca C si una de estas llamadas falla.

$ @ se establece si la cadena para ser "eval" -ed no se compiló (esto puede suceder si "open" o
"close" se importaron con prototipos incorrectos), o si el código Perl se ejecutó durante la evaluación
"murió. En estos casos, el valor de $ @ es el error de compilación o el argumento para "morir"
(que interpolará $! y $?). (Ver también Fatal, sin embargo).

En algunos sistemas operativos, $ ^ E puede contener un indicador de error más detallado, como en
en este caso, "bandeja de CDROM no cerrada". Sistemas que no admiten mensajes de error extendidos
deje $ ^ E igual que $ !.

Finalmente, $? puede establecerse en un valor distinto de 0 si el programa externo / cdrom / install falla. El
Los ocho bits superiores reflejan condiciones de error específicas encontradas por el programa (el
valor "exit ()" del programa). Los ocho bits inferiores reflejan el modo de falla, como la señal
información de muerte y volcado de núcleo. Ver esperar(2) para obtener más detalles. En contraste con $! y $ ^ E,
que se establecen solo si se detecta una condición de error, la variable $? se establece en cada "espera"
o pipe "close", sobrescribiendo el valor anterior. Esto es más como $ @, que en cada "eval ()"
siempre se establece en caso de error y se borra en caso de éxito.

Para obtener más detalles, consulte las descripciones individuales en $ @, $ !, $ ^ E y $ ?.

$ {^ CHILD_ERROR_NATIVE}
El estado nativo devuelto por el último cierre de tubería, comando de tilde invertido ("` `"),
llamada exitosa a "wait ()" o "waitpid ()", o desde el operador "system ()". Sobre
En sistemas tipo POSIX, este valor se puede decodificar con WIFEXITED, WEXITSTATUS,
Funciones WIFSIGNALED, WTERMSIG, WIFSTOPPED, WSTOPSIG y WIFCONTINUED proporcionadas por
el módulo POSIX.

En VMS, esto refleja el estado real de salida de VMS; es decir, es lo mismo que $? Cuándo
el pragma "use vmsish 'status'" está en vigor.

Esta variable se agregó en Perl v5.10.0.

$ EXTENDED_OS_ERROR
$ ^ E Información de error específica del sistema operativo actual. Por el momento, este
difiere de $! solo bajo VMS, OS / 2 y Win32 (y para MacPerl). En todos los demás
plataformas, $ ^ E siempre es lo mismo que $ !.

En VMS, $ ^ E proporciona el valor de estado de VMS del último error del sistema. Esto es
información más específica sobre el último error del sistema que la proporcionada por $ !.
Esto es particularmente importante cuando $! se establece en EVMSERR.

En OS / 2, $ ^ E se establece en el código de error de la última llamada a la API de OS / 2 a través de
CRT, o directamente de perl.

En Win32, $ ^ E siempre devuelve la última información de error reportada por Win32
llamar a "GetLastError ()" que describe el último error desde dentro de la API de Win32.
La mayoría de los códigos específicos de Win32 informarán errores a través de $ ^ E. ANSI C y llamadas similares a Unix
establezca "errno" y, por lo tanto, la mayoría de los códigos Perl portátiles informarán errores a través de $ !.

Advertencias mencionadas en la descripción de $! generalmente se aplican a $ ^ E, también.

Esta variable se agregó en Perl 5.003.

Mnemotécnico: explicación adicional del error.

$ EXCEPTIONS_BEING_CAUGHT
$ ^ S Estado actual del intérprete.

$ ^ S Estado
--------- -------------------------------------
undef Módulo de análisis, evaluación o programa principal
verdadero (1) Ejecutando una evaluación
falso (0) De lo contrario

El primer estado puede ocurrir en los controladores $ SIG {__ DIE__} y $ SIG {__ WARN__}.

El nombre en inglés $ EXCEPTIONS_BEING_CAUGHT es un poco engañoso, porque el
El valor "undef" no indica si se están detectando excepciones, ya que
La compilación del programa principal no detecta excepciones.

Esta variable se agregó en Perl 5.004.

$ ADVERTENCIA
$ ^ W El valor actual del interruptor de advertencia, inicialmente verdadero si -w fue usado, falso
de lo contrario, pero directamente modificable.

Consulte también las advertencias.

Mnemónico: relacionado con el -w switch.

$ {^ WARNING_BITS}
El conjunto actual de comprobaciones de advertencia habilitadas por el pragma "usar advertencias". Tiene
el mismo alcance que las variables $ ^ H y "% ^ H". Se consideran los valores exactos
interno al pragma de advertencias y puede cambiar entre versiones de Perl.

Esta variable se agregó en Perl v5.6.0.

$ OS_ERROR
$ ERRNO
PS Cuando se hace referencia, $! recupera el valor actual de la variable entera C "errno".
Si $! se le asigna un valor numérico, ese valor se almacena en "errno". Cuándo
referenciado como una cadena, $! produce la cadena de error del sistema correspondiente a
"errno".

Muchas llamadas al sistema o biblioteca establecen "errno" si fallan, para indicar la causa de
falla. Por lo general lo hacen no establezca "errno" en cero si tiene éxito. Esto significa
"errno", por lo tanto $ !, solo tiene sentido inmediatamente después de el fracaso:

if (abrir mi $ fh, "<", $ nombre de archivo) {
# ¡Aquí $! no tiene sentido.
...
}
else {
# ¡SOLO aquí está $! significativo.
...
# ¡Ya aquí $! podría no tener sentido.
}
# Dado que aquí podríamos tener éxito o fracaso,
PS no tiene sentido.

Aquí, sin sentido significa que $! puede no estar relacionado con el resultado de "open ()"
operador. Asignación a $! es igualmente efímero. Se puede utilizar de inmediato.
antes de invocar el operador "die ()", para establecer el valor de salida o para inspeccionar el
cadena de error del sistema correspondiente al error n, o para restaurar $! a un significativo
estado.

Mnemónico: ¿Qué acaba de explotar?

% OS_ERROR
% ERRNO
%! Cada elemento de "%!" tiene un valor verdadero solo si $! se establece en ese valor. Para
ejemplo, $! {ENOENT} es verdadero si y solo si el valor actual de $! es "ENOENT";
es decir, si el error más reciente fue "No existe tal archivo o directorio" (o su moral
equivalente: no todos los sistemas operativos dan ese error exacto, y ciertamente no todos
idiomas). El valor verdadero específico no está garantizado, pero en el pasado ha
generalmente ha sido el valor numérico de $ !. Para comprobar si una clave en particular es
significativo en su sistema, use "existe $! {the_key}"; para obtener una lista de claves legales, utilice
"teclas %!". Consulte Errno para obtener más información y también consulte "$!".

Esta variable se agregó en Perl 5.005.

$ CHILD_ERROR
PS El estado devuelto por el último cierre de tubería, comando de tilde invertido ("` `"), exitoso
llamar a "wait ()" o "waitpid ()", o desde el operador "system ()". Esto es simplemente
la palabra de estado de 16 bits devuelta por la llamada al sistema tradicional "wait ()" de Unix (o
lo demás está hecho para parecerse a él). Por tanto, el valor de salida del subproceso es
realmente ("$? >> 8"), y "$? & 127" da qué señal, si la hay, el proceso murió
from y "$? & 128" informa si hubo un volcado de memoria.

Además, si la variable "h_errno" es compatible con C, se devuelve su valor.
a través de $? si falla alguna función "gethost * ()".

Si ha instalado un controlador de señales para "SIGCHLD", ¿el valor de $? por lo general
estar equivocado fuera de ese manejador.

Dentro de una subrutina "END" $? contiene el valor que se le va a dar a
"Salida()". Puede modificar $? en una subrutina "FIN" para cambiar el estado de salida de
su programa. Por ejemplo:

FINAL {
PS = 1 si $? == 255; # morir lo haría 255
}

Bajo VMS, el pragma "use vmsish 'status'" hace $? reflejar la salida real de VMS
estado, en lugar de la emulación predeterminada del estado POSIX; ver "$?" en perlvms para
Detalles.

Mnemónico: similar a sh y ksh.

$ EVAL_ERROR
$ @ El mensaje de error de sintaxis de Perl del último operador "eval ()". Si $ @ es el nulo
cadena, el último "eval ()" analizado y ejecutado correctamente (aunque las operaciones
que invocó puede haber fallado de la manera normal).

Los mensajes de advertencia no se recopilan en esta variable. Sin embargo, puede configurar un
rutina para procesar advertencias configurando $ SIG {__ WARN__} como se describe en "% SIG".

Mnemónico: ¿Dónde estaba el error de sintaxis "en"?

Variables relacionado a los Interprete estado
Estas variables proporcionan información sobre el estado actual del intérprete.

$ COMPILACIÓN
$ ^ C El valor actual de la bandera asociada con el -c cambiar. Principalmente de uso con
-MO = ... para permitir que el código altere su comportamiento cuando se compila, como para
ejemplo a "AUTOLOAD" en tiempo de compilación en lugar de la carga diferida normal.
Configurar "$ ^ C = 1" es similar a llamar a "B :: minus_c".

Esta variable se agregó en Perl v5.6.0.

$ DEPURACIÓN
$ ^ D El valor actual de los indicadores de depuración. Puede leerse o configurarse. Como su comando
línea equivalente, puede utilizar valores numéricos o simbólicos, por ejemplo, "$ ^ D = 10" o "$ ^ D =
"S t"".

Mnemónico: valor de -D switch.

$ {^ CODIFICACIÓN}
¡¡¡OBSOLETO!!!

El objeto referencia al objeto "Codificar" que se utiliza para convertir la fuente
código a Unicode. Gracias a esta variable, su script Perl no tiene que ser
escrito en UTF-8. El valor predeterminado es "indef".

Establecer esta variable en cualquier otro valor que no sea "undef" está obsoleto debido a
defectos fundamentales en su diseño e implementación. Está previsto eliminarlo.
de una futura versión de Perl. Su propósito era permitir que sus scripts de Perl no ASCII
no tener que estar escrito en UTF-8; esto fue útil antes de los editores que trabajaron en
El texto codificado en UTF-8 era común, pero eso fue hace mucho tiempo. Causa problemas, tales
que afecta el funcionamiento de otros módulos que no lo esperan, provocando
caos general. Su uso puede conducir a segfaults.

Si necesita algo como esta funcionalidad, debe usar el pragma de codificación,
que también está desaprobado, pero tiene menos efectos secundarios desagradables.

Si vienes aquí porque tu código está siendo afectado negativamente por
el uso de esta variable por parte de alguien, generalmente puede solucionarlo haciendo esto:

local $ {^ CODIFICACIÓN};

cerca del comienzo de las funciones que se rompen. Esto no define el
variable durante el alcance de ejecución de la función de inclusión.

Esta variable se agregó en Perl 5.8.2.

$ {^ GLOBAL_PHASE}
La fase actual del intérprete de perl.

Los valores posibles son:

CONSTRUIR
El "PerlInterpreter *" se está construyendo a través de "perl_construct". Esta
El valor está principalmente ahí para completar y para usar a través de la C subyacente.
variable "PL_phase". Realmente no es posible que el código Perl sea
ejecutado a menos que la construcción del intérprete esté terminada.

INICIO Este es el tiempo de compilación global. Eso incluye, básicamente, cada "BEGIN"
bloque ejecutado directa o indirectamente durante el tiempo de compilación del
programa de alto nivel.

Esta fase no se llama "BEGIN" para evitar confusiones con los bloques "BEGIN",
ya que se ejecutan durante el tiempo de compilación de cualquier unidad de compilación, no
solo el programa de nivel superior. Un nuevo tiempo de compilación localizado ingresado en la ejecución
tiempo, por ejemplo, por construcciones como "eval" use SomeModule "" no son globales
fases del intérprete y, por lo tanto, no se reflejan en "$ {^ GLOBAL_PHASE}".

CHECK Ejecución de cualquier bloque "CHECK".

INIT Similar a "CHECK", pero para bloques "INIT", no para bloques "CHECK".

RUN El tiempo de ejecución principal, es decir, la ejecución de "PL_main_root".

END Ejecución de cualquier bloque "END".

DESTRUIR
Destrucción global.

También tenga en cuenta que no hay ningún valor para los bloques UNITCHECK. Eso es porque esos son
ejecutar para cada unidad de compilación individualmente y, por lo tanto, no es un
fase de intérprete.

No todos los programas tienen que pasar por todas las fases posibles, pero la transición
de una fase a otra solo puede suceder en el orden descrito en el punto anterior
lista.

Un ejemplo de todas las fases que el código Perl puede ver:

COMIENZO {imprimir "tiempo de compilación: $ {^ GLOBAL_PHASE} \ n"}

INIT {print "init-time: $ {^ GLOBAL_PHASE} \ n"}

VERIFICAR {imprimir "hora de verificación: $ {^ GLOBAL_PHASE} \ n"}

{
paquete Imprimir :: Fase;

sub nuevo {
my ($ clase, $ tiempo) = @_;
volver bendiga \ $ tiempo, $ clase;
}

sub DESTRUIR {
my $ self = shift;
imprimir "$$ self: $ {^ GLOBAL_PHASE} \ n";
}
}

imprimir "tiempo de ejecución: $ {^ GLOBAL_PHASE} \ n";

my $ runtime = Print :: Phase-> new (
"las variables léxicas son basura recolectada antes de END"
);

FIN {imprimir "hora de finalización: $ {^ GLOBAL_PHASE} \ n"}

our $ destruct = Print :: Phase-> new (
"las variables del paquete son basura recolectada después de END"
);

Esto se imprimirá

tiempo de compilación: INICIO
tiempo de verificación: VERIFICAR
tiempo de inicio: INIT
tiempo de ejecución: RUN
las variables léxicas son basura recolectada antes de END: RUN
tiempo de finalización: FIN
las variables del paquete son basura recolectada después de END: DESTRUCT

Esta variable se agregó en Perl 5.14.0.

$ ^ H ADVERTENCIA: Esta variable es estrictamente para uso interno. Su disponibilidad,
El comportamiento y los contenidos están sujetos a cambios sin previo aviso.

Esta variable contiene sugerencias en tiempo de compilación para el intérprete de Perl. Al final de
compilación de un BLOQUE el valor de esta variable se restaura al valor cuando
el intérprete comenzó a compilar el BLOQUE.

Cuando perl comienza a analizar cualquier construcción de bloque que proporcione un alcance léxico (p. Ej.,
cuerpo de evaluación, archivo requerido, cuerpo de subrutina, cuerpo de bucle o bloque condicional), el
Se guarda el valor existente de $ ^ H, pero su valor no se modifica. Cuando el
Se completa la compilación del bloque, se recupera el valor guardado. Entre los
puntos donde su valor se guarda y restaura, código que se ejecuta dentro de BEGIN
blocks es libre de cambiar el valor de $ ^ H.

Este comportamiento proporciona la semántica del alcance léxico y se utiliza en, para
ejemplo, el pragma "use estricto".

El contenido debe ser un número entero; diferentes partes se utilizan para diferentes
banderas pragmáticas. He aquí un ejemplo:

sub add_100 {$ ^ H | = 0x100}

subfoo {
EMPEZAR {add_100 ()}
bar-> baz ($ boon);
}

Considere lo que sucede durante la ejecución del bloque BEGIN. En este punto el
El bloque BEGIN ya se ha compilado, pero el cuerpo de "foo ()" aún se está
compilado. Por lo tanto, el nuevo valor de $ ^ H será visible solo mientras el cuerpo de
"foo ()" se está compilando.

Sustitución del bloque "BEGIN {add_100 ()}" por:

COMIENZO {require estricto; estricto-> importar ('vars')}

demuestra cómo se implementa el "uso estricto de 'vars'". Aquí hay una versión condicional
del mismo pragma léxico:

EMPEZAR {
requieren estricto; estricto-> importar ('vars') si $ condición
}

Esta variable se agregó en Perl 5.003.

% ^ H El hash "% ^ H" proporciona la misma semántica de alcance que $ ^ H. Esto lo hace útil
para la implementación de pragmas de ámbito léxico. Ver perlpragma. Todas las entradas
se encadenan cuando se accede en tiempo de ejecución, por lo que solo los valores simples pueden ser
acomodado. Esto significa que no hay punteros a objetos, por ejemplo.

Al colocar elementos en "% ^ H", para evitar conflictos con otros usuarios de
el hash hay una convención sobre qué claves utilizar. Un módulo debe usar
solo las claves que comienzan con el nombre del módulo (el nombre de su paquete principal) y un
"/" personaje. Por ejemplo, un módulo "Foo :: Bar" debe usar claves como
"Foo :: Bar / baz".

Esta variable se agregó en Perl v5.6.0.

$ {^ OPEN}
Una variable interna utilizada por PerlIO. Una cadena en dos partes, separadas por un "\ 0"
byte, la primera parte describe las capas de entrada, la segunda parte describe el
capas de salida.

Esta variable se agregó en Perl v5.8.0.

$ PERLDB
$ ^ P La variable interna para el soporte de depuración. Los significados de los distintos bits son
sujeto a cambios, pero actualmente indique:

0x01 Entrada / salida de subrutina de depuración.

0x02 Depuración línea por línea. Hace que se llame a la subrutina "DB :: DB ()" para cada
declaración ejecutada. También hace que se guarden líneas de código fuente (como 0x400).

0x04 Desactivar optimizaciones.

0x08 Conserve más datos para futuras inspecciones interactivas.

0x10 Conserva información sobre las líneas de origen en las que se define una subrutina.

0x20 Comience con un solo paso.

0x40 Utilice la dirección de subrutina en lugar del nombre al informar.

0x80 Informe "goto & subrutina" también.

0x100 Proporcione nombres de "archivos" informativos para las evaluaciones según el lugar en el que se encontraban
compilado.

0x200 Proporcione nombres informativos a subrutinas anónimas según el lugar
fueron compilados.

0x400 Guarde las líneas del código fuente en "@ {" _ <$ filename "}".

0x800 Al guardar la fuente, incluya evaluaciones que no generen subrutinas.

0x1000
Al guardar la fuente, incluya la fuente que no se compiló.

Algunos bits pueden ser relevantes solo en tiempo de compilación, algunos solo en tiempo de ejecución. Esto es un
nuevo mecanismo y los detalles pueden cambiar. Véase también perldebguts.

$ {^ TAINT}
Refleja si el modo de contaminación está activado o desactivado. 1 para el (el programa se ejecutó con -T), 0
para desactivado, -1 cuando solo están habilitadas las advertencias de contaminación (es decir, con -t or -TU).

Esta variable es de solo lectura.

Esta variable se agregó en Perl v5.8.0.

$ {^ UNICODE}
Refleja ciertas configuraciones Unicode de Perl. Consulte la documentación de perlrun para la "-C"
cambiar para obtener más información sobre los valores posibles.

Esta variable se establece durante el inicio de Perl y, a partir de entonces, es de solo lectura.

Esta variable se agregó en Perl v5.8.2.

$ {^ UTF8CACHE}
Esta variable controla el estado del código interno de almacenamiento en caché de desplazamiento UTF-8. 1 para
on (predeterminado), 0 para desactivado, -1 para depurar el código de almacenamiento en caché comprobando todos sus
resultados frente a exploraciones lineales, y entrar en pánico ante cualquier discrepancia.

Esta variable se agregó en Perl v5.8.9. Está sujeto a cambios o eliminación.
sin previo aviso, pero se utiliza actualmente para evitar volver a calcular los límites de
Caracteres codificados en UTF-8 de varios bytes.

$ {^ UTF8LOCALE}
Esta variable indica si perl detectó una configuración regional UTF-8 al inicio.
Esta información es utilizada por perl cuando está en modo Adjust-utf8ness-to-locale (como
cuando se ejecuta con el modificador de línea de comandos "-CL"); ver perlrun para más información sobre esto.

Esta variable se agregó en Perl v5.8.8.

y remoto las variables
La desactivación de una variable anuncia la intención de los mantenedores de perl de eliminar eventualmente
la variable del idioma. Es posible que todavía esté disponible a pesar de su estado. Usando un
La variable obsoleta activa una advertencia.

Una vez que se elimina una variable, su uso desencadena un error que le indica que la variable es
sin apoyo.

Consulte perldiag para obtener detalles sobre los mensajes de error.

$ # $ # era una variable que podía usarse para formatear números impresos. Después de
ciclo de desaprobación, su magia se eliminó en Perl v5.10.0 y su uso ahora activa
una advertencia: "$ # ya no es compatible".

Este no es el sigilo que usa delante de un nombre de matriz para obtener el último índice,
como $ # array. Así es como se obtiene el último índice de una matriz en Perl. El
dos no tienen nada que ver el uno con el otro.

En desuso en Perl 5.

Eliminado en Perl v5.10.0.

$ * $ * era una variable que podía utilizar para habilitar la coincidencia de varias líneas. Después de
ciclo de desaprobación, su magia se eliminó en Perl v5.10.0. Usarlo ahora desencadena un
advertencia: "$ * ya no es compatible". Debes usar las expresiones regulares "/ s" y "/ m"
modificadores en su lugar.

En desuso en Perl 5.

Eliminado en Perl v5.10.0.

$ [Esta variable almacena el índice del primer elemento en una matriz y del primer
carácter en una subcadena. El valor predeterminado es 0, pero teóricamente podría establecerlo en
1 para hacer que Perl se comporte más como awk (o Fortran) al suscribirse y cuando
evaluando el índice() y substr () funciones.

A partir de la versión 5 de Perl, la asignación a $ [se trata como una directiva del compilador, y
no puede influir en el comportamiento de ningún otro archivo. (Por eso solo puede asignar
constantes de tiempo de compilación.) Se desaconseja su uso.

Antes de Perl v5.10.0, la asignación a $ [podía verse desde ámbitos léxicos externos en
el mismo archivo, a diferencia de otras directivas en tiempo de compilación (como estricta). Utilizando
local() en él vincularía su valor estrictamente a un bloque léxico. Ahora es siempre
con alcance léxico.

A partir de Perl v5.16.0, está implementado por el módulo arybase. Ver arybase para más
detalles sobre su comportamiento.

En "use v5.16", o "sin función" array_base "", $ [ya no tiene ningún efecto y
siempre contiene 0. Se permite asignarle 0, pero cualquier otro valor
producir un error.

Mnemónico: [comienza con subíndices.

En desuso en Perl v5.12.0.

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