perlrun - Online en la nube

PROGRAMA:

NOMBRE

perlrun - cómo ejecutar el intérprete de Perl

SINOPSIS

perl [ -sTtuUWX ] [ -hv ] [ -V[:configvar]]
[ -cw ] [ -d[t] [:depurador]] [ -D[número / lista]]
[ -pna ] [ -Fpatrón ] [ -l[octal]] [ -0[octal / hexadecimal]]
[ -Idir ] [ -m[-]módulo ] [ -M[-]'módulo...' ] [ -f ] [ -C [número / lista] ]
[ -S ] [ -x[dir]] [ -i[extensión]]
[[-e|-E] 'mando' ] [ -- ] [ Archivo de programa ] [ argumento ] ...

DESCRIPCIÓN

La forma normal de ejecutar un programa Perl es hacerlo directamente ejecutable, o bien
pasando el nombre del archivo fuente como argumento en la línea de comando. (Un interactivo
El entorno Perl también es posible; consulte perldebug para obtener detalles sobre cómo hacerlo).
Al iniciar, Perl busca su programa en uno de los siguientes lugares:

1. Especificado línea por línea a través de -e or -E cambia en la línea de comando.

2. Contenido en el archivo especificado por el primer nombre de archivo en la línea de comando. (Tenga en cuenta que
sistemas que soportan el "#!" la notación invoca a los intérpretes de esta manera. Ver "Ubicación de
Perl ".)

3. Pasado implícitamente a través de la entrada estándar. Esto funciona solo si no hay un nombre de archivo
argumentos: para pasar argumentos a un programa de lectura STDIN, debe especificar explícitamente un "-"
para el nombre del programa.

Con los métodos 2 y 3, Perl comienza a analizar el archivo de entrada desde el principio, a menos que haya
especificó un -x cambiar, en cuyo caso busca la primera línea que comienza con "#!" y
que contiene la palabra "perl", y comienza allí en su lugar. Esto es útil para ejecutar un
programa incrustado en un mensaje más grande. (En este caso indicarías el final del
programa usando el token "__END__").

El "#!" La línea siempre se examina en busca de conmutadores a medida que se analiza la línea. Por tanto, si
estás en una máquina que permite solo un argumento con el "#!" línea, o peor, no
incluso reconocer el "#!" línea, aún puede obtener un comportamiento de cambio constante independientemente de
cómo se invocó Perl, incluso si -x se utilizó para encontrar el comienzo del programa.

Porque históricamente algunos sistemas operativos cortaron silenciosamente la interpretación del kernel de
el "#!" línea después de 32 caracteres, algunos modificadores se pueden pasar en la línea de comando, y
algunos pueden no; incluso podría obtener un "-" sin su letra, si no tiene cuidado. Ustedes
probablemente quiera asegurarse de que todos sus interruptores caigan antes o después de eso
Límite de 32 caracteres. A la mayoría de los conmutadores no les importa si se procesan
redundante, pero obtener un "-" en lugar de un cambio completo podría hacer que Perl intente
ejecute la entrada estándar en lugar de su programa. Y un parcial -I El interruptor también podría causar
resultados extraños.

A algunos conmutadores les importa si se procesan dos veces, por ejemplo, combinaciones de -l y -0.
Coloque todos los interruptores después del límite de 32 caracteres (si corresponde) o reemplace
el uso de -0dígitos por "BEGIN {$ / =" \ 0digits ";}".

Análisis del "#!" cambia comienza dondequiera que se mencione "perl" en la línea. El
las secuencias "- *" y "-" se ignoran específicamente para que pueda, si fuera así
inclinado, decir

#!/ Bin / sh
#! - * - perl - * -
eval 'exec perl -x -wS $ 0 $ {1 + "$ @"}'
si 0;

para que Perl vea el -p switch.

Un truco similar implica el env programa, si lo tiene.

#!/ usr / bin / env perl

Los ejemplos anteriores usan una ruta relativa al intérprete de perl, obteniendo cualquier versión
es el primero en la ruta del usuario. Si desea una versión específica de Perl, digamos, perl5.14.1,
debe colocarlo directamente en el "#!" camino de la línea.

Si el "#!" la línea no contiene la palabra "perl" ni la palabra "indir" el programa llamado
después de la "#!" se ejecuta en lugar del intérprete de Perl. Esto es un poco extraño, pero
ayuda a las personas en máquinas que no hacen "#!", porque pueden decirle a un programa que su
SHELL es / usr / bin / perl, y Perl enviará el programa al intérprete correcto
para ellos.

Después de localizar su programa, Perl compila todo el programa en un formulario interno. Si
hay errores de compilación, no se intenta la ejecución del programa. (Esto es
a diferencia del típico script de shell, que puede ejecutarse a mitad de camino antes de encontrar una sintaxis
error.)

Si el programa es sintácticamente correcto, se ejecuta. Si el programa se agota al final
sin golpear un salida() or morir () operador, un implícito salida(0) se proporciona para indicar
completar con exito.

#! y citando on no Unix sistemas
El "#!" De Unix La técnica se puede simular en otros sistemas:

OS / 2
poner

extproc perl -S -sus_conmutadores

como la primera línea en el archivo "* .cmd" (-S debido a un error en el manejo de 'extproc' de cmd.exe).

MS-DOS
Cree un archivo por lotes para ejecutar su programa y codifíquelo en "ALTERNATE_SHEBANG" (consulte la
dosish.h archivo en la distribución de origen para obtener más información).

Win95 / NT
La instalación de Win95 / NT, cuando se utiliza el instalador de ActiveState para Perl, modificará
el Registro para asociar el .pl extensión con el intérprete de perl. Si instala
Perl por otros medios (incluida la construcción a partir de las fuentes), es posible que deba modificar el
Regístrese usted mismo. Tenga en cuenta que esto significa que ya no puede distinguir la diferencia entre
un programa ejecutable de Perl y un archivo de biblioteca de Perl.

Poner VMS

$ perl -mysw 'f $ env ("procedimiento")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8'!
$ salida ++ + ++ $ estado! = 0 y $ salida = $ estado = indef;

en la parte superior de su programa, donde -misw ¿Hay algún conmutador de línea de comando que desee pasar?
a Perl. Ahora puede invocar el programa directamente, diciendo "programa perl", o como un
Procedimiento DCL, diciendo @program (o implícitamente a través de DCL $ RUTA con solo usar el nombre
Del programa).

Este encantamiento es demasiado para recordar, pero Perl lo mostrará si
diga "perl" -V: startperl "".

Los intérpretes de comandos en sistemas que no son Unix tienen ideas bastante diferentes sobre las citas que en Unix
conchas. Deberá aprender los caracteres especiales en su intérprete de comandos ("*", "\"
y "" "son comunes) y cómo proteger los espacios en blanco y estos caracteres para ejecutar frases ingeniosas
(ver -e más abajo).

En algunos sistemas, es posible que deba cambiar las comillas simples por dobles, que debe no
hacer en sistemas Unix o Plan 9. También puede que tenga que cambiar un solo% a %%.

Por ejemplo:

#Unix
perl -e 'imprimir "Hola mundo \ n"'

#MS-DOS, etc
perl -e "print \" Hola mundo \ n \ ""

# VMS
perl -e "print" "Hola mundo \ n" ""

El problema es que nada de esto es confiable: depende del comando y es completamente
posible tampoco funciona. Si 4DOS si fuera el shell de comandos, esto probablemente funcionaría mejor:

perl -e "imprimir "Hola mundo \ n ""

CMD.EXE en Windows NT introdujo una gran cantidad de funciones estándar de Unix cuando nadie estaba
buscando, pero solo intente encontrar documentación para sus reglas de cotización.

No existe una solución general para todo esto. Es solo un desastre.

Ubicación of Perl
Puede parecer obvio decirlo, pero Perl es útil solo cuando los usuarios pueden encontrarlo fácilmente. Cuándo
posible, es bueno para ambos / usr / bin / perl y / usr / local / bin / perl para ser enlaces simbólicos al
binario real. Si eso no se puede hacer, se recomienda encarecidamente a los administradores del sistema que
poner (enlaces simbólicos a) perl y las utilidades que lo acompañan en un directorio que normalmente se encuentra
a lo largo de la RUTA de un usuario, o en algún otro lugar obvio y conveniente.

En esta documentación, "#!/ usr / bin / perl"en la primera línea del programa estará en
para cualquier método que funcione en su sistema. Se recomienda utilizar una ruta específica si
preocuparse por una versión específica.

#! / usr / local / bin / perl5.14

o si solo desea ejecutar al menos la versión, coloque una declaración como esta en la parte superior
de su programa:

utilizar 5.014;

Comando Switches
Al igual que con todos los comandos estándar, un conmutador de un solo carácter se puede agrupar con el
siguiente interruptor, si lo hay.

#!/ usr / bin / perl -spi.orig # igual que -s -p -i.orig

Un "-" indica el final de las opciones y deshabilita el procesamiento adicional de opciones. Cualquier argumento
después de "-" se tratan como nombres de archivo y argumentos.

Los interruptores incluyen:

-0[octal / hexadecimal]
especifica el separador de registros de entrada ($ /) como un número octal o hexadecimal. Si
no hay dígitos, el carácter nulo es el separador. Otros conmutadores pueden preceder
o siga los dígitos. Por ejemplo, si tiene una versión de find que puede imprimir
nombres de archivo terminados por el carácter nulo, puede decir esto:

encontrar . -nombre '* .orig' -print0 | perl -n0e desvincular

El valor especial 00 hará que Perl absorba archivos en modo párrafo. Algún valor
0400 o superior hará que Perl absorba archivos enteros, pero por convención el valor 0777
es el que se utiliza normalmente para este fin.

También puede especificar el carácter separador utilizando notación hexadecimal: -0xHHH ...,
donde el "H" son dígitos hexadecimales válidos. A diferencia de la forma octal, esta puede ser
se utiliza para especificar cualquier carácter Unicode, incluso aquellos más allá de 0xFF. Así que si usted realmente want
un separador de registros de 0777, especifíquelo como -0x1FF. (Esto significa que no puede usar
de la forma más -x opción con un nombre de directorio que consta de dígitos hexadecimales, o bien Perl
pensará que ha especificado un número hexadecimal para -0.)

-a activa el modo de división automática cuando se usa con un -n or -p. Un comando de división implícito al
@F matriz se hace como lo primero dentro del bucle while implícito producido por el -n
or -p.

perl -ane 'imprimir pop (@F), "\ n";'

es equivalente a

while (<>) {
@F = dividir ('');
imprimir pop (@F), "\ n";
}

Se puede especificar un delimitador alternativo usando -F.

-a establece implícitamente -n.

-C [número / lista]
El sistema -C flag controla algunas de las características de Perl Unicode.

A partir de 5.8.1, el -C puede ir seguido de un número o de una lista de letras de opciones.
Las letras, sus valores numéricos y efectos son los siguientes; enumerar las letras es
igual a sumar los números.

Se supone que I 1 STDIN está en UTF-8
O 2 STDOUT estará en UTF-8
E 4 STDERR estará en UTF-8
S 7 I + O + E
i 8 UTF-8 es la capa PerlIO predeterminada para flujos de entrada
o 16 UTF-8 es la capa PerlIO predeterminada para flujos de salida
D 24 yo + o
A 32 se espera que los elementos @ARGV estén codificados en cadenas
en UTF-8
L 64 normalmente las "IOEioA" son incondicionales, la L hace
los condicionan a las variables de entorno local
(LC_ALL, LC_CTYPE y LANG, en el orden de
precedencia decreciente) - si las variables indican
UTF-8, entonces los "IOEioA" seleccionados están en efecto
a 256 Establecer $ {^ UTF8CACHE} en -1, para ejecutar el almacenamiento en caché UTF-8
código en modo de depuración.

Por ejemplo, -COE y -C6 ambos activarán UTF-8-ness tanto en STDOUT como en STDERR.
La repetición de letras es simplemente redundante, no acumulativa ni alternante.

Las opciones "io" significan que cualquier open() (u operaciones de E / S similares) en el
El alcance del archivo actual tendrá la capa PerlIO ": utf8" aplicada implícitamente a ellos, en
En otras palabras, se espera UTF-8 de cualquier flujo de entrada, y UTF-8 se produce en cualquier
flujo de salida. Este es solo el predeterminado, con capas explícitas en open() y con
binmode () se pueden manipular los arroyos como de costumbre.

-C por sí solo (no seguido por ningún número o lista de opciones), o la cadena vacía "" para
la variable de entorno "PERL_UNICODE", tiene el mismo efecto que -CSDL. En otra
palabras, los identificadores de E / S estándar y la capa "open ()" predeterminada son UTF-8-fied but
solo si las variables de entorno de la configuración regional indican una configuración regional UTF-8. Este comportamiento
sigue el implícitamente (y problemático) comportamiento UTF-8 de Perl 5.8.0. (Ver "UTF-8 no
por defecto más largo en configuraciones regionales UTF-8 "en perl581delta.)

Puedes usar -C0 (o "0" para "PERL_UNICODE") para deshabilitar explícitamente todo lo anterior
Funciones Unicode.

La variable mágica de solo lectura "$ {^ UNICODE}" refleja el valor numérico de este
ajuste. Esta variable se establece durante el inicio de Perl y, a partir de entonces, es de solo lectura. Si
quieres efectos en tiempo de ejecución, usa los tres argumentos open() (ver "abierto" en perlfunc), los dos-
arg binmode () (ver "binmode" en perlfunc), y el pragma "open" (ver open).

(En Perls anteriores a 5.8.1 el -C El conmutador era un conmutador solo para Win32 que habilitaba el
uso de API de Win32 de "llamada amplia al sistema" compatibles con Unicode. Esta característica fue prácticamente
sin usar, sin embargo, y el modificador de línea de comando fue, por lo tanto, "reciclado").

Nota: Desde perl 5.10.1, si el -C se utiliza la opción "#!" línea, debe ser
también se especifica en la línea de comando, ya que los flujos estándar ya están configurados
en este punto de la ejecución del intérprete de perl. También puedes usar binmode ()
para configurar la codificación de un flujo de E / S.

-c hace que Perl verifique la sintaxis del programa y luego salga sin ejecutarlo.
En realidad, will ejecutar y los bloques "BEGIN", "UNITCHECK" o "CHECK" y cualquier "uso"
declaraciones: se considera que ocurren fuera de la ejecución de su programa.
Sin embargo, se omitirán los bloques "INIT" y "END".

-d
-dt ejecuta el programa bajo el depurador de Perl. Ver perldebug. Si t se especifica, es
indica al depurador que se utilizarán subprocesos en el código que se está depurando.

-re:MOD [= bar, baz]
-dt:MOD [= bar, baz]
ejecuta el programa bajo el control de un módulo de depuración, creación de perfiles o seguimiento
instalado como "Devel ::MODIFICACIÓN". P.ej, -d: DProf ejecuta el programa usando el
Generador de perfiles "Devel :: DProf". Como con el -M , las opciones se pueden pasar al
"Devel ::MODIFICACIÓN" paquete donde serán recibidos e interpretados por el
"Devel ::MOD :: importar " rutina. De nuevo, como -M, usar --D:-MOD llamar
"Devel ::MOD :: desimportar " en lugar de importar. La lista de opciones separadas por comas debe
seguir un carácter "=". Si t se especifica, le indica al depurador que los subprocesos
se utilizará en el código que se está depurando. Ver perldebug.

-Dletters
-Dnúmero
establece banderas de depuración. Para ver cómo ejecuta su programa, use -Dtls. (Esto funciona
solo si la depuración está compilada en su Perl.) Otro buen valor es -Dx, cual
enumera su árbol de sintaxis compilado. Y -Dr muestra expresiones regulares compiladas; el
El formato de la salida se explica en perldebguts.

Como alternativa, especifique un número en lugar de una lista de letras (p. Ej., -D14 is
equivalente a -Dtls):

1 p Tokenización y análisis (con v, muestra la pila de análisis)
2 s Instantáneas de pila (con v, muestra todas las pilas)
4 l Procesamiento de pila de contexto (bucle)
8 t Ejecución de seguimiento
16o Método y resolución de sobrecarga
32 c Conversiones de cadenas / numéricas
64 P Imprimir información de perfil, estado de entrada del archivo de origen
128 m de memoria y asignación de SV
Procesamiento de formato 256 f
512 r Análisis y ejecución de expresiones regulares
1024 x volcado de árbol de sintaxis
2048 u Controles contaminados
4096 U No oficial, piratería de usuarios (reservado para privados,
uso inédito)
8192 Hash dump: usurpa los valores ()
16384 X Asignación del Bloc de notas
32768 D Limpieza
65536 Asignación de losas S Op
131072 T Tokenización
262144 R Incluir recuentos de referencia de variables objeto de dumping (por ejemplo, cuando
usando -Ds)
524288 J muestra s, t, P-depuración (no saltar) en códigos de operación dentro
paquete DB
1048576 v Detallado: utilizar junto con otros indicadores
2097152 C Copiar al escribir
4194304 A Comprobaciones de coherencia en estructuras internas
8388608 q silencioso - actualmente solo suprime el "EJECUTANDO"
mensaje
16777216 Resolución de coincidencia inteligente de seguimiento M
33554432 B dump suBrutina definiciones, incluidos bloques especiales
como BEGIN
67108864 L trace Información relacionada con la configuración regional; lo que obtiene salida es muy
sujeto a cambios

Todas estas banderas requieren -DEPURACIÓN cuando compila el ejecutable de Perl (pero vea
": opd" en Devel :: Peek o "modo 'depuración'" en re, lo que puede cambiar esto). Ver el
INSTALAR en la distribución fuente de Perl para saber cómo hacer esto. Esta bandera es
se configura automáticamente si incluye -g opción cuando "Configurar" le pregunta sobre
indicadores de optimizador / depurador.

Si solo está tratando de obtener una impresión de cada línea de código Perl mientras se ejecuta,
la forma en que "sh -x" proporciona scripts de shell, no puede usar Perl -D switch.
En su lugar haz esto

# Si tiene la utilidad "env"
env PERLDB_OPTS = "NonStop = 1 AutoTrace = 1 frame = 2" programa perl -dS

# Sintaxis del shell Bourne
$ PERLDB_OPTS = "NonStop = 1 AutoTrace = 1 frame = 2" programa perl -dS

# sintaxis csh
% (setenv PERLDB_OPTS "NonStop = 1 AutoTrace = 1 frame = 2"; programa perl -dS)

Consulte perldebug para obtener detalles y variaciones.

-e línea de comando
puede usarse para ingresar una línea de programa. Si -e se da, Perl no buscará un
nombre de archivo en la lista de argumentos. Múltiple -e Se pueden dar órdenes para construir un
secuencia de comandos de varias líneas. Asegúrese de usar punto y coma donde lo haría en un programa normal.

-E línea de comando
se comporta como -e, excepto que habilita implícitamente todas las características opcionales (en el
unidad de compilación principal). Ver característica.

-f Deshabilitar la ejecución $ Config {sitelib} /sitecustomize.pl Al inicio.

Perl se puede construir para que intente ejecutar de forma predeterminada
$ Config {sitelib} /sitecustomize.pl al inicio (en un bloque BEGIN). Este es un gancho que
permite al administrador del sistema personalizar cómo se comporta Perl. Por ejemplo, se puede utilizar para
agregue entradas a la matriz @INC para que Perl busque módulos en ubicaciones no estándar.

Perl realmente inserta el siguiente código:

EMPEZAR {
hacer {local $ !; -f "$ Config {sitelib} /sitecustomize.pl"; }
&& hacer "$ Config {sitelib} /sitecustomize.pl";
}

Dado que es un "hacer" real (no un "requisito"), sitiopersonalizar.pl no necesita regresar
un verdadero valor. El código se ejecuta en el paquete "main", en su propio ámbito léxico. Sin embargo,
si el script muere, $ @ no se establecerá.

El valor de $ Config {sitelib} también se determina en el código C y no se lee desde
"Config.pm", que no está cargado.

El código se ejecuta muy temprano. Por ejemplo, se mostrarán los cambios realizados en @INC.
en la salida de `perl -V`. Por supuesto, los bloques "END" también se ejecutarán muy
tarde.

Para determinar en tiempo de ejecución si esta capacidad se ha compilado en su perl, puede
verifique el valor de $ Config {usesitecustomize}.

-Fpatrón
especifica el patrón para dividir para -a. El patrón puede estar rodeado por "//", "",
o '', de lo contrario se pondrá entre comillas simples. No puede usar espacios en blanco literal en
el patrón.

-F establece implícitamente ambos -a y -n.

-h imprime un resumen de las opciones.

-i[extensión]
especifica que los archivos procesados ​​por la construcción "<>" deben editarse in situ. Eso
hace esto cambiando el nombre del archivo de entrada, abriendo el archivo de salida con el nombre original,
y seleccionando ese archivo de salida como predeterminado para imprimir() declaraciones. La extensión,
si se proporciona, se utiliza para modificar el nombre del archivo antiguo para hacer una copia de seguridad,
siguiendo estas reglas:

Si no se proporciona ninguna extensión y su sistema la admite, el original presentar se mantiene
abrir sin un nombre mientras la salida se redirige a un nuevo archivo con el original
nombre de archivo. Cuando perl sale, limpiamente o no, el original presentar está desvinculado.

Si la extensión no contiene un "*", se agrega al final de la actual
nombre de archivo como sufijo. Si la extensión contiene uno o más caracteres "*", entonces
cada "*" se reemplaza con el nombre de archivo actual. En términos de Perl, podría pensar en
esto como:

($ copia de seguridad = $ extensión) = ~ s / \ * / $ nombre_archivo / g;

Esto le permite agregar un prefijo al archivo de respaldo, en lugar de (o además de) un
sufijo:

$ perl -pi'orig_ * '-e' s / bar / baz / 'fileA # copia de seguridad en
# 'archivo_originalA'

O incluso para colocar copias de seguridad de los archivos originales en otro directorio (proporcionado
el directorio ya existe):

$ perl -pi'old / *. orig '-e' s / bar / baz / 'fileA # copia de seguridad en
# 'antiguo / fileA.orig'

Estos conjuntos de frases ingeniosas son equivalentes:

$ perl -pi -e 's / bar / baz /' fileA # sobrescribe el archivo actual
$ perl -pi '*' -e 's / bar / baz /' fileA # sobrescribe el archivo actual

$ perl -pi'.orig '-e' s / bar / baz / 'fileA # copia de seguridad en' fileA.orig '
$ perl -pi '*. orig' -e 's / bar / baz /' fileA # copia de seguridad en 'fileA.orig'

Desde el caparazón, diciendo

$ perl -p -i.orig -e "s / foo / bar /; ..."

es lo mismo que usar el programa:

#!/ usr / bin / perl -pi.orig
s / foo / bar /;

que es equivalente a

#!/ usr / bin / perl
$ extensión = '.orig';
LINE: while (<>) {
if ($ ARGV ne $ oldargv) {
if ($ extensión! ~ / \ * /) {
$ copia de seguridad = $ ARGV. $ extensión;
}
else {
($ respaldo = $ extensión) = ~ s / \ * / $ ARGV / g;
}
renombrar ($ ARGV, $ copia de seguridad);
abierto (ARGVOUT, "> $ ARGV");
seleccione (ARGVOUT);
$ oldargv = $ ARGV;
}
s / foo / bar /;
}
Seguir {
impresión; # esto se imprime en el nombre de archivo original
}
seleccione (STDOUT);

excepto que el -i El formulario no necesita comparar $ ARGV con $ oldargv para saber cuándo
el nombre del archivo ha cambiado. Sin embargo, usa ARGVOUT para el identificador de archivo seleccionado.
Tenga en cuenta que STDOUT se restaura como el identificador de archivo de salida predeterminado después del bucle.

Como se muestra arriba, Perl crea el archivo de respaldo independientemente de que la salida sea realmente
cambió. Así que esta es solo una forma elegante de copiar archivos:

$ perl -p -i '/ algunos / archivo / ruta / *' -e 1 archivo1 archivo2 archivo3 ...
or
$ perl -p -i'.orig '-e 1 archivo1 archivo2 archivo3 ...

Puede utilizar "eof" sin paréntesis para localizar el final de cada archivo de entrada, en caso de
desea agregar a cada archivo, o restablecer la numeración de línea (ver ejemplo en "eof" en
perlfunc).

Si, para un archivo dado, Perl no puede crear el archivo de respaldo como se especifica en el
extensión, saltará ese archivo y continuará con el siguiente (si
existe).

Para una discusión de los problemas relacionados con los permisos de archivos y -i, consulte "¿Por qué Perl
¿Permitirme eliminar archivos de solo lectura? ¿Por qué -i aplasta los archivos protegidos? ¿No es esto un
error en Perl? "en perlfaq5.

No se puede utilizar -i para crear directorios o quitar extensiones de archivos.

Perl no expande "~" en los nombres de archivo, lo cual es bueno, ya que algunas personas lo usan para
sus archivos de respaldo:

$ perl -pi ~ -e 's / foo / bar /' archivo1 archivo2 archivo3 ...

Tenga en cuenta que porque -i cambia el nombre o elimina el archivo original antes de crear un nuevo archivo
con el mismo nombre, no se conservarán los enlaces duros y blandos de estilo Unix.

Finalmente, la -i El conmutador no impide la ejecución cuando no se proporcionan archivos en el
línea de comando. En este caso, no se realiza ninguna copia de seguridad (el archivo original no puede, por supuesto,
ser determinado) y el procesamiento procede de STDIN a STDOUT como podría esperarse.

-Idirectorio
Directorios especificados por -I se anteponen a la ruta de búsqueda de módulos (@INC).

-l[octum]
habilita el procesamiento automático de fin de línea. Tiene dos efectos separados. Primero, es
muerde automáticamente $ / (el separador de registros de entrada) cuando se usa con -n or -p.
En segundo lugar, asigna "$ \" (el separador de registros de salida) para tener el valor de octum so
que cualquier declaración impresa tendrá ese separador agregado nuevamente. Si octum is
omitido, establece "$ \" en el valor actual de $/. Por ejemplo, para recortar líneas a 80
columnas:

perl -lpe 'substr ($ _, 80) = ""'

Tenga en cuenta que la asignación "$ \ = $ /" se realiza cuando se procesa el cambio, por lo que la entrada
El separador de registros puede ser diferente al separador de registros de salida si el -l cambiar
es seguido por un -0 cambiar:

gnufind / -print0 | perl -ln0e 'imprimir "encontrado $ _" if -p'

Esto establece "$ \" en nueva línea y luego establece $ / en el carácter nulo.

-m[-]módulo
-M[-]módulo
-M[-]'módulo ... '
- [mM][-]módulo = arg [, arg] ...
-mmódulo ejecuta "uso" módulo "();" antes de ejecutar su programa.

-Mmódulo ejecuta "uso" módulo ";" antes de ejecutar su programa. Puedes usar comillas
para agregar código adicional después del nombre del módulo, por ejemplo, '-MMÓDULO qw (foo bar)'.

Si el primer carácter después del -M or -m es un guión-) entonces se reemplaza el 'uso'
sin'.

Un poco de azúcar sintáctico incorporado significa que también puede decir -mMÓDULO= foo, bar or
-MMÓDULO= foo, bar como atajo para '-METROMÓDULO qw (foo bar)'. Esto evita la necesidad de
utilice comillas al importar símbolos. El código real generado por -MMÓDULO= foo, bar is
"use el módulo dividido (/, /, q {foo, bar})". Tenga en cuenta que el formulario "=" elimina la distinción
entre -m y -M, Es decir, -mMÓDULO= foo, bar es el mismo que -MMÓDULO= foo, bar.

Una consecuencia de esto es que -MMÓDULO= numero nunca realiza una verificación de versión, a menos que
"MÓDULO :: import () " en sí está configurado para realizar una verificación de versión, lo que podría suceder para
ejemplo si MÓDULO hereda de Exporter.

-n hace que Perl asuma el siguiente bucle alrededor de su programa, lo que lo hace iterar
sobre argumentos de nombre de archivo algo así como SED -n or awk:

LÍNEA:
while (<>) {
... # tu programa va aquí
}

Tenga en cuenta que las líneas no se imprimen de forma predeterminada. Consulte "-p" para imprimir líneas. Si
un archivo nombrado por un argumento no se puede abrir por alguna razón, Perl le advierte al respecto
y pasa al siguiente archivo.

También tenga en cuenta que "<>" pasa argumentos de línea de comando a "abrir" en perlfunc, que
no necesariamente los interpreta como nombres de archivo. Ver perlop para una posible seguridad
trascendencia.

Esta es una forma eficaz de eliminar todos los archivos que no se han modificado durante al menos
una semana:

encontrar . -mtime +7 -print | perl -nle desvincular

Esto es más rápido que usar el Exec- interruptor de find porque no tienes que empezar un
proceso en cada nombre de archivo encontrado. Sufre del error de manejar mal las nuevas líneas.
en nombres de ruta, que puede corregir si sigue el ejemplo de -0.

Los bloques "BEGIN" y "END" se pueden usar para capturar el control antes o después del implícito
bucle de programa, al igual que en awk.

-p hace que Perl asuma el siguiente bucle alrededor de su programa, lo que lo hace iterar
sobre argumentos de nombre de archivo algo así como SED:

LÍNEA:
while (<>) {
... # tu programa va aquí
} Seguir {
imprimir o morir "-p destino: $! \ n";
}

Si un archivo nombrado por un argumento no se puede abrir por alguna razón, Perl le advierte sobre
y pasa al siguiente archivo. Tenga en cuenta que las líneas se imprimen automáticamente.
Un error que ocurre durante la impresión se considera fatal. Para suprimir la impresión utilice el
-n cambiar. A -p anula un -n switch.

Los bloques "BEGIN" y "END" se pueden usar para capturar el control antes o después del implícito
bucle, como en awk.

-s permite el análisis rudimentario de conmutadores para conmutadores en la línea de comando después del programa
nombre pero antes de cualquier argumento de nombre de archivo (o antes de un argumento de --). Cualquier interruptor
encontrado allí se elimina de @ARGV y establece la variable correspondiente en Perl
programa. El siguiente programa imprime "1" si el programa se invoca con un -xyz
switch y "abc" si se invoca con -xyz = abc.

#!/ usr / bin / perl -s
if ($ xyz) {imprimir "$ xyz \ n"}

Tenga en cuenta que un interruptor como --ayuda crea la variable "$ {- help}", que no es
compatible con "use" referencias estrictas "". Además, al usar esta opción en un script con
advertencias habilitadas, es posible que obtenga muchas advertencias falsas de "solo se usa una vez".

-S hace que Perl use la variable de entorno PATH para buscar el programa a menos que el
El nombre del programa contiene separadores de ruta.

En algunas plataformas, esto también hace que Perl agregue sufijos al nombre de archivo mientras
buscándolo. Por ejemplo, en plataformas Win32, los sufijos ".bat" y ".cmd"
se agregan si falla la búsqueda del nombre original, y si el nombre no
ya terminan en uno de esos sufijos. Si su Perl fue compilado con "DEBUGGING"
encendido, usando el -DP cambiar a Perl muestra cómo progresa la búsqueda.

Normalmente, se utiliza para emular "#!" inicio en plataformas que no son compatibles con "#!".
También es conveniente cuando se depura un script que usa "#!" Y, por lo tanto, normalmente
encontrado por el mecanismo de búsqueda $ PATH del shell.

Este ejemplo funciona en muchas plataformas que tienen un shell compatible con Bourne shell:

#!/ usr / bin / perl
eval 'ejecutivo / usr / bin / perl -wS $ 0 $ {1 + "$ @"} '
if $ running_under_some_shell;

El sistema ignora la primera línea y envía el programa a / Bin / sh, que procede a
intente ejecutar el programa Perl como un script de shell. El shell ejecuta el segundo
line como un comando de shell normal y, por lo tanto, inicia el intérprete de Perl. En algunos
sistemas $ 0 no siempre contiene el nombre de ruta completo, por lo que el -S le dice a Perl que busque
para el programa si es necesario. Después de que Perl localiza el programa, analiza las líneas
y los ignora porque la variable $ running_under_some_shell nunca es verdadera. Si
el programa será interpretado por csh, deberá reemplazar "$ {1 +" $ @ "}" con $ *,
aunque eso no comprende los espacios incrustados (y demás) en la lista de argumentos.
Comenzar sh más bien que csh, algunos sistemas pueden tener que reemplazar el "#!" línea con un
línea que contiene solo dos puntos, que Perl ignorará cortésmente. Otros sistemas
no puedo controlar eso, y necesita una construcción totalmente tortuosa que funcione bajo cualquiera de
csh, sh, o Perl, como los siguientes:

eval '(salida $? 0)' && eval 'exec perl -wS $ 0 $ {1 + "$ @"}'
& eval 'exec / usr / bin / perl -wS $ 0 $ argv: q '
if $ running_under_some_shell;

Si el nombre de archivo proporcionado contiene separadores de directorio (y por lo tanto es un valor absoluto o
nombre de ruta relativa), y si ese archivo no se encuentra, las plataformas que agregan el archivo
extensiones lo hará e intentará buscar el archivo con esas extensiones agregadas, una
por uno.

En plataformas similares a DOS, si el programa no contiene separadores de directorio,
primero se buscará en el directorio actual antes de buscar en la RUTA.
En plataformas Unix, el programa se buscará estrictamente en la RUTA.

-t Como -T, pero las comprobaciones de corrupción emitirán advertencias en lugar de errores fatales. Estos
Las advertencias ahora se pueden controlar normalmente sin "advertencias qw (taint)".

Nota: Este is no a sustitutas for "-T"! Esto está destinado a ser utilizado only como temporal
ayuda al desarrollo mientras se asegura el código heredado: para código de producción real y para
código seguro escrito desde cero, utilice siempre el código real -T.

-T activa "taint" para que puedas probarlos. Por lo general, estas comprobaciones se realizan solo cuando
ejecutando setuid o setgid. Es una buena idea activarlos explícitamente para los programas.
que se ejecutan en nombre de otra persona en la que no necesariamente confía, como CGI
programas o cualquier servidor de Internet que pueda escribir en Perl. Consulte perlsec para obtener más detalles.
Por razones de seguridad, Perl debe ver esta opción con bastante anticipación; generalmente esto
significa que debe aparecer al principio de la línea de comando o en el "#!" línea para sistemas que
apoyar esa construcción.

-u Este modificador hace que Perl descargue el núcleo después de compilar su programa. Entonces puedes en
teoría, tome este volcado de memoria y conviértalo en un archivo ejecutable utilizando la deshacerse
programa (no suministrado). Esto acelera el inicio a expensas de algo de espacio en disco (que
puede minimizar eliminando el ejecutable). (Aún así, un ejecutable "hola mundo"
sale a unos 200K en mi máquina.) Si desea ejecutar una parte de su
programa antes de descargar, utilice el vertedero() operador en su lugar. Nota: disponibilidad de
deshacerse es específico de la plataforma y puede no estar disponible para un puerto específico de Perl.

-U permite a Perl realizar operaciones inseguras. Actualmente, las únicas operaciones "inseguras" son
intentar desvincular directorios mientras se ejecuta como superusuario y ejecuta setuid
los programas con comprobaciones de contaminación fatal se convirtieron en advertencias. Tenga en cuenta que las advertencias deben
habilitado junto con esta opción para realmente generar las advertencias de verificación de contaminación.

-v imprime la versión y el nivel de parche de su ejecutable perl.

-V imprime un resumen de los principales valores de configuración de Perl y los valores actuales de @INC.

-V:configvar
Imprime en STDOUT el valor de las variables de configuración nombradas, con múltiplos
cuando tu "configvar " El argumento parece una expresión regular (no tiene letras). Por ejemplo:

$ perl -V: libc
libc = '/ lib / libc-2.2.4.so';
$ perl -V: lib.
libs = '- lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
libc = '/ lib / libc-2.2.4.so';
$ perl -V: lib. *
libpth = '/ usr / local / lib / lib / Usr / lib';
libs = '- lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
lib_ext = '. a';
libc = '/ lib / libc-2.2.4.so';
libperl = 'libperl.a';
....

Además, se pueden utilizar dos puntos adicionales para controlar el formato. Un colon al final
suprime el salto de línea y el terminador ";", lo que le permite incrustar consultas en el shell
comandos. (mnemónico: separador PATH ":".)

$ echo "compress-vars:" `perl -V: z. *:` "¡están aquí!"
compresión-vars: zcat = '' zip = 'zip' ya están aquí!

Los dos puntos iniciales eliminan la parte "name =" de la respuesta, esto le permite mapear a
el nombre que necesitas. (mnemónico: etiqueta vacía)

$ echo "goodvfork =" `./perl -Ilib -V :: usevfork`
goodvfork = falso;

Los dos puntos iniciales y finales se pueden usar juntos si necesita un parámetro posicional
valores sin los nombres. Tenga en cuenta que en el caso siguiente, los parámetros "PERL_API" son
devuelto en orden alfabético.

$ echo building_on `perl -V :: osname: -V :: PERL_API _. *:` ahora
building_on 'linux' '5' '1' '9' ahora

-w imprime advertencias sobre construcciones dudosas, como nombres de variables que se mencionan solo una vez
y variables escalares utilizadas antes de establecerse; subrutinas redefinidas; referencia a
identificadores de archivos indefinidos; identificadores de archivo abiertos de solo lectura que está intentando escribir
sobre; valores usados ​​como un número que no look como números; usando una matriz como si
eran un escalar; si sus subrutinas se repiten a más de 100 de profundidad; e innumerables otros
cosas.

Este conmutador realmente solo habilita la variable global $ ^ W; normalmente, el léxico
Se prefiere el pragma de "advertencias de uso" con alcance. Puede deshabilitar o promover a fatal
errores advertencias específicas usando ganchos "__WARN__", como se describe en perlvar y "advertir"
en perlfunc. Véanse también perldiag y perltrap. Una facilidad de advertencia detallada es
también disponible si desea manipular clases enteras de advertencias; ver advertencias.

-W Habilita todas las advertencias independientemente de "sin advertencias" o $ ^ W. Ver advertencias.

-X Desactiva todas las advertencias independientemente de las "advertencias de uso" o $ ^ W. Ver advertencias.

-x
-xdirectorio
le dice a Perl que el programa está incrustado en una porción más grande de texto no relacionado, como
en un mensaje de correo. La basura principal se descartará hasta la primera línea que
comienza con "#!" y contiene la cadena "perl". Cualquier cambio significativo en eso
se aplicará la línea.

Todas las referencias a números de línea por parte del programa (advertencias, errores, ...) tratarán la
"#!" línea como la primera línea. Por lo tanto, una advertencia en la segunda línea del programa, que es
en la línea 100 del archivo se informará como la línea 2, no como la línea 100. Esto puede
ser anulado usando la directiva "#line". (Consulte "Comentarios antiguos sencillos (¡no!)" En
perlsin)

Si se especifica un nombre de directorio, Perl cambiará a ese directorio antes de ejecutar
el programa. El -x El interruptor controla solo la eliminación de la basura principal. El
el programa debe terminar con "__END__" si hay basura al final para ser ignorada;
el programa puede procesar parte o toda la basura final a través del identificador de archivo "DATOS"
Si es deseado.

El directorio, si se especifica, debe aparecer inmediatamente después de la -x con ningún
espacio en blanco intermedio.

MEDIO AMBIENTE

INICIO Se utiliza si "chdir" no tiene ningún argumento.

LOGDIR Se usa si "chdir" no tiene argumento y HOME no está configurado.

PATH Se utiliza para ejecutar subprocesos y para encontrar el programa si -S se utiliza.

PERL5LIB Una lista de directorios en los que buscar archivos de la biblioteca Perl antes de buscar
en la biblioteca estándar y el directorio actual. Cualquier arquitectura específica
y directorios específicos de la versión, como versión / archname /, versión/o
archname / en las ubicaciones especificadas se incluyen automáticamente si
existen, con esta búsqueda realizada en el momento de inicio del intérprete. Además, cualquier
Se agregan los directorios que coinciden con las entradas en $ Config {inc_version_list}.
(Por lo general, estos serían para versiones anteriores de Perl compatibles instaladas en el
mismo árbol de directorio.)

Si PERL5LIB no está definido, se utiliza PERLLIB. Los directorios están separados (como
en PATH) con dos puntos en las plataformas Unixish y con un punto y coma en Windows (el
separador de ruta adecuado dado por el comando "perl -V:path_sep ").

Al ejecutar comprobaciones de corrupción, ya sea porque el programa estaba ejecutando setuid o
setgid, o el -T or -t se especificó el conmutador, ni PERL5LIB ni PERLLIB son
consultado. En cambio, el programa debería decir:

use lib "/ mi / directorio";

PERL5OPT Opciones de la línea de comandos (conmutadores). Los conmutadores de esta variable se tratan como si
estaban en cada línea de comando de Perl. Solo el - [CDIMUdmtwW] los interruptores son
permitido. Al ejecutar comprobaciones de corrupción (ya sea porque el programa se estaba ejecutando
setuid o setgid, o porque el -T or -t se utilizó el interruptor), esta variable es
ignorado. Si PERL5OPT comienza con -T, la contaminación se habilitará y posteriormente
opciones ignoradas. Si PERL5OPT comienza con -t, se habilitará la contaminación, un
Se eliminó el punto de escritura de @INC y se respetaron las opciones posteriores.

PERLIO Una lista separada por espacios (o dos puntos) de capas de PerlIO. Si perl está diseñado para usar
Sistema PerlIO para IO (el predeterminado) estas capas afectan el IO de Perl.

Es convencional comenzar los nombres de las capas con dos puntos (por ejemplo, ": perlio")
para enfatizar su similitud con los "atributos" variables. Pero el código que
analiza cadenas de especificación de capa, que también se utiliza para decodificar el PERLIO
variable de entorno, trata los dos puntos como un separador.

Un PERLIO vacío o desarmado es equivalente al conjunto predeterminado de capas para su
plataforma; por ejemplo, ": unix: perlio" en sistemas similares a Unix y ": unix: crlf" en
Windows y otros sistemas similares a DOS.

La lista se convierte en la predeterminada para all IO de Perl. En consecuencia, solo incorporado
las capas pueden aparecer en esta lista, como capas externas (como ": codificación ()")
¡Necesito IO para cargarlos! Consulte "pragma abierto" para saber cómo agregar
codificaciones por defecto.

Las capas que tiene sentido incluir en la variable de entorno PERLIO son
resumido brevemente a continuación. Para obtener más detalles, consulte PerlIO.

: bytes Una pseudocapa que convierte el indicador ": utf8" off para la capa de abajo;
Es poco probable que sea útil por sí solo en el entorno global de PERLIO.
variable. Quizás estaba pensando en ": crlf: bytes" o
": perlio: bytes".

: crlf Una capa que hace CRLF a la traducción "\ n" distinguiendo "texto" y
archivos "binarios" a la manera de MS-DOS y sistemas operativos similares.
(Actualmente lo hace no imitar MS-DOS en lo que respecta al tratamiento de Control-Z como
siendo un marcador de fin de archivo).

: mmap Una capa que implementa la "lectura" de archivos mediante mmap(2) para hacer un
el archivo completo aparece en el espacio de direcciones del proceso, y luego usando ese
como "búfer" de PerlIO.

: perlio Esta es una reimplementación del almacenamiento en búfer tipo stdio escrito como
Capa de PerlIO. Como tal, llamará a cualquier capa que esté debajo de ella por su
operaciones, típicamente ": unix".

: pop Una pseudocapa experimental que elimina la capa superior. Usar con
el mismo cuidado que se reserva para la nitroglicerina.

: raw Una pseudocapa que manipula otras capas. Aplicando el ": raw"
layer es equivalente a llamar a "binmode ($ fh)". Hace la corriente
pasar cada byte tal cual sin traducción. En particular, tanto CRLF
la traducción y la intuición ": utf8" de la configuración regional están deshabilitadas.

A diferencia de las versiones anteriores de Perl, ": raw" es no solo el inverso de
": crlf": otras capas que afectarían a la naturaleza binaria del
stream también se eliminan o desactivan.

: stdio Esta capa proporciona una interfaz PerlIO envolviendo el ANSI C del sistema
llamadas a la biblioteca "stdio". La capa proporciona almacenamiento en búfer y E / S. Nota
que la capa ": stdio" hace no hacer la traducción CRLF incluso si eso es
el comportamiento normal de la plataforma. Necesitará una capa ": crlf" arriba
para hacer eso.

: unix Capa de bajo nivel que llama a "leer", "escribir", "lseek", etc.

: utf8 Una pseudocapa que habilita una bandera en la capa de abajo para decirle a Perl que
la salida debe estar en utf8 y esa entrada debe considerarse como ya
en formato utf8 válido. ADVERTENCIA: It sí no check for validez y as
tal should be manejado con extremo precaución for entrada, because
EN LINEA violaciónes can ocurrir con no más corto UTF-8 codificaciones, etc.
Generalmente, ": codificación (utf8)" es la mejor opción al leer UTF-8
datos codificados.

: win32 En plataformas Win32 esto experimental La capa utiliza E / S nativa de "control"
en lugar de una capa de descriptor de archivo numérico similar a Unix. Conocido por ser
buggy en esta versión (5.14).

El conjunto de capas predeterminado debería dar resultados aceptables en todas las plataformas.

Para plataformas Unix, será el equivalente de "unix perlio" o "stdio".
Configure está configurado para preferir la implementación "stdio" si el sistema
la biblioteca proporciona un acceso rápido al búfer; de lo contrario, usa el "unix
Perlio "implementación.

En Win32, el valor predeterminado en esta versión (5.14) es "unix crlf". "Stdio" de Win32
tiene una serie de errores / funciones erróneas para Perl IO que dependen un poco de
la versión y el proveedor del compilador de C. Usando nuestra propia capa "crlf" como el
buffer evita esos problemas y hace que las cosas sean más uniformes. La capa "crlf"
proporciona conversión CRLF y almacenamiento en búfer.

Esta versión (5.14) usa "unix" como capa inferior en Win32, por lo que todavía
utiliza las rutinas de descriptor de archivos numéricos del compilador de C. Hay un
capa "win32" nativa experimental, que se espera que se mejore y debería
eventualmente se convertirá en el predeterminado en Win32.

La variable de entorno PERLIO se ignora por completo cuando se ejecuta Perl en
modo de mancha.

PERLIO_DEBUG
Si se establece en el nombre de un archivo o dispositivo, ciertas operaciones del subsistema PerlIO
se registrará en ese archivo, que se abre en modo anexar. Los usos típicos son
en Unix:

% env PERLIO_DEBUG = / dev / tty secuencia de comandos perl ...

y en Win32, aproximadamente el equivalente:

> establecer PERLIO_DEBUG = CON
script de perl ...

Esta funcionalidad está deshabilitada para scripts setuid y para scripts que se ejecutan con -T.

PERLLIB Una lista de directorios en los que buscar archivos de la biblioteca Perl antes de buscar
en la biblioteca estándar y el directorio actual. Si se define PERL5LIB,
PERLLIB no se utiliza.

La variable de entorno PERLLIB se ignora por completo cuando se ejecuta Perl en
modo de mancha.

PERL5DB El comando utilizado para cargar el código del depurador. El valor predeterminado es:

COMIENZO {require "perl5db.pl"}

La variable de entorno PERL5DB solo se usa cuando Perl se inicia con un
-d switch.

PERL5DB_THREADED
Si se establece en un valor verdadero, indica al depurador que el código que se está depurando
utiliza hilos.

PERL5SHELL (específico para el puerto Win32)
Solo en puertos Win32, se puede configurar en un shell alternativo que Perl debe usar
internamente para ejecutar comandos "backtick" o sistema(). El valor predeterminado es "cmd.exe
/ x / d / c "en WindowsNT y" command.com / c "en Windows95. El valor es
considerados separados por espacios. Anteponga a cualquier personaje que necesite ser protegido,
como un espacio o barra invertida, con otra barra invertida.

Tenga en cuenta que Perl no usa COMSPEC para este propósito porque COMSPEC tiene un alto
grado de variabilidad entre los usuarios, lo que genera problemas de portabilidad. Además,
Perl puede usar un shell que puede no ser apto para uso interactivo y configurar
COMSPEC a tal caparazón puede interferir con el funcionamiento adecuado de otros
programas (que generalmente buscan en COMSPEC para encontrar un shell adecuado para interactivos
utilizar).

Antes de Perl 5.10.0 y 5.8.8, PERL5SHELL no se verificaba cuando se ejecutaba
comandos externos. Se recomienda que establezca (o elimine) explícitamente
$ ENV {PERL5SHELL} cuando se ejecuta en modo de corrupción en Windows.

PERL_ALLOW_NON_IFS_LSP (específico del puerto Win32)
Establézcalo en 1 para permitir el uso de LSP no compatibles con IFS (servicio en capas
Proveedores). Perl normalmente busca un LSP compatible con IFS porque es
necesario para su emulación de sockets de Windows como identificadores de archivos reales. Sin embargo,
esto puede causar problemas si tiene un firewall como McAfee Guardian, cual
requiere que todas las aplicaciones usen su LSP pero que no es compatible con IFS,
porque claramente Perl normalmente evitará el uso de este tipo de LSP.

Establecer esta variable de entorno en 1 significa que Perl simplemente usará el
primer LSP adecuado enumerado en el catálogo, que mantiene McAfee Guardian
feliz, y en ese caso particular, Perl también funciona porque McAfee
GuardianLSP en realidad reproduce otros juegos que permiten aplicaciones que requieren
Compatibilidad IFS para trabajar.

PERL_DEBUG_MSTATS
Relevante solo si Perl está compilado con el "malloc" incluido con Perl
distribución; es decir, si "perl -V: d_mymalloc" es "definir".

Si se establece, esto descarga las estadísticas de memoria después de la ejecución. Si se establece en un
entero mayor que uno, también descarga las estadísticas de memoria después de la compilación.

PERL_DESTRUCT_LEVEL
Relevante solo si su ejecutable Perl fue construido con -DEPURACIÓN, esta
controla el comportamiento de destrucción global de objetos y otras referencias.
Consulte "PERL_DESTRUCT_LEVEL" en perlhacktips para obtener más información.

PERL_DL_NONLAZY
Establecer en "1" para que Perl se resuelva all símbolos indefinidos cuando carga una dinámica
Biblioteca. El comportamiento predeterminado es resolver símbolos cuando se utilizan.
Establecer esta variable es útil durante la prueba de extensiones, ya que asegura
que obtiene un error en los nombres de funciones mal escritos, incluso si el conjunto de pruebas
no los llama.

PERL_ENCODIFICACIÓN
Si utiliza el pragma "usar codificación" sin un nombre de codificación explícito, el
Se consulta la variable de entorno PERL_ENCODING para obtener un nombre de codificación.

PERL_HASH_SEED
(Desde Perl 5.8.1, nueva semántica en Perl 5.18.0) Se usa para anular la
Aleatorización de la función hash interna de Perl. El valor se expresa en
hexadecimal y puede incluir un 0x inicial. Los patrones truncados se tratan como
aunque tienen el sufijo suficientes ceros según sea necesario.

Si se proporciona la opción y NO se establece "PERL_PERTURB_KEYS", entonces un valor de
'0' implica "PERL_PERTURB_KEYS = 0" y cualquier otro valor implica
"PERL_PERTURB_KEYS = 2".

POR FAVOR NOTA: El sistema hachís dispersores is sensible información. Los hashes se asignan aleatoriamente a
protege contra ataques locales y remotos contra el código Perl. Por manualmente
Al poner una semilla, esta protección puede perderse total o parcialmente.

Consulte "Ataques de complejidad algorítmica" en perlsec, "PERL_PERTURB_KEYS" y
"PERL_HASH_SEED_DEBUG" para obtener más información.

PERL_PERTURB_TECLAS
(Desde Perl 5.18.0) Si se establece en "0" o "NO", las teclas de desplazamiento serán
repetible de ejecución a ejecución para el mismo PERL_HASH_SEED. Inserción en un hash
no cambiará el orden, excepto para proporcionar más espacio en el hash. Cuándo
combinado con la configuración PERL_HASH_SEED, este modo es lo más cercano a pre 5.18
comportamiento que pueda obtener.

Cuando se establece en "1" o "ALEATORIO", las teclas de desplazamiento serán aleatorias. Cada
El momento en que se inserta un hash en el orden de la clave cambiará de forma aleatoria.
Es posible que el orden no se pueda repetir en la siguiente ejecución del programa, incluso si el
Se ha especificado PERL_HASH_SEED. Este es el modo predeterminado de perl.

Cuando se establece en "2" o "DETERMINISTIC", la inserción de claves en un hash provocará
el orden de las teclas para cambiar, pero de una manera que sea repetible desde la ejecución del programa hasta
ejecución del programa.

NOTA: El uso de esta opción se considera inseguro y está destinado solo para
depurar el comportamiento no determinista en la función hash de Perl. No lo use en
producción.

Consulte "Ataques de complejidad algorítmica" en perlsec y "PERL_HASH_SEED" y
"PERL_HASH_SEED_DEBUG" para obtener más información. Puede obtener y configurar la clave
máscara transversal para un hash específico mediante el uso de "hash_traversal_mask ()"
función de Hash :: Util.

PERL_HASH_SEED_DEBUG
(Desde Perl 5.8.1.) Establezca en "1" para mostrar (a STDERR) información sobre el
función hash, semilla y qué tipo de aleatorización transversal de clave está en efecto
al inicio de la ejecución. Esto, combinado con "PERL_HASH_SEED" y
"PERL_PERTURB_KEYS" está destinado a ayudar a depurar el comportamiento no determinista
causado por la aleatorización de hash.

Nota que cualquier información sobre la función hash, especialmente la semilla hash es
sensible información: al conocerlo, se puede crear un ataque de denegación de servicio
contra el código Perl, incluso de forma remota; ver "Ataques de complejidad algorítmica" en
perlsec para obtener más información. Do no revelar de la forma más hachís dispersores a la gente que
no necesito saberlo. Consulte también "hash_seed ()" y "key_traversal_mask ()" en
Hash :: Util.

Un resultado de ejemplo podría ser:

HASH_FUNCTION = ONE_AT_A_TIME_HARD HASH_SEED = 0x652e9b9349a7a032 PERTURB_KEYS = 1 (ALEATORIO)

PERL_MEM_LOG
Si su Perl se configuró con -Accflags = -DPERL_MEM_LOG, configurando el
La variable de entorno "PERL_MEM_LOG" habilita el registro de mensajes de depuración. El valor
tiene la forma "número> [m] [s] [t] ", dónde "número" es el número de descriptor de archivo
desea escribir (2 es el valor predeterminado), y la combinación de letras especifica
que desea información sobre (m) emory y / o (s) v, opcionalmente con
(t) sellos. Por ejemplo, "PERL_MEM_LOG = 1mst" registra toda la información en stdout.
Puede escribir en otros descriptores de archivos abiertos de varias formas:

$ 3> foo3 PERL_MEM_LOG = 3 millones de perl ...

PERL_ROOT (específico del puerto VMS)
Un nombre lógico arraigado oculto en la traducción que contiene Perl y el
dispositivo para la ruta @INC solo en VMS. Otros nombres lógicos que afectan a Perl en
Los VMS incluyen PERLSHR, PERL_ENV_TABLES y SYS $ TIMEZONE_DIFFERENTIAL, pero son
opcional y discutido más en perlvms y en LÉAME.vms en la fuente de Perl
distribución.

PERL_SIGNALS
Disponible en Perls 5.8.1 y posterior. Si se establece en "inseguro", la versión anterior a Perl-5.8.0
el comportamiento de la señal (que es inmediato pero inseguro) se restablece. Si se establece en
"seguro", entonces se utilizan señales seguras (pero diferidas). Consulte "Señales diferidas
(Señales seguras) "en perlipc.

PERL_UNICODE
Equivalente a la -C conmutador de línea de comandos. Tenga en cuenta que esto no es un booleano
variable. Establecer esto en "1" no es la forma correcta de "habilitar Unicode"
(lo que sea que eso signifique). Sin embargo, puede usar "0" para "deshabilitar Unicode" (o
alternativamente, desactive PERL_UNICODE en su shell antes de iniciar Perl). Ver el
descripción del -C cambiar para obtener más información.

SYS $ LOGIN (específico del puerto VMS)
Se usa si chdir no tiene argumento y HOME y LOGDIR no están configurados.

Perl también tiene variables de entorno que controlan cómo Perl maneja los datos específicos de
lenguajes naturales particulares; ver perllocale.

Perl y sus diversos módulos y componentes, incluidos sus marcos de prueba, a veces pueden
hacer uso de algunas otras variables de entorno. Algunos de estos son específicos de un
plataforma particular. Consulte la documentación del módulo correspondiente y cualquier
documentación para su plataforma (como perlsolaris, perllinux, perlmacosx, perlwin32, etc.)
para las variables propias de esas situaciones específicas.

Perl hace que todas las variables de entorno estén disponibles para el programa que se está ejecutando y pasa
estos junto con cualquier proceso hijo que inicie. Sin embargo, los programas que ejecutan setuid servirían
Bueno, ejecutar las siguientes líneas antes de hacer cualquier otra cosa, solo para mantener a la gente
honesto:

$ ENV {RUTA} = "/compartimiento:/ usr / bin"; # o lo que necesites
$ ENV {SHELL} = "/ Bin / sh"si existe $ ENV {SHELL};
eliminar @ENV {qw (IFS CDPATH ENV BASH_ENV)};

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