Este es el comando perlfunc que se puede ejecutar en el proveedor de alojamiento gratuito de OnWorks utilizando una de nuestras múltiples estaciones de trabajo en línea gratuitas, como Ubuntu Online, Fedora Online, emulador en línea de Windows o emulador en línea de MAC OS.
PROGRAMA:
NOMBRE
perlfunc - Funciones integradas de Perl
DESCRIPCIÓN
Las funciones de esta sección pueden servir como términos en una expresión. Caen en dos
categorías principales: operadores de lista y operadores unarios con nombre. Estos difieren en su
relación de precedencia con una coma siguiente. (Consulte la tabla de precedencia en perlop).
Los operadores de lista toman más de un argumento, mientras que los operadores unarios nunca pueden tomar más de
un argumento. Por lo tanto, una coma termina el argumento de un operador unario, pero simplemente
separa los argumentos de un operador de lista. Un operador unario generalmente proporciona escalar
contexto a su argumento, mientras que un operador de lista puede proporcionar contextos escalares o de lista
por sus argumentos. Si hace ambas cosas, los argumentos escalares van primero y los argumentos de la lista siguen,
y solo puede haber uno de esos argumentos de lista. Por ejemplo, empalme() tiene tres
argumentos escalares seguidos de una lista, mientras que gethostbyname () tiene cuatro argumentos escalares.
En las descripciones de sintaxis que siguen, enumere los operadores que esperan una lista (y proporcione
contexto de lista para los elementos de la lista) se muestran con LIST como argumento. Tal lista
puede consistir en cualquier combinación de argumentos escalares o valores de lista; los valores de la lista serán
incluido en la lista como si cada elemento individual estuviera interpolado en ese punto de la
list, formando un valor de lista unidimensional más largo. Las comas deben separar literal
elementos de la LISTA.
Cualquier función en la lista a continuación puede usarse con o sin paréntesis alrededor de su
argumentos. (Las descripciones de sintaxis omiten los paréntesis). Si usa paréntesis, la
Una regla simple pero a veces sorprendente es la siguiente: miradas como una función, por lo tanto is
una función, y la precedencia no importa. De lo contrario, es un operador de lista o unario.
operador, y la precedencia sí importa. Espacio en blanco entre la función y la izquierda
los paréntesis no cuentan, por lo que a veces debes tener cuidado:
imprimir 1 + 2 + 4; # Impresiones 7.
imprimir (1 + 2) + 4; # Impresiones 3.
imprimir (1 + 2) +4; # ¡También imprime 3!
imprimir + (1 + 2) +4; # Impresiones 7.
imprimir ((1 + 2) +4); # Impresiones 7.
Si ejecuta Perl con el -w cambiarlo puede advertirle sobre esto. Por ejemplo, el tercero
la línea de arriba produce:
print (...) interpretado como función en - línea 1.
Uso inútil de la suma de enteros en contexto vacío en la línea 1.
Algunas funciones no toman ningún argumento y, por lo tanto, no funcionan como unario ni como lista.
operadores. Estos incluyen funciones como "tiempo" y "endpwent". Por ejemplo,
"tiempo + 86_400" siempre significa "tiempo () + 86_400".
Para las funciones que se pueden utilizar en un contexto escalar o de lista, la falla no abortiva es
generalmente indicado en contexto escalar al devolver el valor indefinido, y en la lista
contexto devolviendo la lista vacía.
Recuerde la siguiente regla importante: hay no gobernar que relaciona el comportamiento de un
expresión en contexto de lista a su comportamiento en contexto escalar, o viceversa. Podría hacer
dos cosas totalmente diferentes. Cada operador y función decide qué tipo de valor
Sería más apropiado volver en un contexto escalar. Algunos operadores devuelven la longitud
de la lista que se habría devuelto en el contexto de la lista. Algunos operadores devuelven el
primer valor de la lista. Algunos operadores devuelven el último valor de la lista. Algunos
los operadores devuelven un recuento de operaciones exitosas. En general, hacen lo que quieres,
a menos que quieras consistencia.
Una matriz con nombre en contexto escalar es bastante diferente de lo que parecería a primera vista
para ser una lista en contexto escalar. No puede hacer que una lista como "(1,2,3)" esté en escalar
contexto, porque el compilador conoce el contexto en tiempo de compilación. Generaría el
operador de coma escalar allí, no la versión de construcción de lista de la coma. Eso significa
Para empezar, nunca fue una lista.
En general, las funciones en Perl que sirven como envoltorios para llamadas al sistema ("syscalls") del
mismo nombre (como chown(2) tenedor(2) cerrado(2), etc.) devuelven verdadero cuando tienen éxito y
"undef" en caso contrario, como se suele mencionar en las descripciones siguientes. Esto es diferente
de las interfaces C, que devuelven "-1" en caso de falla. Las excepciones a esta regla incluyen
"espera", "waitpid" y "syscall". Las llamadas al sistema también establecen el $! variable en
falla. Otras funciones no, excepto accidentalmente.
Los módulos de extensión también pueden conectarse al analizador de Perl para definir nuevos tipos de
expresión. Estos pueden parecer funciones, pero también pueden verse completamente diferentes. los
la sintaxis que sigue a la palabra clave está definida completamente por la extensión. Si eres un
implementador, consulte "PL_keyword_plugin" en perlapi para conocer el mecanismo. Si está usando tal
un módulo, consulte la documentación del módulo para obtener detalles de la sintaxis que define.
Perl Funciones by Categoría
Aquí están las funciones de Perl (incluidas las cosas que parecen funciones, como algunas palabras clave
y operadores nombrados) ordenados por categoría. Algunas funciones aparecen en más de un lugar.
Funciones para SCALAR o cadenas
"chomp", "chop", "chr", "crypt", "fc", "hex", "index", "lc", "lcfirst", "length",
"oct", "ord", "pack", "q //", "qq //", "reverse", "rindex", "sprintf", "substr",
"tr ///", "uc", "ucfirst", "y ///"
"fc" está disponible solo si la función "fc" está habilitada o si tiene el prefijo
"CENTRO::". La función "fc" se habilita automáticamente con un "use v5.16" (o superior)
declaración en el ámbito actual.
Expresiones regulares y coincidencia de patrones
"m //", "pos", "qr //", "quotemeta", "s ///", "dividir", "estudiar"
Funciones numéricas
"abs", "atan2", "cos", "exp", "hex", "int", "log", "oct", "rand", "sin", "sqrt",
"srand"
Funciones para @ARRAYs reales
"each", "keys", "pop", "push", "shift", "splice", "unshift", "values"
Funciones para datos de lista
"grep", "unirse", "mapa", "qw //", "invertir", "ordenar", "desempaquetar"
Funciones para% HASHes reales
"eliminar", "cada", "existe", "claves", "valores"
Funciones de entrada y salida
"binmode", "close", "closedir", "dbmclose", "dbmopen", "die", "eof", "fileno",
"flock", "formato", "getc", "print", "printf", "read", "readdir", "readline"
"rewinddir", "say", "seek", "seekdir", "select", "syscall", "sysread", "sysseek",
"syswrite", "tell", "telldir", "truncar", "advertir", "escribir"
"decir" solo está disponible si la función "decir" está habilitada o si tiene el prefijo
"CENTRO::". La función "decir" se habilita automáticamente con un "usar v5.10" (o superior)
declaración en el ámbito actual.
Funciones para registros o datos de longitud fija
"empaquetar", "leer", "syscall", "sysread", "sysseek", "syswrite", "desempaquetar", "vec"
Funciones para identificadores de archivos, archivos o directorios
"-X", "chdir", "chmod", "chown", "chroot", "fcntl", "glob", "ioctl", "link", "lstat",
"mkdir", "open", "opendir", "readlink", "renombrar", "rmdir", "stat", "symlink",
"sysopen", "umask", "unlink", "utime"
Palabras clave relacionadas con el flujo de control de su programa Perl
"romper", "llamador", "continuar", "morir", "hacer", "volcar", "eval", "evalbytes" "salir",
"__FILE__", "goto", "last", "__LINE__", "next", "__PACKAGE__", "rehacer", "return",
"sub", "__SUB__", "wantarray"
"descanso" solo está disponible si habilita la función "interruptor" experimental o utiliza la
Prefijo "CORE ::". La función "cambiar" también habilita el "predeterminado", "dado" y "cuándo"
declaraciones, que están documentadas en "Declaraciones de cambio" en perlsyn. El interruptor"
La función se habilita automáticamente con una declaración "use v5.10" (o superior) en el
alcance actual. En Perl v5.14 y anteriores, "continuar" requería la función "cambiar",
como las otras palabras clave.
"evalbytes" solo está disponible con la función "evalbytes" (ver función) o si
con el prefijo "CORE ::". "__SUB__" solo está disponible con la función "current_sub" o
si tiene el prefijo "CORE ::". Tanto las funciones "evalbytes" como "current_sub" son
habilitado automáticamente con una declaración "use v5.16" (o superior) en el alcance actual.
Palabras clave relacionadas con el alcance
"llamador", "importación", "local", "mi", "nuestro", "paquete", "estado", "uso"
"estado" está disponible solo si la función "estado" está habilitada o si tiene el prefijo
"CENTRO::". La función "estado" se habilita automáticamente con un "uso v5.10" (o superior)
declaración en el ámbito actual.
Funciones misceláneas
"definido", "línea de formulario", "bloqueo", "prototipo", "restablecer", "escalar", "indef"
Funciones para procesos y grupos de procesos
"alarma", "exec", "fork", "getpgrp", "getppid", "getpriority", "kill", "pipe", "qx //",
"readpipe", "setpgrp", "setpriority", "sleep", "system", "times", "wait", "waitpid"
Palabras clave relacionadas con los módulos de Perl
"hacer", "importar", "no", "paquete", "requerir", "usar"
Palabras clave relacionadas con clases y orientación a objetos
"bendecir", "dbmclose", "dbmopen", "paquete", "ref", "atar", "atar", "desatar", "usar"
Funciones de toma de bajo nivel
"accept", "bind", "connect", "getpeername", "getsockname", "getsockopt", "listen",
"recv", "enviar", "setsockopt", "apagar", "socket", "socketpair"
Funciones de comunicación entre procesos de System V
"msgctl", "msgget", "msgrcv", "msgsnd", "semctl", "semget", "semop", "shmctl",
"shmget", "shmread", "shmwrite"
Obteniendo información de usuarios y grupos
"endgrent", "endhostent", "endnetent", "endpwent", "getgrent", "getgrgid", "getgrnam",
"getlogin", "getpwent", "getpwnam", "getpwuid", "setgrent", "setpwent"
Obteniendo información de la red
"endprotoent", "endprotoent", "gethostbyaddr", "gethostbyname", "gethostent",
"getnetbyaddr", "getnetbyname", "getnetent", "getprotobyname", "getprotobynumber",
"getprotoent", "getservbyname", "getservbyport", "getserv", "sethostent",
"setnetent", "setprotoent", "setservent"
Funciones relacionadas con el tiempo
"gmtime", "localtime", "time", "times"
Palabras clave sin función
"y", "AUTOLOAD", "BEGIN", "CHECK", "cmp", "CORE", "__DATA__", "default", "DESTROY",
"else", "elseif", "elsif", "FIN", "__END__", "eq", "para", "foreach", "ge", "dado",
"gt", "si", "INIT", "le", "lt", "ne", "no", "o", "UNITCHECK", "a menos que", "hasta",
"cuando", "mientras", "x", "xor"
Portabilidad
Perl nació en Unix y, por lo tanto, puede acceder a todas las llamadas comunes al sistema Unix. En no Unix
entornos, es posible que la funcionalidad de algunas llamadas al sistema Unix no esté disponible o
de la funcionalidad disponible puede diferir ligeramente. Las funciones de Perl afectadas por este
son:
"-X", "binmode", "chmod", "chown", "chroot", "crypt", "dbmclose", "dbmopen", "dump",
"endgrent", "endhostent", "endnetent", "endprotoent", "endpwent", "endservent", "exec",
"fcntl", "rebaño", "fork", "getgrent", "getgrgid", "gethostbyname", "gethostent",
"getlogin", "getnetbyaddr", "getnetbyname", "getnetent", "getppid", "getpgrp",
"getpriority", "getprotobynumber", "getprotoent", "getpwent", "getpwnam", "getpwuid",
"getservbyport", "getservent", "getsockopt", "glob", "ioctl", "kill", "link", "lstat",
"msgctl", "msgget", "msgrcv", "msgsnd", "abrir", "canalizar", "readlink", "renombrar", "seleccionar",
"semctl", "semget", "semop", "setgrent", "sethostent", "setnetent", "setpgrp",
"setpriority", "setprotoent", "setpwent", "setservent", "setsockopt", "shmctl", "shmget",
"shmread", "shmwrite", "socket", "socketpair", "stat", "symlink", "syscall", "sysopen",
"sistema", "tiempos", "truncar", "umask", "desvincular", "utime", "esperar", "waitpid"
Para obtener más información sobre la portabilidad de estas funciones, consulte perlport y otras
documentación específica de la plataforma disponible.
Alfabético Publicaciones of Perl Funciones
-X IDENTIFICADOR DE ARCHIVO
-X EXPR
-X MANILLAR
-Prueba de archivo XA, donde X es una de las letras que se enumeran a continuación. Este operador unario toma
un argumento, ya sea un nombre de archivo, un identificador de archivo o un identificador de directorio, y prueba el
asociado para ver si algo es cierto al respecto. Si se omite el argumento,
prueba $ _, excepto "-t", que prueba STDIN. A menos que se documente lo contrario, vuelve
1 para verdadero y '' para falso. Si el archivo no existe o no se puede examinar,
devuelve "undef" y establece $! (errno). A pesar de los nombres divertidos, la precedencia es la misma.
como cualquier otro operador unario nombrado. El operador puede ser cualquiera de:
-r El archivo es legible por uid / gid efectivo.
-w El archivo se puede escribir mediante uid / gid efectivo.
-x El archivo es ejecutable por uid / gid efectivo.
-o El archivo es propiedad de Effective uid.
-R El archivo es legible por uid / gid real.
-W El archivo se puede escribir mediante uid / gid real.
-X El archivo es ejecutable por uid / gid real.
-O File es propiedad de uid real.
-e El archivo existe.
-z El archivo tiene tamaño cero (está vacío).
-s El archivo tiene un tamaño distinto de cero (devuelve el tamaño en bytes).
-f El archivo es un archivo sin formato.
-d El archivo es un directorio.
-l El archivo es un enlace simbólico (falso si los enlaces simbólicos no lo son
compatible con el sistema de archivos).
-p El archivo es una tubería con nombre (FIFO) o Filehandle es una tubería.
-S File es un socket.
-b Archivo es un archivo especial de bloque.
-c Archivo es un archivo especial de caracteres.
-t Filehandle se abre en un tty.
-u El archivo tiene el bit setuid establecido.
-g El archivo tiene establecido el bit gid establecido.
-k El archivo tiene un bit adhesivo establecido.
-T File es un archivo de texto ASCII o UTF-8 (suposición heurística).
-B File es un archivo "binario" (opuesto a -T).
-M Hora de inicio del script menos tiempo de modificación del archivo, en días.
-A Igual para el tiempo de acceso.
-C Lo mismo para el tiempo de cambio de inodo (Unix, puede diferir para otros
plataformas)
Ejemplo:
while (<>) {
masticar
siguiente a menos que -f $ _; # ignorar especiales
# ...
}
Tenga en cuenta que "-s / a / b /" no realiza una sustitución negada. Decir "-exp ($ foo)" todavía
Sin embargo, funciona como se esperaba: solo las letras individuales que siguen a un menos se interpretan como
pruebas de archivo.
Estos operadores están exentos de "parece una regla de función" descrita anteriormente.
Es decir, un paréntesis de apertura después del operador no afecta la cantidad de
El siguiente código constituye el argumento. Coloque los paréntesis de apertura antes del
operador para separarlo del código que sigue (esto se aplica solo a operadores con
mayor precedencia que los operadores unarios, por supuesto):
-s ($ archivo) + 1024 # probablemente incorrecto; igual que -s ($ archivo + 1024)
(-s $ archivo) + 1024 # correcto
La interpretación de los operadores de permisos de archivos "-r", "-R", "-w", "-W", "-x" y
"-X" se basa de forma predeterminada únicamente en el modo del archivo y los uids y gids del
usuario. Puede haber otras razones por las que no pueda leer, escribir o ejecutar el archivo:
por ejemplo, controles de acceso al sistema de archivos de red, ACL (listas de control de acceso), solo lectura
sistemas de archivos y formatos ejecutables no reconocidos. Tenga en cuenta que el uso de estos seis
operadores específicos para verificar si alguna operación es posible suele ser un error,
porque puede estar abierto a condiciones de carrera.
También tenga en cuenta que, para el superusuario en los sistemas de archivos locales, "-r", "-R", "-w" y
Las pruebas "-W" siempre devuelven 1, y "-x" y "-X" devuelven 1 si se establece algún bit de ejecución en
el modo. Los scripts ejecutados por el superusuario pueden necesitar stat () para determinar el
modo real del archivo, o establezca temporalmente su uid efectivo en otra cosa.
Si está utilizando ACL, existe un pragma llamado "filetest" que puede producir más
resultados precisos que los desnudos stat () bits de modo. Cuando esté en "use filetest 'access'"
las pruebas de archivo mencionadas anteriormente prueban si el permiso se puede (no) otorgar usando
de la forma más de la máquina(2) familia de llamadas al sistema. También tenga en cuenta que "-x" y "-X" pueden debajo de este
pragma devuelve verdadero incluso si no hay ningún bit de permiso de ejecución establecido (ni ningún extra
ejecutar permisos ACL). Esta extrañeza se debe a las llamadas al sistema subyacente '
definiciones. Tenga en cuenta también que, debido a la implementación de "use filetest 'access'",
el identificador de archivo especial "_" no almacenará en caché los resultados de las pruebas de archivo cuando este pragma
está en efecto. Lea la documentación del pragma "filetest" para obtener más información.
Los interruptores "-T" y "-B" funcionan de la siguiente manera. El primer bloque más o menos del archivo es
examinado para ver si es UTF-8 válido que incluye caracteres no ASCII. Si es asi
un archivo "-T". De lo contrario, esa misma parte del archivo se examina en busca de caracteres extraños.
como códigos de control extraños o caracteres con el bit alto establecido. Si más de un
el tercero de los caracteres es extraño, es un archivo "-B"; de lo contrario, es un archivo "-T".
Además, cualquier archivo que contenga un byte cero en la parte examinada se considera un archivo binario.
expediente. (Si se ejecuta dentro del alcance de una configuración regional de uso que incluye "LC_CTYPE", impar
los caracteres son cualquier cosa que no sea imprimible ni espacio en la configuración regional actual).
"-T" o "-B" se utiliza en un identificador de archivo, el búfer de E / S actual se examina en lugar de
el primer bloque. Tanto "-T" como "-B" devuelven verdadero en un archivo vacío o en un archivo en EOF
al probar un identificador de archivo. Porque tienes que leer un archivo para hacer la prueba "-T", en
la mayoría de las veces desea utilizar una "-f" contra el archivo primero, como en "siguiente a menos que -f
$ archivo && -T $ archivo ".
Si alguna de las pruebas de archivo (o el operador "stat" o "lstat") recibe el
identificador de archivo especial que consta de un subrayado solitario, luego la estructura estadística del
Se utiliza la prueba de archivo anterior (u operador estadístico), lo que guarda una llamada al sistema. (Esto no
trabajar con "-t", y debes recordar que lstat () y "-l" dejan valores en el
estructura de estadísticas para el enlace simbólico, no el archivo real.) (Además, si el búfer de estadísticas
se completó con una llamada "lstat", "-T" y "-B" lo restablecerán con los resultados de "stat
_"). Ejemplo:
imprimir "Puedo hacerlo. \ n" if -r $ a || -w _ || -X _;
stat ($ nombre de archivo);
imprimir "Legible \ n" if -r _;
imprime "Escribe \ n" if -w _;
imprimir "Ejecutable \ n" if -x _;
imprimir "Setuid \ n" if -u _;
imprimir "Setgid \ n" if -g _;
imprimir "Pegajoso \ n" if -k _;
imprimir "Texto \ n" si -T _;
imprimir "Binario \ n" si -B _;
A partir de Perl 5.10.0, como una forma de azúcar puramente sintáctica, puede apilar archivos de prueba
operadores, de manera que "-f -w -x $ archivo" es equivalente a "-x $ archivo && -w _ && -f _".
(Esta es solo una sintaxis elegante: si usa el valor de retorno de "-f $ file" como argumento
a otro operador de prueba de archivos, no ocurrirá ninguna magia especial).
Problemas de portabilidad: "-X" en perlport.
Para evitar confundir a los posibles usuarios de su código con misteriosos errores de sintaxis, coloque
algo como esto en la parte superior de su secuencia de comandos:
utilizar 5.010; # para que las operaciones de prueba de archivos puedan apilarse
abs VALOR
abs Devuelve el valor absoluto de su argumento. Si se omite VALUE, usa $ _.
aceptar NEWSOCKET, GENERICSOCKET
Acepta una conexión de enchufe entrante, al igual que aceptar(2) lo hace. Devuelve el empaquetado
dirección si tuvo éxito, falso en caso contrario. Consulte el ejemplo en "Sockets: cliente / servidor
Comunicación "en perlipc.
En los sistemas que admiten un indicador de cierre en el ejecutivo en los archivos, el indicador se establecerá para el
descriptor de archivo recién abierto, según lo determinado por el valor de $ ^ F. Ver "$ ^ F" en
perlvar.
SEGUNDOS de alarma
alarma
Hace arreglos para que se entregue un SIGALRM a este proceso después del número especificado de
Han transcurrido los segundos del reloj de pared. Si no se especifica SECONDS, el valor almacenado en $ _ es
usó. (En algunas máquinas, desafortunadamente, el tiempo transcurrido puede ser hasta un segundo menos
o más de lo que especificó debido a la forma en que se cuentan los segundos y la programación del proceso
puede retrasar aún más la entrega de la señal).
Solo un temporizador puede estar contando a la vez. Cada llamada desactiva el temporizador anterior y un
Se puede proporcionar un argumento de 0 para cancelar el temporizador anterior sin iniciar uno nuevo.
El valor devuelto es la cantidad de tiempo restante del temporizador anterior.
Para retrasos de granularidad más fina que un segundo, el módulo Time :: HiRes (de CPAN,
y a partir de Perl 5.8 parte de la distribución estándar) proporciona ualarm (). Usted
también puede usar la versión de cuatro argumentos de Perl de Seleccione() dejando los tres primeros
argumentos no definidos, o puede utilizar la interfaz "syscall" para acceder
temporizador(2) si su sistema lo admite. Consulte perlfaq8 para obtener más detalles.
Por lo general, es un error mezclar las llamadas de "alarma" y "dormir", porque "dormir" puede ser
implementado internamente en su sistema con "alarma".
Si desea utilizar "alarma" para agotar el tiempo de espera de una llamada al sistema, debe utilizar un "eval" / "die"
par. ¡No puede confiar en la alarma que hace que la llamada al sistema falle con $! ajustado a
"EINTR" porque Perl configura controladores de señales para reiniciar las llamadas al sistema en algunos sistemas.
Usar "eval" / "die" siempre funciona, modulo las advertencias dadas en "Signals" en perlipc.
evaluar {
local $ SIG {ALRM} = sub {morir "alarma \ n"}; # NB: \ n requerido
alarma $ tiempo de espera;
$ nread = sysread SOCKET, $ buffer, $ size;
alarma 0;
};
si ($ @) {
morir a menos que $ @ eq "alarma \ n"; # propagar errores inesperados
# desconectado
}
else {
# no
}
Para obtener más información, consulte perlipc.
Problemas de portabilidad: "alarma" en perlport.
atan2 Y, X
Devuelve el arcotangente de Y / X en el rango -PI a PI.
Para la operación tangente, puede usar la función "Math :: Trig :: tan", o usar la
relación familiar:
sub tan {sin ($ _ [0]) / cos ($ _ [0])}
El valor de retorno de "atan2 (0,0)" está definido por la implementación; consulta tu atan2(3)
página de manual para obtener más información.
Problemas de portabilidad: "atan2" en perlport.
enlazar SOCKET, NAME
Vincula una dirección de red a un socket, al igual que se unen(2) lo hace. Devuelve verdadero si
tuvo éxito, falso en caso contrario. NOMBRE debe ser una dirección empaquetada del tipo apropiado
para el enchufe. Consulte los ejemplos en "Sockets: comunicación cliente / servidor" en
perlipc.
binmode IDENTIFICADOR DE ARCHIVO, CAPA
binmode IDENTIFICADOR DE ARCHIVO
Organiza que FILEHANDLE se lea o escriba en modo "binario" o "texto" en los sistemas
donde las bibliotecas en tiempo de ejecución distinguen entre archivos binarios y de texto. Si FILEHANDLE
es una expresión, el valor se toma como el nombre del identificador de archivo. Devuelve verdadero en
éxito, de lo contrario, devuelve "undef" y establece $! (errno).
En algunos sistemas (en general, sistemas basados en DOS y Windows) binmode () es necesario
cuando no está trabajando con un archivo de texto. En aras de la portabilidad, es una buena
idea de usarlo siempre cuando sea apropiado, y nunca usarlo cuando no sea apropiado.
Además, las personas pueden configurar su E / S para que sea Unicode codificado en UTF8 por defecto, no bytes.
En otras palabras: independientemente de la plataforma, utilice binmode () en datos binarios, como imágenes, para
ejemplo.
Si LAYER está presente, es una sola cadena, pero puede contener varias directivas. los
las directivas alteran el comportamiento del identificador de archivo. Cuando LAYER está presente, usando
binmode en un archivo de texto tiene sentido.
Si LAYER se omite o se especifica como ": raw", el identificador de archivo se hace adecuado para pasar
datos binarios. Esto incluye desactivar la posible traducción CRLF y marcarla como
bytes (a diferencia de los caracteres Unicode). Tenga en cuenta que, a pesar de lo que pueda estar implícito en
"Programación Perl " (The Camel, 3.ª edición) o en cualquier otro lugar, ": raw" es no simplemente el
inverso de ": crlf". Otras capas que afectarían la naturaleza binaria de la transmisión
están also discapacitado. Vea PerlIO, perlrun y la discusión sobre PERLIO
Variable ambiental.
Los ": bytes", ": crlf", ": utf8" y cualquier otra directiva de la forma ": ...", son
llamado E / S ponedoras. El pragma "abierto" se puede utilizar para establecer capas de E / S predeterminadas.
Ver abierto.
El CAPA parámetro of de la forma más binmode () función is descrito as "DISCIPLINA" in
"Programación Perla, 3rd Edición". Sin embargo, desde de la forma más publicación of este vídeo libro, by muchos
known as "Camello III ", de la forma más consenso of de la forma más nombrando of este vídeo a la fatiga tiene emocionado obtenidos de
"disciplina" a "capa". Todo documentación of este vídeo versión of Perl por lo tanto se refiere
a "capas" más bien than a "disciplinas". Ahora back a de la forma más regularly programada
documentación...
Para marcar FILEHANDLE como UTF-8, use ": utf8" o ": codificación (UTF-8)". ": utf8" solo marcas
los datos como UTF-8 sin más verificación, mientras que ": codificación (UTF-8)" verifica los datos
por ser realmente válido UTF-8. Se pueden encontrar más detalles en PerlIO :: encoding.
En general, un software de chat en vivo es ideal para todas las organizaciones, ya que permite conocer de cerca a la audiencia, identificar los problemas que están experimentando y resolverlos para aumentar la lealtad a la marca, la credibilidad y las valoraciones de satisfacción. binmode () debería ser llamado después open() pero antes de que se realice cualquier E / S en el
filehandle. Vocación binmode () normalmente vacía cualquier dato de salida almacenado en búfer pendiente (y
quizás datos de entrada pendientes) en el mango. Una excepción a esto es la ": codificación"
capa que cambia la codificación de caracteres predeterminada del identificador; ver "abierto". los
La capa ": encoding" a veces debe llamarse en mitad de la transmisión, y no elimina la
Arroyo. El ": encoding" también empuja implícitamente sobre sí mismo la capa ": utf8"
porque internamente Perl opera con caracteres Unicode codificados en UTF8.
El sistema operativo, los controladores de dispositivo, las bibliotecas C y el sistema de tiempo de ejecución de Perl
conspirar para permitir que el programador trate un solo carácter ("\ n") como el terminador de línea,
independientemente de la representación externa. En muchos sistemas operativos, el texto nativo
La representación del archivo coincide con la representación interna, pero en algunas plataformas la
La representación externa de "\ n" se compone de más de un carácter.
Todas las variantes de archivos Unix, Mac OS (antiguos y nuevos) y Stream_LF en VMS utilizan un único
carácter para terminar cada línea en la representación externa del texto (aunque eso
un solo carácter es CARRIAGE RETURN en versiones anteriores a Darwin de Mac OS, y es LINE
FEED en Unix y la mayoría de los archivos VMS). En otros sistemas como OS / 2, DOS y los diversos
sabores de MS-Windows, su programa ve un "\ n" como un simple "\ cJ", pero lo que está almacenado
en los archivos de texto están los dos caracteres "\ cM \ cJ". Eso significa que si no usas
binmode () en estos sistemas, las secuencias "\ cM \ cJ" del disco se convertirán a "\ n" en
entrada, y cualquier "\ n" en su programa se convertirá de nuevo a "\ cM \ cJ" en la salida.
Esto es lo que desea para los archivos de texto, pero puede ser desastroso para los archivos binarios.
Otra consecuencia de usar binmode () (en algunos sistemas) es ese fin de archivo especial
los marcadores se verán como parte del flujo de datos. Para sistemas de Microsoft
familia esto significa que, si sus datos binarios contienen "\ cZ", el subsistema de E / S
considérelo como el final del archivo, a menos que utilice binmode ().
binmode () es importante no solo para readline () y imprimir() operaciones, sino también cuando
usando leer(), buscar(), sysread (), syswrite () y contar() (ver perlport para más
detalles). Vea las variables $ / y "$ \" en perlvar para saber cómo configurar manualmente su entrada
y secuencias de terminación de línea de salida.
Problemas de portabilidad: "binmode" en perlport.
bendiga REF, CLASSNAME
bendiga REF
Esta función le dice a la cosa referenciada por REF que ahora es un objeto en el
Paquete CLASSNAME. Si se omite CLASSNAME, se utiliza el paquete actual. Porque un
"bendecir" es a menudo lo último en un constructor, devuelve la referencia para
conveniencia. Utilice siempre la versión de dos argumentos si una clase derivada puede heredar la
función haciendo la bendición. Consulte perlobj para obtener más información sobre la bendición (y las bendiciones).
de objetos
Considere siempre bendecir objetos en CLASSNAMEs que tengan mayúsculas y minúsculas. Espacios de nombres con
todos los nombres en minúsculas se consideran reservados para Perl pragmata. Los tipos integrados tienen todo
nombres en mayúsculas. Para evitar confusiones, es posible que desee evitar nombres de paquetes como
bien. Asegúrese de que CLASSNAME sea un valor real.
Consulte "Módulos Perl" en perlmod.
break
Romper un bloque "dado ()".
Esta palabra clave está habilitada por la función "cambiar"; consulte la función para obtener más información sobre
"cambiar". También puede acceder a él colocando el prefijo "CORE ::". Alternativamente,
incluir un "use v5.10" o posterior al alcance actual.
llamador EXPR
llamador
Devuelve el contexto de la llamada actual a la subrutina de Perl puro. En contexto escalar,
devuelve el nombre del paquete de la persona que llama si hay is una persona que llama (es decir, si estamos en un
subrutina o "eval" o "require") y el valor indefinido en caso contrario. llamador nunca
devuelve subs XS y se omiten. El siguiente sub de perl puro aparecerá en lugar de
el sub XS en los valores de retorno de la persona que llama. En el contexto de la lista, la persona que llama regresa
# 0 1 2
($ paquete, $ nombre de archivo, $ línea) = llamador;
Con EXPR, devuelve información adicional que el depurador usa para imprimir una pila.
rastro. El valor de EXPR indica cuántos marcos de llamada retroceder antes del actual
.
# 0 1 2 3 4
($ paquete, $ nombre de archivo, $ línea, $ subrutina, $ hasargs,
# 5 6 7 8 9 10
$ wantarray, $ evaltext, $ is_require, $ sugerencias, $ máscara de bits, $ sugerencia)
= llamador ($ i);
Aquí, $ subrutina es la función que llamó la persona que llama (en lugar de la función
que contiene la persona que llama). Tenga en cuenta que $ subrutina puede ser "(eval)" si el marco no es un
llamada de subrutina, pero una "eval". En tal caso, los elementos adicionales $ evaltext y
$ is_require se establecen: $ is_require es verdadero si el marco es creado por un "require" o
instrucción "use", $ evaltext contiene el texto de la instrucción "eval EXPR". En
en particular, para una declaración "eval BLOCK", $ subrutina es "(eval)", pero $ evaltext es
indefinido. (Tenga en cuenta también que cada declaración "use" crea un marco "require" dentro de un
marco "eval EXPR".) $ subrutina también puede ser "(desconocido)" si esta subrutina en particular
pasa a haber sido eliminado de la tabla de símbolos. $ hasargs es verdadero si es nuevo
Se configuró una instancia de @_ para el marco. $ hints y $ bitmask contienen sugerencias pragmáticas
con el que se compiló la persona que llama. $ hints corresponde a $ ^ H y $ bitmask
corresponde a "$ {^ WARNING_BITS}". Los valores de $ hints y $ bitmask están sujetos a
cambian entre versiones de Perl y no están diseñadas para uso externo.
$ hinthash es una referencia a un hash que contiene el valor de "% ^ H" cuando la persona que llama fue
compilado, o "undef" si "% ^ H" estaba vacío. No modifique los valores de este hash, ya que
son los valores reales almacenados en el optree.
Además, cuando se llama desde el paquete de base de datos en el contexto de lista, y con un
argumento, la persona que llama devuelve información más detallada: establece la variable de lista
@DB :: args son los argumentos con los que se invocó la subrutina.
Tenga en cuenta que es posible que el optimizador haya optimizado los marcos de llamadas antes de que lo hiciera el "llamador".
la oportunidad de obtener la información. Eso significa que es posible que la persona que llama (N) no regrese
información sobre la trama de llamada que espera, para "N> 1". En particular,
@DB :: args puede tener información de la última vez que se llamó al "llamador".
Tenga en cuenta que la configuración de @DB :: args es el mejor esfuerzo, destinado a depurar o generar
retrocesos, y no se debe confiar en ellos. En particular, como @_ contiene alias para
los argumentos de la persona que llama, Perl no toma una copia de @_, por lo que @DB :: args contendrá
modificaciones que la subrutina hace a @_ o su contenido, no los valores originales en
tiempo de llamada. @DB :: args, como @_, no contiene referencias explícitas a sus elementos, por lo que
En ciertos casos, sus elementos pueden haber sido liberados y reasignados para otros
variables o valores temporales. Finalmente, un efecto secundario de la implementación actual
es que los efectos de "shift @_" pueden normalmente deshacerse (pero no "pop @_" u otro
empalme y no si se ha tomado una referencia a @_, y sujeto a la advertencia sobre
elementos reasignados), por lo que @DB :: args es en realidad un híbrido del estado actual y
estado inicial de @_. El comprador tenga cuidado.
chdir EXPR
chdir IDENTIFICADOR DE ARCHIVO
chdir MANGO DE DIRH
chdir
Cambia el directorio de trabajo a EXPR, si es posible. Si se omite EXPR, cambia a
el directorio especificado por $ ENV {HOME}, si está configurado; si no, cambia al directorio
especificado por $ ENV {LOGDIR}. (En VMS, la variable $ ENV {SYS $ LOGIN} también está marcada,
y se utiliza si está establecido.) Si no se establece ninguno, "chdir" no hace nada. Vuelve verdadero en
éxito, falso en caso contrario. Vea el ejemplo en "morir".
En sistemas que apoyan fchdir(2), puede pasar un identificador de archivo o un identificador de directorio como
el argumento. En sistemas que no son compatibles fchdir(2), al pasar las asas se eleva un
excepción.
LISTA chmod
Cambia los permisos de una lista de archivos. El primer elemento de la lista debe ser el
modo numérico, que probablemente debería ser un número octal, y que definitivamente debería
no ser una cadena de dígitos octales: 0644 está bien, pero "0644" no. Devuelve el número
de archivos modificados correctamente. Consulte también "oct" si todo lo que tiene es una cadena.
$ cnt = chmod 0755, "foo", "bar";
chmod 0755, @ejecutables;
$ modo = "0644"; modo chmod $, "foo"; # !!! establece el modo en
# --w ---- rT
$ modo = "0644"; chmod oct ($ modo), "foo"; # este es mejor
$ modo = 0644; modo chmod $, "foo"; # esto es lo mejor
En sistemas que apoyan fchmod(2), puede pasar identificadores de archivos entre los archivos. Sobre
sistemas que no son compatibles fchmod(2), pasar identificadores de archivo genera una excepción.
Los identificadores de archivo deben pasarse como referencias globales o globales para ser reconocidos; las palabras desnudas son
considerados nombres de archivo.
open (my $ fh, "<", "foo");
my $ permanente = (stat $ fh) [2] & 07777;
chmod ($ permanente | 0600, $ fh);
También puede importar las constantes simbólicas "S_I *" del módulo "Fcntl":
use Fcntl qw (: modo);
chmod S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH, @executables;
# Idéntico al chmod 0755 del ejemplo anterior.
Problemas de portabilidad: "chmod" en perlport.
masticar VARIABLE
masticar (LISTA)
chomp
Esta versión más segura de "chop" elimina cualquier cadena final que corresponda al
valor actual de $ / (también conocido como $ INPUT_RECORD_SEPARATOR en el módulo "Inglés").
Devuelve el número total de caracteres eliminados de todos sus argumentos. Es a menudo
utilizado para eliminar la nueva línea del final de un registro de entrada cuando le preocupa que
el registro final puede faltar en su nueva línea. Cuando está en modo párrafo ("$ / = ''"),
elimina todas las nuevas líneas finales de la cadena. Cuando está en modo sorber ("$ / = undef") o
modo de registro de longitud fija ($ / es una referencia a un número entero o similar; ver perlvar)
chomp () no eliminará nada. Si se omite VARIABLE, muerde $ _. Ejemplo:
while (<>) {
masticar # evitar \ n en el último campo
@array = dividir (/: /);
#...
}
Si VARIABLE es un hash, muerde los valores del hash, pero no sus claves, restableciendo el
"cada" iterador en el proceso.
De hecho, puede masticar cualquier cosa que sea un lvalue, incluida una asignación:
chomp ($ cwd = `pwd`);
chomp ($ respuesta = );
Si muerde una lista, se muerde cada elemento y el número total de caracteres
eliminado se devuelve.
Tenga en cuenta que los paréntesis son necesarios cuando muerde cualquier cosa que no sea una simple
variable. Esto se debe a que "chomp $ cwd =` pwd`; " se interpreta como "(chomp $ cwd) =
`pwd`;", en lugar de como "chomp ($ cwd =` pwd`) "que podría esperar. Del mismo modo,
"chomp $ a, $ b" se interpreta como "chomp ($ a), $ b" en lugar de "chomp ($ a, $ b)".
picar VARIABLE
picar (LISTA)
cortar
Corta el último carácter de una cadena y devuelve el carácter cortado. Está
mucho más eficiente que "s /.$// s" porque no escanea ni copia la cadena. Si
Se omite VARIABLE, corta $ _. Si VARIABLE es un hash, corta los valores del hash, pero
no sus claves, restableciendo el "cada" iterador en el proceso.
De hecho, puede cortar cualquier cosa que sea un valor l, incluida una asignación.
Si corta una lista, cada elemento se corta. Solo el valor de la última "tajada" es
devuelto.
Tenga en cuenta que "chop" devuelve el último carácter. Para devolver todos menos el último carácter,
use "substr ($ string, 0, -1)".
Consulte también "masticar".
chown LISTA
Cambia el propietario (y el grupo) de una lista de archivos. Los dos primeros elementos de la lista
debe ser el numérico uid y gid, en ese orden. Un valor de -1 en cualquier posición es
interpretado por la mayoría de los sistemas para dejar ese valor sin cambios. Devuelve el número de
archivos cambiados con éxito.
$ cnt = chown $ uid, $ gid, 'foo', 'bar';
chown $ uid, $ gid, @filenames;
En sistemas que apoyan fchown(2), puede pasar identificadores de archivos entre los archivos. Sobre
sistemas que no son compatibles fchown(2), pasar identificadores de archivo genera una excepción.
Los identificadores de archivo deben pasarse como referencias globales o globales para ser reconocidos; las palabras desnudas son
considerados nombres de archivo.
Aquí hay un ejemplo que busca uids no numéricos en el archivo passwd:
imprimir "Usuario:";
chomp ($ usuario = );
imprimir "Archivos:";
chomp ($ patrón = );
($ inicio de sesión, $ pase, $ uid, $ gid) = getpwnam ($ usuario)
o muere "$ usuario no en el archivo passwd";
@ary = glob ($ patrón); # expandir nombres de archivos
chown $ uid, $ gid, @ary;
En la mayoría de los sistemas, no puede cambiar la propiedad del archivo a menos que esté
el superusuario, aunque debería poder cambiar el grupo a cualquiera de sus
grupos secundarios. En sistemas inseguros, estas restricciones pueden relajarse, pero esto es
no es una suposición portátil. En los sistemas POSIX, puede detectar esta condición de esta manera:
use POSIX qw (sysconf _PC_CHOWN_RESTRICTED);
$ can_chown_giveaway = no sysconf (_PC_CHOWN_RESTRICTED);
Problemas de portabilidad: "chown" en perlport.
NÚMERO chr
chr Devuelve el carácter representado por ese NÚMERO en el juego de caracteres. Por ejemplo,
"chr(65) "es" A "en ASCII o Unicode, y chr(0x263a) es una cara sonriente Unicode.
Los valores negativos dan el carácter de reemplazo Unicode (chr(0xfffd)), excepto bajo el
bytes pragma, donde los ocho bits más bajos del valor (truncado a un número entero) son
usado.
Si se omite NUMBER, usa $ _.
Para el reverso, use "ord".
Tenga en cuenta que los caracteres de 128 a 255 (inclusive) no están codificados internamente de forma predeterminada.
como UTF-8 por razones de compatibilidad con versiones anteriores.
Consulte perlunicode para obtener más información sobre Unicode.
chroot NOMBRE DE ARCHIVO
chroot
Esta función funciona como la llamada al sistema con el mismo nombre: hace que el nombre
directorio el nuevo directorio raíz para todos los nombres de ruta adicionales que comienzan con un "/" por
su proceso y todos sus hijos. (No cambia su directorio de trabajo actual,
que no se ve afectado.) Por razones de seguridad, esta llamada está restringida al superusuario.
Si se omite FILENAME, hace un "chroot" a $ _.
NOTA: Es una buena práctica de seguridad hacer "chdir (" / ")" (al directorio raíz)
inmediatamente después de un "chroot ()".
Problemas de portabilidad: "chroot" en perlport.
cerrar FILEHANDLE
Cerrar
Cierra el archivo o canalización asociado con el identificador de archivo, vacía los búferes de E / S y
cierra el descriptor de archivos del sistema. Devuelve verdadero si esas operaciones tienen éxito y si no
Cualquier capa de PerlIO informó de un error. Cierra el identificador de archivo seleccionado actualmente si
se omite el argumento.
No tiene que cerrar FILEHANDLE si inmediatamente va a hacer otra "apertura"
en él, porque "abrir" lo cierra para usted. (Ver abierto). Sin embargo, un "cierre" explícito en
un archivo de entrada restablece el contador de línea ($.), mientras que el cierre implícito realizado por "abrir"
no.
Si el identificador de archivo proviene de un canal abierto, "cerrar" devuelve falso si uno de los otros
Las llamadas al sistema involucradas fallan o si su programa sale con un estado distinto de cero. Si el único
El problema fue que el programa salió de un valor distinto de cero, $! se establecerá en 0. Cerrar una tubería
también espera a que salga el proceso que se ejecuta en la tubería, en caso de que desee ver
la salida de la tubería después, e implícitamente pone el valor de estado de salida de ese
comando en $? y "$ {^ CHILD_ERROR_NATIVE}".
Si hay varios subprocesos en ejecución, "cierre" en un identificador de archivo desde un canal abierto
devuelve verdadero sin esperar a que termine el proceso hijo, si el identificador de archivo es
todavía abierto en otro hilo.
Cerrar el extremo de lectura de una tubería antes de que el proceso de escritura en el otro extremo sea
la escritura terminada da como resultado que el escritor reciba un SIGPIPE. Si el otro extremo no puede manejar
eso, asegúrese de leer todos los datos antes de cerrar la tubería.
Ejemplo:
open (OUTPUT, '| sort> foo') # tubería para ordenar
o morir "No se puede empezar a ordenar: $!";
# ... # imprimir cosas a la salida
cerrar SALIDA # esperar a que termine la ordenación
o advierte $! ? "Error al cerrar la tubería de clasificación: $!"
: "Estado de salida $? De clasificación";
open (INPUT, 'foo') # obtiene los resultados de la clasificación
or die "¡No se puede abrir 'foo' para la entrada: $!";
FILEHANDLE puede ser una expresión cuyo valor se puede utilizar como un identificador de archivo indirecto,
por lo general, el nombre real del identificador de archivo o un identificador autovivificado.
cerradoir DIRHANDLE
Cierra un directorio abierto por "opendir" y devuelve el éxito de esa llamada al sistema.
conectar SOCKET, NAME
Intenta conectarse a un enchufe remoto, como se unen(2). Devuelve verdadero si
tuvo éxito, falso en caso contrario. NOMBRE debe ser una dirección empaquetada del tipo apropiado
para el enchufe. Consulte los ejemplos en "Sockets: comunicación cliente / servidor" en
perlipc.
continuar BLOQUEO
continue
Cuando le sigue un BLOQUE, "continuar" es en realidad una declaración de control de flujo en lugar de
Una función. Si hay un BLOQUE "continuar" adjunto a un BLOQUE (normalmente en un
"while" o "foreach"), siempre se ejecuta justo antes de que el condicional esté a punto de
ser evaluado de nuevo, al igual que la tercera parte de un ciclo "for" en C. Por lo tanto, puede ser
utilizado para incrementar una variable de bucle, incluso cuando el bucle se ha continuado a través de la
instrucción "siguiente" (que es similar a la instrucción "continuar" C).
"último", "siguiente" o "rehacer" pueden aparecer dentro de un bloque "continuar"; "último" y "rehacer"
se comportan como si se hubieran ejecutado dentro del bloque principal. También lo hará "siguiente", pero desde
ejecutará un bloque "continuar", puede ser más entretenido.
mientras (EXPR) {
### rehacer siempre viene aquí
hacer algo;
} Seguir {
### lo siguiente siempre viene aquí
hacer algo más;
# luego vuelva a la parte superior para volver a verificar EXPR
}
### lo último siempre viene aquí
Omitir la sección "continuar" equivale a usar una vacía, lógicamente,
por lo que "siguiente" retrocede directamente para verificar la condición en la parte superior del ciclo.
Cuando no hay BLOQUE, "continuar" es una función que cae a través del "cuando" actual
o bloque "predeterminado" en lugar de iterar un "foreach" que encierra dinámicamente o salir de un
delimitando léxicamente "dado". En Perl 5.14 y versiones anteriores, esta forma de "continuar" era
solo disponible cuando la función "cambiar" estaba habilitada. Ver función y "Cambiar
Declaraciones "en perlsyn para obtener más información.
porque EXPR
cos Devuelve el coseno de EXPR (expresado en radianes). Si se omite EXPR, toma el
coseno de $ _.
Para la operación de coseno inverso, puede usar la función "Math :: Trig :: acos ()", o
usa esta relación:
sub acos {atan2 (sqrt (1 - $ _ [0] * $ _ [0]), $ _ [0])}
cripta PLAINTEXT, SAL
Crea una cadena de resumen exactamente como la cripta(3) función en la biblioteca C (asumiendo
que en realidad tienes una versión allí que no ha sido extirpada como potencial
munición).
cripta() es una función hash unidireccional. PLAINTEXT y SALT se convierten en un breve
cadena, llamada resumen, que se devuelve. El mismo PLAINTEXT y SALT siempre
devolver la misma cadena, pero no hay forma (conocida) de obtener el PLAINTEXT original de
el hash. Pequeños cambios en PLAINTEXT o SALT resultarán en grandes cambios en el
digerir.
No hay función de descifrado. Esta función no es tan útil para la criptografía
(para eso, busca Cripta módulos en su espejo CPAN cercano) y el nombre "cripta" es
un nombre poco apropiado. En su lugar, se utiliza principalmente para comprobar si hay dos fragmentos de texto.
lo mismo sin tener que transmitir o almacenar el texto en sí. Un ejemplo es comprobar
si se proporciona una contraseña correcta. Se almacena el resumen de la contraseña, no el
contraseña en sí. El usuario escribe una contraseña que es cripta()con la misma sal que
el resumen almacenado. Si los dos resúmenes coinciden, la contraseña es correcta.
Al verificar una cadena de resumen existente, debe usar el resumen como la sal (como
"cripta ($ simple, $ digest) eq $ digest"). La SAL utilizada para crear el resumen es visible
como parte del resumen. Esto garantiza cripta() hash la nueva cadena con el mismo
sal como digestión. Esto permite que su código funcione con la cripta estándar y con
implementaciones más exóticas. En otras palabras, no asuma nada sobre la cadena devuelta
en sí mismo ni sobre cuántos bytes de SALT pueden importar.
Tradicionalmente, el resultado es una cadena de 13 bytes: dos primeros bytes de la sal,
seguido de 11 bytes del conjunto "[./0-9A-Za-z]", y solo los primeros ocho bytes de
PLAINTEXT importaba. Pero esquemas de hash alternativos (como MD5), seguridad de nivel superior
esquemas (como C2) e implementaciones en plataformas que no son Unix pueden producir diferentes
instrumentos de cuerda.
Al elegir una nueva sal, cree una cadena aleatoria de dos caracteres cuyos caracteres vengan
del conjunto "[./0-9A-Za-z]" (como "unirse '', ('.', '/', 0..9, 'A' .. 'Z', 'a'. .'z ') [rand
64, rand 64] "). Este conjunto de caracteres es solo una recomendación; los caracteres
permitido en la sal depende únicamente de la biblioteca de criptas de su sistema, y Perl no puede
restringir las sales que acepta "crypt ()".
Aquí hay un ejemplo que asegura que quien ejecute este programa conozca su contraseña:
$ pwd = (getpwuid ($ <)) [1];
sistema "stty -echo";
imprimir "Contraseña:";
chomp ($ palabra = );
imprimir "\ n";
sistema "stty echo";
if (cripta ($ palabra, $ pwd) ne $ pwd) {
morir "Lo siento ... \ n";
} Else {
imprimir "ok \ n";
}
Por supuesto, escribir tu propia contraseña a quien te la pida no es prudente.
La función de cripta no es adecuada para hacer hash de grandes cantidades de datos, sobre todo de
todo porque no puede recuperar la información. Mire el módulo Digest para más
algoritmos robustos.
Si usas cripta() en una cadena Unicode (que potentially tiene caracteres con puntos de código
por encima de 255), Perl intenta darle sentido a la situación tratando de degradar (una copia
de) la cadena de nuevo a una cadena de bytes de ocho bits antes de llamar cripta() (en esa copia).
Si eso funciona, bien. Que no, cripta() muere con "Carácter ancho en cripta".
Problemas de portabilidad: "cripta" en perlport.
dbmcerrar HASH
[Esta función ha sido reemplazada en gran medida por la función "desatar".]
Rompe el enlace entre un archivo DBM y un hash.
Problemas de portabilidad: "dbmclose" en perlport.
dbmopen HASH, DBNAME, MASK
[Esta función ha sido reemplazada en gran medida por la función de enlace].
Esto une un dBm(3) ndbm(3) sdbm(3) gdbm(3), o un archivo Berkeley DB a un hash. PICADILLO
es el nombre del hash. (A diferencia de "abierto" normal, el primer argumento es no a
identificador de archivo, aunque parezca uno). DBNAME es el nombre de la base de datos
(sin el . es or .pag extensión si la hubiera). Si la base de datos no existe, es
creado con la protección especificada por MASK (modificada por la "umask"). Para prevenir
creación de la base de datos si no existe, puede especificar un MODO de 0, y el
La función devolverá un valor falso si no puede encontrar una base de datos existente. Si tu
El sistema solo admite las funciones de DBM más antiguas, solo puede realizar una llamada "dbmopen" en
su programa. En versiones anteriores de Perl, si su sistema no tenía DBM ni ndbm,
llamar a "dbmopen" produjo un error fatal; ahora vuelve a sdbm(3).
Si no tiene acceso de escritura al archivo DBM, solo puede leer variables hash, no
establecerlos. Si desea probar si puede escribir, utilice pruebas de archivo o intente
establecer una entrada hash ficticia dentro de una "evaluación" para atrapar el error.
Tenga en cuenta que funciones como "claves" y "valores" pueden devolver listas enormes cuando se utilizan en
archivos DBM grandes. Es posible que prefiera utilizar la función "cada" para iterar sobre DBM de gran tamaño.
archivos. Ejemplo:
# imprimir compensaciones de archivos de historial
dbmopen (% HIST, '/ usr / lib / news / history', 0666);
while (($ key, $ val) = each% HIST) {
imprimir $ clave, '=', desempaquetar ('L', $ val), "\ n";
}
dbmclose (% HIST);
Consulte también AnyDBM_File para obtener una descripción más general de los pros y los contras de
varios enfoques de dbm, así como DB_File para una implementación particularmente rica.
Puede controlar qué biblioteca DBM usa cargando esa biblioteca antes de llamar
dbmopen ():
utilizar DB_Archivo;
dbmopen (% NS_Hist, "$ ENV {HOME} /. netscape / history.db")
o morir "No se puede abrir el archivo histórico de Netscape: $!";
Problemas de portabilidad: "dbmopen" en perlport.
EXPR definido
se define
Devuelve un valor booleano que indica si EXPR tiene un valor diferente al indefinido
valor "indef". Si EXPR no está presente, se marca $ _.
Muchas operaciones devuelven "undef" para indicar falla, fin de archivo, error del sistema,
variable no inicializada y otras condiciones excepcionales. Esta función le permite
distinguir "undef" de otros valores. (Una simple prueba booleana no distinguirá
entre "undef", cero, la cadena vacía y "0", que son igualmente falsos).
que dado que "undef" es un escalar válido, su presencia no necesariamente indicar un
condición excepcional: "pop" devuelve "undef" cuando su argumento es una matriz vacía, or
cuando el elemento a devolver pasa a ser "indef".
También puede utilizar "definido (& func)" para comprobar si alguna vez se ha utilizado la subrutina & func
definido. El valor de retorno no se ve afectado por ninguna declaración anticipada de & func. A
La subrutina que no está definida aún puede ser invocable: su paquete puede tener un
Método "AUTOLOAD" que lo hace aparecer la primera vez que se
llamado; ver perlsub.
El uso de "definido" en agregados (hashes y matrices) está en desuso. Solía informar
si alguna vez se había asignado memoria para ese agregado. Este comportamiento puede
desaparecerán en futuras versiones de Perl. En su lugar, debería utilizar una prueba simple de tamaño:
if (@an_array) {print "tiene elementos de matriz \ n"}
if (% a_hash) {print "tiene miembros hash \ n"}
Cuando se usa en un elemento hash, le dice si el valor está definido, no si
la clave existe en el hash. Utilice "existe" para este último propósito.
Ejemplos:
imprimir si está definido $ switch {D};
imprimir "$ val \ n" mientras está definido ($ val = pop (@ary));
die "¡No se puede leer el enlace $ sym: $!"
a menos que esté definido ($ valor = readlink $ sym);
sub foo {definido & $ bar? & $ bar (@_): muere "Sin barra"; }
$ debugging = 0 a menos que se defina $ debugging;
Nota: Mucha gente tiende a abusar de "definido" y luego se sorprende al descubrir que
el número 0 y "" (la cadena de longitud cero) son, de hecho, valores definidos. Para
ejemplo, si dices
"ab" = ~ /a(.*)b/;
La coincidencia de patrones se realiza correctamente y se define $ 1, aunque no coincide con "nada". Eso
realmente no dejó de coincidir con nada. Más bien, coincidió con algo que le sucedió
tener una longitud de cero caracteres. Todo esto es muy franco y honesto. Cuando una función
devuelve un valor indefinido, es una admisión de que no podría darte una
respuesta. Por lo tanto, debe usar "definido" solo cuando cuestione la integridad de lo que
estás tratando de hacer. En otras ocasiones, lo que desea es una simple comparación con 0 o "".
Consulte también "undef", "existe", "ref".
eliminar EXPR
Dada una expresión que especifica un elemento o porción de un hash, "eliminar" elimina el
elementos especificados de ese hash para que existe () en ese elemento ya no regresa
verdadero. Establecer un elemento hash en el valor indefinido no elimina su clave, pero
eliminarlo hace; ver "existe".
En el contexto de la lista, devuelve el valor o los valores eliminados, o el último elemento de este tipo en
contexto escalar. La longitud de la lista de retorno siempre coincide con la de la lista de argumentos:
eliminar elementos inexistentes devuelve el valor indefinido en su correspondiente
posiciones.
eliminar () también se puede utilizar en matrices y cortes de matriz, pero su comportamiento es menos
simple. A pesar de que existe () devolverá falso para las entradas eliminadas, eliminando
los elementos de la matriz nunca cambian los índices de los valores existentes; usar cambio() or empalme() for
ese. Sin embargo, si algún elemento eliminado cae al final de una matriz, el tamaño de la matriz
se reduce a la posición del elemento más alto que todavía prueba verdadero para existe ()o
a 0 si ninguno lo hace. En otras palabras, una matriz no tendrá elementos inexistentes al final
después de una eliminación.
ADVERTENCIA: Se desaconseja encarecidamente llamar a "eliminar" en los valores de la matriz. La noción de
eliminar o comprobar la existencia de elementos de la matriz de Perl no es conceptualmente
coherente y puede conducir a un comportamiento sorprendente.
Eliminar de% ENV modifica el entorno. Eliminar de un hash vinculado a un archivo DBM
elimina la entrada del archivo DBM. Es posible que no se elimine de un hash o matriz "vinculado"
necesariamente devolver cualquier cosa; depende de la implementación del paquete "vinculado"
DELETE método, que puede hacer lo que le plazca.
La construcción "eliminar EXPR local" localiza la eliminación en el bloque actual en ejecución
tiempo. Hasta que el bloque salga, los elementos eliminados localmente temporalmente ya no existen.
Consulte "Eliminación localizada de elementos de tipos compuestos" en perlsub.
% hash = (foo => 11, bar => 22, baz => 33);
$ escalar = eliminar $ hash {foo}; # $ escalar es 11
$ escalar = eliminar @hash {qw (foo bar)}; # $ escalar es 22
@array = eliminar @hash {qw (foo baz)}; # @array es (undef, 33)
Lo siguiente (de manera ineficiente) elimina todos los valores de% HASH y @ARRAY:
foreach $ key (claves% HASH) {
eliminar $ HASH {$ clave};
}
foreach $ index (0 .. $ # ARRAY) {
eliminar $ ARRAY [$ index];
}
Y también estos:
eliminar @HASH {claves% HASH};
eliminar @ARRAY [0 .. $ # ARRAY];
Pero ambos son más lentos que asignar la lista vacía o indefinir% HASH o @ARRAY, que
es la forma habitual de vaciar un agregado:
% HASH = (); #% HASH completamente vacío
undef% HASH; # olvide% HASH existió alguna vez
@ARRAY = (); # completamente vacío @ARRAY
undef @ARRAY; # olvidar @ARRAY alguna vez existió
El EXPR puede complicarse arbitrariamente siempre que su funcionamiento final sea un elemento o
rebanada de un agregado:
eliminar $ ref -> [$ x] [$ y] {$ key};
eliminar @ {$ ref -> [$ x] [$ y]} {$ key1, $ key2, @morekeys};
eliminar $ ref -> [$ x] [$ y] [$ índice];
eliminar @ {$ ref -> [$ x] [$ y]} [$ index1, $ index2, @moreindices];
morir LISTA
"morir" plantea una excepción. Dentro de una "eval", el mensaje de error se mete en $ @ y
la "eval" termina con el valor indefinido. Si la excepción está fuera de todos
adjuntando "eval" s, la excepción no detectada imprime LIST en "STDERR" y sale con
un valor distinto de cero. Si necesita salir del proceso con un código de salida específico, consulte
"Salida".
Ejemplos equivalentes:
die "No se puede cd a spool: $! \ n" a menos que chdir '/ usr / spool / news';
chdir '/ usr / spool / news' o muere "No se puede cd a spool: $! \ n"
Si el último elemento de LIST no termina en una nueva línea, el número de línea de secuencia de comandos actual
y el número de línea de entrada (si lo hubiera) también se imprimen, y se proporciona una nueva línea. Tenga en cuenta que
el "número de línea de entrada" (también conocido como "fragmento") está sujeto a cualquier noción de
"línea" pasa a estar actualmente en efecto, y también está disponible como el especial
variable $ .. Ver "$ /" en perlvar y "$". en perlvar.
Sugerencia: a veces, agregar ", detenido" a su mensaje hará que se mejore
sentido cuando se agrega la cadena "en la línea 123 de foo". Suponga que está ejecutando un script
"canasta".
morir "/ etc / games no es bueno";
morir "/ etc / games no es bueno, detenido";
producir, respectivamente
/ etc / games no es bueno en la línea 123 de canasta.
/ etc / games no es bueno, se detuvo en la línea 123 de canasta.
Si la salida está vacía y $ @ ya contiene un valor (generalmente de un
eval) ese valor se reutiliza después de agregar "\ t ... propagado". Esto es útil para
propagación de excepciones:
eval {...};
morir a menos que $ @ = ~ / Excepción esperada /;
Si la salida está vacía y $ @ contiene una referencia de objeto que tiene un "PROPAGATE"
, ese método se llamará con parámetros adicionales de número de línea y archivo.
El valor de retorno reemplaza el valor en $ @; es decir, como si "$ @ = eval {
$ @ -> PROPAGATE (__ FILE__, __LINE__)}; "fueron llamados.
Si $ @ está vacío, se utiliza la cadena "Died".
Si una excepción no detectada da como resultado la salida del intérprete, el código de salida se determina a partir de
los valores de $! y $? con este pseudocódigo:
salir $! si $ !; # errno
salir $? >> 8 si $? >> 8; # estado de salida del niño
salida 255; # último recurso
La intención es exprimir la mayor cantidad de información posible sobre la causa probable en el
espacio limitado del código de salida del sistema. Sin embargo, como $! es el valor de "errno" de C,
que puede ser establecido por cualquier llamada al sistema, esto significa que el valor del código de salida usado
por "morir" puede ser no predecible, por lo que no se debe confiar en él, salvo que no sea
cero.
También puede llamar a "morir" con un argumento de referencia, y si está atrapado dentro de un
"eval", $ @ contiene esa referencia. Esto permite un manejo de excepciones más elaborado
utilizando objetos que mantienen un estado arbitrario sobre la excepción. Tal esquema es
a veces es preferible hacer coincidir valores de cadena particulares de $ @ con valores regulares
Expresiones Porque $ @ es una variable global y "eval" puede usarse dentro del objeto
implementaciones, tenga cuidado de que el análisis del objeto de error no reemplace el
referencia en la variable global. Es más fácil hacer una copia local de la referencia.
antes de cualquier manipulación. He aquí un ejemplo:
use Scalar :: Util "bendito";
eval {...; die Some :: Module :: Exception-> new (FOO => "bar")};
si (mi $ ev_err = $ @) {
si (bendito ($ ev_err)
&& $ ev_err-> isa ("Algunos :: Módulo :: Excepción")) {
# manejar Algunos :: Módulo :: Excepción
}
else {
# manejar todas las demás posibles excepciones
}
}
Dado que Perl encadena los mensajes de excepción no detectados antes de que se muestren, probablemente
desea sobrecargar las operaciones de encadenamiento en objetos de excepción. Ver sobrecarga para
detalles sobre eso.
Puede hacer que se ejecute una devolución de llamada justo antes de que el "dado" haga su acto, por
configurando el gancho $ SIG {__ DIE__}. Se llama al controlador asociado con el texto de error
y puede cambiar el mensaje de error, si lo considera oportuno, llamando de nuevo a "morir". Ver "% SIG"
en perlvar para obtener detalles sobre la configuración de entradas% SIG, y "eval BLOCK" para algunos ejemplos.
Aunque esta función debía ejecutarse justo antes de que su programa saliera, este
no lo es actualmente: el gancho $ SIG {__ DIE__} se llama actualmente incluso dentro eval ()ed
bloques / cadenas! Si uno quiere que el anzuelo no haga nada en tales situaciones, coloque
morir @_ si $ ^ S;
como la primera línea del controlador (ver "$ ^ S" en perlvar). Porque esto promueve
acción extraña a distancia, este comportamiento contrario a la intuición puede arreglarse en un futuro
en libertad.
Vea también salida(), advertir()y el módulo Carp.
hacer BLOQUEO
No es realmente una función. Devuelve el valor del último comando en la secuencia de
comandos indicados por BLOQUEO. Cuando se modifica con el modificador de bucle "while" o "until",
ejecuta el BLOQUE una vez antes de probar la condición del bucle. (En otras declaraciones el
Los modificadores de bucle prueban primero el condicional).
"do BLOCK" hace no cuenta como un bucle, por lo que las declaraciones de control de bucle "siguiente", "último" o
"rehacer" no se puede utilizar para salir o reiniciar el bloque. Ver perlsyn para una alternativa
estrategias.
hacer EXPR
Utiliza el valor de EXPR como nombre de archivo y ejecuta el contenido del archivo como Perl.
guión.
hacer 'stat.pl';
es en gran parte como
eval `cat stat.pl`;
excepto que es más conciso, no ejecuta procesos externos, realiza un seguimiento de la
nombre de archivo para mensajes de error, busca en los directorios @INC y actualiza% INC si el
se encuentra el archivo. Vea "@INC" en perlvar y "% INC" en perlvar para estas variables. Eso
también difiere en que el código evaluado con "do FILENAME" no puede ver léxicos en el
alcance adjunto; "eval STRING" lo hace. Sin embargo, es lo mismo en el sentido de que analiza
el archivo cada vez que lo llame, por lo que probablemente no desee hacer esto dentro de un bucle.
Si "do" puede leer el archivo pero no puede compilarlo, devuelve "undef" y establece un error.
mensaje en $ @. Si "do" no puede leer el archivo, devuelve undef y establece $! al
error. Siempre marque $ @ primero, ya que la compilación podría fallar de una manera que también establezca $ !.
Si el archivo se compila correctamente, "do" devuelve el valor de la última expresión
evaluado.
La inclusión de módulos de biblioteca se realiza mejor con los operadores "use" y "require",
que también realiza una comprobación automática de errores y genera una excepción si hay un problema.
Es posible que desee utilizar "hacer" para leer en un archivo de configuración de programa. Error manual
la verificación se puede hacer de esta manera:
# leer en los archivos de configuración: primero el sistema, luego el usuario
para $ archivo ("/share/prog/defaults.rc",
"$ ENV {HOME} /. Someprogrc")
{
a menos que ($ return = do $ file) {
advertir "no se pudo analizar $ file: $ @" si $ @;
advertir "no se pudo hacer $ file: $!" a menos que se defina $ retorno;
advertir "no se pudo ejecutar $ file" a menos que $ return;
}
}
volcado ETIQUETA
volcar EXPR
arrojar
Esta función provoca un volcado de memoria inmediato. Ver también el -u interruptor de línea de comandos en
perlrun, que hace lo mismo. Principalmente, esto es para que pueda utilizar el deshacerse
programa (no suministrado) para convertir su volcado de memoria en un binario ejecutable después de haber
Inicializó todas sus variables al comienzo del programa. Cuando el nuevo binario
se ejecuta, comenzará ejecutando un "goto LABEL" (con todas las restricciones que
sufre "goto"). Piense en ello como un goto con un volcado de núcleo intermedio y
reencarnación. Si se omite "LABEL", reinicia el programa desde la parte superior. El vertedero
EXPR ", disponible a partir de Perl 5.18.0, permite calcular un nombre al ejecutar
time, siendo por lo demás idéntico a "dump LABEL".
ADVERTENCIA: Cualquier archivo abierto en el momento del volcado se no estar abierto más cuando el
El programa se reencarna, con la posible confusión resultante por parte de Perl.
Esta función ahora es en gran parte obsoleta, principalmente porque es muy difícil convertir un núcleo
archivo en un ejecutable. Es por eso que ahora debería invocarlo como "CORE :: dump ()", si
no desea que se le advierta contra un posible error tipográfico.
A diferencia de la mayoría de los operadores con nombre, tiene la misma prioridad que la asignación. Tambien es
exentos de la regla de apariencia de una función, por lo que "dump (" foo ")." bar "" causará "bar"
para ser parte del argumento de "dumping".
Problemas de portabilidad: "dump" en perlport.
cada HASH
cada ARRAY
cada EXPR
Cuando se llama a un hash en el contexto de la lista, devuelve una lista de 2 elementos que consta de la clave
y valor para el siguiente elemento de un hash. Solo en Perl 5.12 y posteriores, también
devuelve el índice y el valor del siguiente elemento de una matriz para que pueda iterar
encima de eso; Los antiguos Perls consideran que esto es un error de sintaxis. Cuando se llama en contexto escalar,
devuelve solo la clave (no el valor) en un hash o el índice en una matriz.
Las entradas hash se devuelven en un orden aparentemente aleatorio. El orden aleatorio real es
específico de un hash dado; la misma serie exacta de operaciones en dos hashes puede resultar
en un orden diferente para cada hash. Cualquier inserción en el hash puede cambiar el orden,
al igual que cualquier eliminación, con la excepción de que la clave más reciente devuelta por "cada"
o las "claves" pueden eliminarse sin cambiar el orden. Siempre que un hash determinado sea
sin modificar, puede confiar en "claves", "valores" y "cada uno" para devolver repetidamente el mismo
orden como el uno al otro. Consulte "Ataques de complejidad algorítmica" en perlsec para obtener detalles sobre
por qué el orden hash es aleatorio. Aparte de las garantías proporcionadas aquí, la exacta
Los detalles del algoritmo hash de Perl y el orden transversal de hash están sujetos a cambios en
cualquier versión de Perl.
Después de que "each" haya devuelto todas las entradas del hash o matriz, la siguiente llamada a "each"
devuelve la lista vacía en el contexto de la lista y "undef" en el contexto escalar; la próxima llamada
siguiendo que uno reinicia la iteración. Cada hash o matriz tiene su propio
iterador, al que se accede mediante "cada", "claves" y "valores". El iterador se restablece implícitamente
cuando "cada uno" ha llegado al final como se acaba de describir; se puede restablecer explícitamente por
llamando "claves" o "valores" en el hash o matriz. Si agrega o elimina un hash
elementos mientras se itera sobre él, el efecto sobre el iterador no se especifica; por
Por ejemplo, las entradas se pueden omitir o duplicar, así que no lo haga. Excepción: es
siempre es seguro eliminar el elemento devuelto más recientemente por "each ()", por lo que lo siguiente
el código funciona correctamente:
while (($ clave, $ valor) = cada% hash) {
imprimir $ clave, "\ n";
eliminar $ hash {$ clave}; # Esto es seguro
}
Los hash vinculados pueden tener un comportamiento de ordenación diferente al de la implementación de hash de perl.
Esto imprime su entorno como el printenv(1) programa, pero en un
orden:
while (($ clave, $ valor) = cada% ENV) {
imprimir "$ clave = $ valor \ n";
}
A partir de Perl 5.14, "cada" puede tomar un EXPR escalar, que debe contener una referencia a
un hash o matriz sin bendición. El argumento será desreferenciado automáticamente. Esta
aspecto de "cada uno" se considera altamente experimental. El comportamiento exacto puede cambiar en
una versión futura de Perl.
while (($clave,$valor) = cada $hashref) { ... }
A partir de Perl 5.18, puede usar un "cada" simple en un bucle "while", que establecerá $_ en
cada iteración.
while(cada %ENV) {
imprimir "$_=$ENV{$_}\n";
}
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.012; # así que las claves/valores/cada uno funciona en arreglos
usar 5.014; # entonces claves/valores/cada uno trabaja en escalares (experimental)
usar 5.018; # así que cada uno se asigna a $_ en una sola prueba while
Consulte también "claves", "valores" y "ordenar".
eof ARCHIVO
eof ()
eof Devuelve 1 si la próxima lectura en IDENTIFICADOR DE ARCHIVO devolverá el final del archivo or si IDENTIFICADOR DE ARCHIVO es
no abierto. FILEHANDLE puede ser una expresión cuyo valor proporcione el identificador de archivo real.
(Tenga en cuenta que esta función en realidad lee un carácter y luego "desconéctalo", por lo que no es
útil en un contexto interactivo.) No lea desde un archivo de terminal (o llame
"eof(FILEHANDLE)" en él) después de llegar al final del archivo. Tipos de archivos como terminales
puede perder la condición de fin de archivo si lo hace.
Un "eof" sin argumento usa el último archivo leído. Usando "eof ()" con vacío
paréntesis es diferente. Se refiere al pseudoarchivo formado a partir de los archivos enumerados
en la línea de comando y se accede a través del operador "<>". Dado que "<>" no es explícitamente
abierto, como lo es un identificador de archivo normal, un "eof ()" antes de que se haya utilizado "<>" causará
@ARGV para ser examinado para determinar si la entrada está disponible. De manera similar, un "eof()" después
"<>" ha regresado al final del archivo asumirá que está procesando otra lista @ARGV, y
si no ha configurado @ARGV, leerá la entrada de "STDIN"; consulte "Operadores de E/S" en perlop.
En un bucle "while (<>)", se puede usar "eof" o "eof(ARGV)" para detectar el final de cada
mientras que "eof()" solo detectará el final del último archivo. Ejemplos:
# restablecer la numeración de líneas en cada archivo de entrada
while (<>) {
siguiente si /^\s*#/; # omitir comentarios
imprimir "$.\t$_";
} Seguir {
cerrar ARGV si eof; # Nota de()!
}
# insertar guiones justo antes de la última línea del último archivo
while (<>) {
if (eof()) { # verificar el final del último archivo
imprimir "--------------\n";
}
impresión;
último si eof(); # necesario si estamos leyendo desde una terminal
}
Sugerencia práctica: casi nunca necesita usar "eof" en Perl, porque la entrada
los operadores normalmente devuelven "undef" cuando se quedan sin datos o encuentran un error.
valor EXPR
BLOQUE EVAL
eval
En la primera forma, a menudo denominada "evaluación de cadena", el valor de retorno de EXPR es
analizado y ejecutado como si fuera un pequeño programa Perl. El valor de la expresión
(que a su vez está determinado dentro del contexto escalar) se analiza primero, y si hubiera
sin errores, ejecutado como un bloque dentro del contexto léxico del programa Perl actual.
Esto significa que, en particular, cualquier variable léxica externa es visible para él, y cualquier
la configuración de las variables del paquete o las definiciones de formato y subrutina permanecen después.
Tenga en cuenta que el valor se analiza cada vez que se ejecuta "eval". Si se omite EXPR,
evalúa $_. Este formulario se usa normalmente para retrasar el análisis y la ejecución posterior.
del texto de EXPR hasta el tiempo de ejecución.
Si la función "unicode_eval" está habilitada (que es la opción predeterminada en "usar 5.16" o
declaración superior), EXPR o $_ se trata como una cadena de caracteres, por lo que "use utf8"
las declaraciones no tienen efecto y los filtros de fuentes están prohibidos. En ausencia del
función "unicode_eval", la cadena a veces se tratará como caracteres y
a veces como bytes, según la codificación interna, y los filtros de origen activados
dentro de la "eval" exhiben el comportamiento errático, pero histórico, de afectar a algunos
ámbito de archivo externo que aún se está compilando. Véase también la palabra clave "evalbytes", que
siempre trata su entrada como un flujo de bytes y funciona correctamente con filtros de origen, y
el pragma característica.
Pueden surgir problemas si la cadena expande un escalar que contiene un número de punto flotante.
Ese escalar puede expandirse a letras, como "NaN" o "Infinito"; o, dentro del alcance
de un "usar configuración regional", el carácter del punto decimal puede ser algo más que un punto (como
como coma). Es probable que ninguno de estos se analice como probablemente espera.
En la segunda forma, el código dentro del BLOQUE se analiza solo una vez, al mismo tiempo
el código que rodea a la "eval" misma fue analizado y ejecutado dentro del contexto de
el programa Perl actual. Este formulario se usa típicamente para atrapar excepciones más
eficientemente que el primero (ver más abajo), al mismo tiempo que proporciona el beneficio de verificar
el código dentro de BLOCK en tiempo de compilación.
El punto y coma final, si lo hay, puede omitirse del valor de EXPR o dentro del
CUADRA.
En ambas formas, el valor devuelto es el valor de la última expresión evaluada dentro
el miniprograma; también se puede usar una declaración de retorno, al igual que con las subrutinas. los
expresión que proporciona el valor devuelto se evalúa en contexto nulo, escalar o de lista,
dependiendo del contexto de la propia "eval". Consulte "wantarray" para obtener más información sobre cómo
se puede determinar el contexto de evaluación.
Si hay un error de sintaxis o de tiempo de ejecución, o si se ejecuta una instrucción "die", "eval"
devuelve "undef" en contexto escalar o una lista vacía en contexto de lista, y $@ se establece en
el mensaje de error (Antes de la versión 5.16, un error hacía que se devolviera "undef" en la lista
contexto para errores de sintaxis, pero no para errores de tiempo de ejecución.) Si no hubo ningún error, $@ es
establecido en la cadena vacía. Un operador de flujo de control como "last" o "goto" puede omitir el
configuración de $@. Tenga en cuenta que el uso de "eval" tampoco impide que Perl imprima advertencias
a STDERR, ni rellena el texto de los mensajes de advertencia en $@. Para hacer cualquiera de
esos, tienes que usar la facilidad $SIG{__WARN__}, o desactivar las advertencias dentro del
BLOQUEO o EXPR usando "sin advertencias 'todas'". Consulte "advertencia", perlvar y advertencias.
Tenga en cuenta que, debido a que "eval" atrapa errores fatales, es útil para determinar
si se implementa una característica particular (como "socket" o "enlace simbólico"). Está
también el mecanismo de captura de excepciones de Perl, donde el operador de troquel se usa para elevar
excepciones
Si desea atrapar errores al cargar un módulo XS, algunos problemas con el binario
interfaz (como el sesgo de la versión de Perl) puede ser fatal incluso con "eval" a menos que
Se establece $ENV{PERL_DL_NONLAZY}. Véase perlrun.
Si el código que se va a ejecutar no varía, puede usar el formulario eval-BLOCK para interceptar la ejecución.
errores de tiempo sin incurrir en la penalización de recompilar cada vez. El error, si
any, todavía se devuelve en $@. Ejemplos:
# hacer que dividir por cero no sea fatal
eval { $respuesta = $a / $b; }; advertir a $@ si $@;
# lo mismo, pero menos eficiente
eval '$respuesta = $a / $b'; advertir a $@ si $@;
# un error en tiempo de compilación
evaluar { $respuesta = }; # INCORRECTO
# un error de tiempo de ejecución
eval '$respuesta ='; # juegos $@
El uso del formulario "eval{}" como una trampa de excepción en las bibliotecas tiene algunos problemas. Vencer
al estado actual posiblemente roto de los ganchos "__DIE__", es posible que desee no activar
cualquier gancho "__DIE__" que el código de usuario pueda haber instalado. Puede utilizar el "local
$SIG{__DIE__}" para este propósito, como muestra este ejemplo:
# una trampa de excepción privada para dividir por cero
eval {local $SIG{'__DIE__'}; $respuesta = $a / $b; };
advertir $ @ si $ @;
Esto es especialmente significativo, dado que los ganchos "__DIE__" pueden volver a llamar a "morir", lo que
tiene el efecto de cambiar sus mensajes de error:
# Los ganchos __DIE__ pueden modificar los mensajes de error
{
local $SIG{'__DIE__'} =
sub { (mi $x = $_[0]) =~ s/foo/bar/g; morir $x };
eval { die "foo vive aquí" };
imprime $@ si $@; # imprime "bar vive aquí"
}
Debido a que esto promueve la acción a distancia, este comportamiento contrario a la intuición puede ser
corregido en una versión futura.
Con una "eval", debe tener especial cuidado en recordar lo que se está mirando
cuando:
evaluar $x; # CASO 1
evaluar "$x"; # CASO 2
evaluar '$x'; # CASO 3
evaluar { $x }; # CASO 4
evaluar "\$$x++"; # CASO 5
$$x++; # CASO 6
Los casos 1 y 2 anteriores se comportan de forma idéntica: ejecutan el código contenido en la variable
$ x. (Aunque el caso 2 tiene comillas dobles engañosas que hacen que el lector se pregunte qué más
podría estar pasando (nada).) Los casos 3 y 4 también se comportan de la misma manera:
ejecute el código '$x', que no hace más que devolver el valor de $x. (El caso 4 es
preferido por razones puramente visuales, pero también tiene la ventaja de compilar en
en tiempo de compilación en lugar de en tiempo de ejecución). El caso 5 es un lugar donde normalmente would como uno
para usar comillas dobles, excepto que en esta situación particular, solo puede usar
referencias simbólicas en su lugar, como en el caso 6.
Antes de Perl 5.14, la asignación a $@ se producía antes de la restauración de
variables, lo que significa que para que su código se ejecute en versiones anteriores, un temporal es
requerido si desea enmascarar algunos pero no todos los errores:
# alterar $@ solo en repugnancia infame
{
mi $e;
{
locales $@; # proteger el $@ existente
eval { prueba_repugnancia() };
# $@ =~ /nefasto/ y muere $@; # Solo Perl 5.14 y superior
$@ =~ /nefasto/ y $e = $@;
}
morir $e si se define $e
}
"eval BLOCK" hace no cuenta como un bucle, por lo que las declaraciones de control de bucle "siguiente", "último",
o "rehacer" no se puede usar para salir o reiniciar el bloque.
Un "eval ''" ejecutado dentro de una subrutina definida en el paquete "DB" no ve el
ámbito léxico circundante habitual, sino más bien el ámbito de la primera pieza no DB de
código que lo llamó. Normalmente no necesita preocuparse por esto a menos que esté
escribiendo un depurador de Perl.
bytes evaluados EXPR
bytes evaluados
Esta función es como "eval" con un argumento de cadena, excepto que siempre analiza su
argumento, o $_ si se omite EXPR, como una cadena de bytes. Una cadena que contiene
caracteres cuyo valor ordinal exceda de 255 da como resultado un error. Filtros de origen
activados dentro del código evaluado se aplican al propio código.
Esta función solo está disponible en la función "evalbytes", un "usar v5.16" (o
superior) o con un prefijo "CORE::". Consulte la función para obtener más información.
LISTA de ejecutivos
LISTA DE PROGRAMAS ejecutivos
La función "exec" ejecuta un comando del sistema y nunca devoluciones; use "sistema" en su lugar
de "exec" si desea que regrese. Falla y devuelve falso solo si el comando
no existe y se ejecuta directamente en lugar de a través del shell de comandos de su sistema
(vea abajo).
Como es un error común usar "ejec" en lugar de "sistema", Perl le advierte si
"exec" se llama en contexto nulo y si hay una declaración siguiente que no es
"morir", "advertir" o "salir" (si se establece "-w", pero siempre haces eso, ¿verdad?). Si usted
realmente quiere seguir a un "ejecutivo" con alguna otra declaración, puede usar una de estas
estilos para evitar la advertencia:
exec ('foo') o imprime STDERR "no se pudo ejecutar foo: $!";
{ ejecutivo ('foo') }; print STDERR "no se pudo ejecutar foo: $!";
Si hay más de un argumento en LIST, esto llama ejecutivo(3) con los argumentos en
LISTA. Si solo hay un elemento en LIST, el argumento se verifica para Shell
metacaracteres, y si hay alguno, el argumento completo se pasa al sistema
shell de comandos para analizar (esto es "/ Bin / sh -c" en plataformas Unix, pero varía en otras
plataformas). Si no hay metacaracteres de shell en el argumento, se divide en
palabras y pasó directamente a "execvp", que es más eficiente. Ejemplos:
ejecutivo/ bin / echo', 'Tus argumentos son: ', @ARGV;
exec "ordenar $outfile | uniq";
Si realmente no quiere ejecutar el primer argumento, pero quiere mentirle al programa
está ejecutando sobre su propio nombre, puede especificar el programa que realmente desea
ejecutar como un "objeto indirecto" (sin coma) delante de la LISTA, como en "exec
LISTA DE PROGRAMAS". (Esto siempre fuerza la interpretación de la LISTA como una lista multivaluada,
incluso si solo hay un escalar en la lista). Ejemplo:
$cáscara = '/bin/csh';
exec $shell '-sh'; # pretender que es un shell de inicio de sesión
o, más directamente,
ejecutivo {'/bin/csh'} '-sh'; # pretender que es un shell de inicio de sesión
Cuando los argumentos se ejecutan a través del shell del sistema, los resultados están sujetos a su
peculiaridades y capacidades. Ver "`STRING`" en perlop para más detalles.
Usar un objeto indirecto con "ejec" o "sistema" también es más seguro. este uso
(que también funciona bien con sistema()) fuerza la interpretación de los argumentos como
lista multivaluada, incluso si la lista tenía solo un argumento. De esa manera estás a salvo de
el caparazón expande comodines o divide palabras con espacios en blanco en ellas.
@args = ("echo sorpresa");
ejecutivo @args; # sujeto a escapes de proyectiles
# si @argumentos == 1
exec { $argumentos[0] } @argumentos; # seguro incluso con una lista de un solo argumento
La primera versión, la que no tiene objeto indirecto, ejecutaba el echo programa, pasando
"sorprende" un argumento. La segunda versión no lo hizo; intentó ejecutar un programa llamado
"eco sorpresa", no lo encontró y estableció $? a un valor distinto de cero que indica falla.
En Windows, solo la sintaxis de objetos indirectos "exec PROGRAM LIST" evitará de manera confiable
usando el caparazón; "exec LIST", incluso con más de un elemento, volverá a la
shell si la primera generación falla.
Perl intenta vaciar todos los archivos abiertos para la salida antes que el exec, pero es posible que no lo haga.
ser compatible con algunas plataformas (ver perlport). Para estar seguro, es posible que deba establecer $|
($AUTOFLUSH en inglés) o llamar al método "autoflush()" de "IO::Handle" en cualquier abierto
manijas para evitar pérdidas de salida.
Tenga en cuenta que "exec" no llamará a sus bloques "END", ni invocará métodos "DESTROY"
en tus objetos.
Problemas de portabilidad: "exec" en perlport.
existe EXPR
Dada una expresión que especifica un elemento de un hash, devuelve verdadero si el especificado
El elemento en el hash se ha inicializado alguna vez, incluso si el valor correspondiente es
indefinido.
imprime "Existe\n" si existe $hash{$clave};
imprime "Definido\n" si está definido $hash{$clave};
imprime "Verdadero\n" si $hash{$clave};
También se puede llamar a los elementos de la matriz, pero su comportamiento es mucho menos obvio y
está fuertemente ligado al uso de "eliminar" en matrices.
ADVERTENCIA: Se desaconseja encarecidamente llamar "existe" a los valores de matriz. La noción de
eliminar o comprobar la existencia de elementos de la matriz de Perl no es conceptualmente
coherente y puede conducir a un comportamiento sorprendente.
imprime "Existe\n" si existe $matriz[$índice];
imprime "Definido\n" si está definido $matriz[$índice];
imprime "Verdadero\n" si $matriz[$índice];
Un elemento hash o matriz puede ser verdadero solo si está definido y definido solo si
existe, pero lo contrario no necesariamente es cierto.
Dada una expresión que especifica el nombre de una subrutina, devuelve verdadero si la
se ha declarado alguna vez una subrutina especificada, incluso si no está definida. Mencionar un
el nombre de la subrutina existe o está definido no cuenta como declaración. Tenga en cuenta que un
subrutina que no existe aún puede ser invocable: su paquete puede tener un
Método "AUTOLOAD" que lo hace aparecer la primera vez que se
llamado; ver perlsub.
imprime "Existe\n" si existe &subrutina;
imprime "Definido\n" si está definido como &subrutina;
Tenga en cuenta que la EXPR puede complicarse arbitrariamente siempre que la operación final sea una
búsqueda de clave hash o matriz o nombre de subrutina:
si (existe $ref->{A}->{B}->{$clave}) { }
si (existe $hash{A}{B}{$clave}) { }
si (existe $ref->{A}->{B}->[$ix]) { }
si (existe $hash{A}{B}[$ix]) { }
si (existe &{$ref->{A}{B}{$clave}}) { }
Aunque la matriz anidada más profunda o el elemento hash no surgirán
solo porque su existencia fue probada, cualquiera que intervenga lo hará. Así "$ref->{"A"}"
y "$ref->{"A"}->{"B"}" surgirá debido a la prueba de existencia para el
$elemento clave anterior. Esto sucede en cualquier lugar donde se use el operador de flecha, incluso
aquí:
undef$ref;
if (existe $ref->{"Alguna clave"}) { }
imprimir $ref; # impresiones Hachís(0x80d3d5c)
Esta sorprendente autovivificación en lo que a primera -o incluso a segunda- mirada no
parece ser un contexto lvalue puede corregirse en una versión futura.
Uso de una llamada de subrutina, en lugar de un nombre de subrutina, como argumento para existe () is
un error.
existe ⊂ # OK
existe &sub(); # Error
salir EXPR
salida
Evalúa EXPR y sale inmediatamente con ese valor. Ejemplo:
$ respuesta = ;
exit 0 si $respuesta =~ /^[Xx]/;
Véase también "morir". Si se omite EXPR, sale con estado 0. El único universalmente
los valores reconocidos para EXPR son 0 para éxito y 1 para error; otros valores están sujetos
a la interpretación según el entorno en el que se ejecute el programa Perl.
Por ejemplo, salir de 69 (EX_UNAVAILABLE) desde un sendmail el filtro de correo entrante
hacer que el remitente devuelva el artículo sin entregar, pero eso no es cierto en todas partes.
No use "salir" para abortar una subrutina si hay alguna posibilidad de que alguien quiera
para atrapar cualquier error que haya ocurrido. Usa "morir" en su lugar, que puede ser atrapado por un
"evaluar".
El salida() La función no siempre sale inmediatamente. Llama a cualquier "FIN" definido
rutinas primero, pero estas rutinas "FIN" no pueden por sí mismas abortar la salida. igualmente
todos los destructores de objetos que deben llamarse se llaman antes de la salida real. "FINAL"
las rutinas y los destructores pueden cambiar el estado de salida modificando $?. si esto es un
problema, puede llamar a "POSIX::_exit($status)" para evitar el procesamiento END y destructor.
Ver perlmod para más detalles.
Problemas de portabilidad: "salir" en perlport.
EXP EXPR
Exp Devoluciones e (la base del logaritmo natural) a la potencia de EXPR. Si se omite EXPR,
da "exp ($ _)".
fc EXPR
fc Devuelve la versión plegada de EXPR. Esta es la función interna que implementa
el escape "\F" en cadenas entre comillas dobles.
Casefolding es el proceso de asignar cadenas a un formulario donde las diferencias de mayúsculas y minúsculas son
borrado; comparar dos cadenas en su forma plegada es efectivamente una forma de preguntar
si dos cadenas son iguales, independientemente del caso.
Aproximadamente, si alguna vez te encuentras escribiendo esto
lc($esto) eq lc($eso) # ¡Incorrecto!
# o
uc($esto) eq uc($eso) # ¡También está mal!
# o
$esto =~ /^\Q$eso\E\z/i # ¡Correcto!
Ahora puedes escribir
fc ($ esto) eq fc ($ eso)
Y obtener los resultados correctos.
Perl solo implementa la forma completa de plegado de casos, pero puede acceder a los pliegues simples
utilizando "casefold ()" en Unicode::UCD y "prop_invmap ()" en Unicode::UCD. Para más
información sobre el plegado de cajas, consulte el estándar Unicode, específicamente las secciones 3.13
"Operaciones de casos predeterminados", 4.2 "Normativas de casos" y 5.18 "Asignaciones de casos", disponibles
ahttp://www.unicode.org/versions/latest/>, así como los Case Charts disponibles en
<http://www.unicode.org/charts/case/>.
Si se omite EXPR, utiliza $_.
Esta función se comporta de la misma manera bajo varios pragmas, como dentro de
"usar la función 'unicode_strings", como lo hace "lc", con la única excepción de "fc" de
LETRA LATINA MAYÚSCULA SHARP S (U+1E9E) dentro del alcance de "use locale". el foldcase
de este carácter normalmente sería "ss", pero como se explica en la sección "lc", el caso
los cambios que cruzan el límite 255/256 son problemáticos bajo los locales y, por lo tanto, son
prohibido. Por lo tanto, esta función en locale devuelve en su lugar la cadena
"\x{17F}\x{17F}", que es la S LARGA MINÚSCULA LATINA. Dado que ese carácter en sí
pliegues a "s", la cadena de dos de ellos juntos debe ser equivalente a una sola
U+1E9E cuando está plegado.
Si bien el estándar Unicode define dos formas adicionales de plegado de cajas, una para Turkic
idiomas y uno que nunca mapea un carácter en múltiples caracteres, estos son
no proporcionado por el núcleo de Perl; Sin embargo, se puede utilizar el módulo CPAN "Unicode::Casing"
para proporcionar una implementación.
Esta palabra clave está disponible solo cuando la función "fc" está habilitada o cuando tiene el prefijo
"CENTRO::"; Ver característica. Alternativamente, incluya un "usar v5.16" o posterior al actual
alcance.
fcntl IDENTIFICADOR DE ARCHIVO, FUNCIÓN, ESCALAR
Implementa el fcntl(2) función. Probablemente tendrás que decir
utilizar Fcntl;
primero en obtener las definiciones constantes correctas. Procesamiento de argumentos y valor devuelto
funciona como "ioctl" a continuación. Por ejemplo:
utilizar Fcntl;
fcntl($filehandle, F_GETFL, $packed_return_buffer)
o muere "no puedo fcntl F_GETFL: $!";
No tiene que verificar "definido" en el retorno de "fcntl". Como "ioctl",
asigna un retorno de 0 de la llamada del sistema a "0 pero verdadero" en Perl. Esta cadena es verdadera
en contexto booleano y 0 en contexto numérico. También está exento de lo normal. -w
advertencias sobre conversiones numéricas incorrectas.
Tenga en cuenta que "fcntl" genera una excepción si se usa en una máquina que no implementa
fcntl(2). Consulte el módulo Fcntl o su fcntl(2) página de manual para aprender qué funciones son
disponible en su sistema.
Aquí hay un ejemplo de cómo configurar un identificador de archivo llamado "REMOTO" para que no bloquee en el
Nivel del sistema. Tendrás que negociar $| Aunque por tu cuenta.
utilice Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
$banderas = fcntl(REMOTO, F_GETFL, 0)
o muere "No se pueden obtener banderas para el socket: $!\n";
$banderas = fcntl(REMOTO, F_SETFL, $banderas | O_NONBLOCK)
or die "No se pueden establecer banderas para el socket: $!\n";
Problemas de portabilidad: "fcntl" en perlport.
__EXPEDIENTE__
Un token especial que devuelve el nombre del archivo en el que aparece.
fileno IDENTIFICADOR DE ARCHIVO
Devuelve el descriptor de archivo para un identificador de archivo, o indefinido si el identificador de archivo no es
abierto. Si no hay un descriptor de archivo real a nivel del sistema operativo, como puede suceder con
identificadores de archivo conectados a objetos de memoria a través de "abrir" con una referencia para el tercero
argumento, se devuelve -1.
Esto es principalmente útil para construir mapas de bits para "seleccionar" y tty-POSIX de bajo nivel.
operaciones de manipulación. Si IDENTIFICADOR_ARCHIVO es una expresión, el valor se toma como un
identificador de archivo indirecto, generalmente su nombre.
Puede usar esto para averiguar si dos identificadores se refieren al mismo subyacente
descriptor:
if (fileno(ESTO) != -1 && fileno(ESTO) == fileno(ESO)) {
print "ESTO y AQUELLO son duplicados\n";
} elsif (fileno(ESTO) != -1 && fileno(ESO) != -1) {
imprime "ESTO y AQUELLO tienen diferentes".
"descriptores de archivos subyacentes\n";
} Else {
imprime "Al menos uno de ESTO y AQUELLO hace".
"no tiene un descriptor de archivo real\n";
}
El comportamiento de "fileno" en un identificador de directorio depende del sistema operativo. En un
sistema con dirección(3) o similar, "fileno" en un identificador de directorio devuelve el subyacente
descriptor de archivo asociado con el identificador; en sistemas sin tal soporte,
devuelve el valor indefinido y establece $! (errno).
flock MANGO DE ARCHIVO, OPERACIÓN
Calls rebaño(2), o una emulación del mismo, en FILEHANDLE. Devuelve verdadero para el éxito, falso
sobre el fracaso Produce un error fatal si se usa en una máquina que no implementa
rebaño(2) fcntl(2) bloqueo, o bloquear(3). "flock" es el bloqueo de archivos portátil de Perl
interfaz, aunque solo bloquea archivos completos, no registros.
Dos semánticas de "rebaño" potencialmente no obvias pero tradicionales son que espera
indefinidamente hasta que se conceda la cerradura, y que sus cerraduras sean simplemente asesor. Tal
Las cerraduras discrecionales son más flexibles, pero ofrecen menos garantías. Esto significa que
los programas que no usan también "flock" pueden modificar archivos bloqueados con "flock". Ver
perlport, la documentación específica de su puerto y las páginas de manual locales específicas de su sistema
para detalles. Es mejor asumir un comportamiento tradicional si está escribiendo portable
programas (Pero si no lo eres, siempre deberías sentirte perfectamente libre de escribir para
las idiosincrasias de su propio sistema (a veces llamadas "características"). Adhesión servil a
las preocupaciones de portabilidad no deberían interponerse en el camino para hacer su trabajo).
OPERATION es uno de LOCK_SH, LOCK_EX o LOCK_UN, posiblemente combinado con LOCK_NB.
Estas constantes se valoran tradicionalmente 1, 2, 8 y 4, pero puede usar el símbolo
nombres si los importa desde el módulo Fcntl, ya sea individualmente o como un grupo
utilizando la etiqueta ":flock". LOCK_SH solicita un bloqueo compartido, LOCK_EX solicita un bloqueo exclusivo
lock, y LOCK_UN libera un bloqueo solicitado previamente. Si LOCK_NB es bitwise-o'ed
con LOCK_SH o LOCK_EX, luego "flock" regresa inmediatamente en lugar de bloquear la espera
para la cerradura; verifique el estado de devolución para ver si lo recibió.
Para evitar la posibilidad de falta de coordinación, Perl ahora vacía FILEHANDLE antes
bloquearlo o desbloquearlo.
Tenga en cuenta que la emulación construida con bloquear(3) no proporciona bloqueos compartidos y
requiere que FILEHANDLE esté abierto con intención de escritura. Estas son las semánticas que
bloquear(3) implementos. La mayoría, si no todos, los sistemas implementan bloquear(3) en términos de fcntl(2)
Sin embargo, el bloqueo, por lo que la semántica diferente no debería molestar a demasiadas personas.
Tenga en cuenta que fcntl(2) emulación de rebaño(3) requiere que FILEHANDLE esté abierto con
intención de lectura para usar LOCK_SH y requiere que esté abierto con intención de escritura para usar
BLOQUEO_EX.
Tenga en cuenta también que algunas versiones de "flock" no pueden bloquear cosas en la red; lo harías
necesita usar el "fcntl" más específico del sistema para eso. Si quieres puedes forzar Perl
para ignorar su sistema rebaño(2) función, y así proporcionar su propia fcntl(2) -basado
emulación, pasando el interruptor "-Ud_flock" al Configurar programa cuando tu
configurar y construir un nuevo Perl.
Aquí hay un agregador de buzón para sistemas BSD.
# importar constantes LOCK_* y SEEK_END
utilice Fcntl qw(:flock SEEK_END);
bloqueo secundario {
mi ($fh) = @_;
flock($fh, LOCK_EX) or die "No se puede bloquear el buzón - $!\n";
# y, en caso de que alguien se añadiera mientras esperábamos...
seek($fh, 0, SEEK_END) o die "No se puede buscar - $!\n";
}
desbloqueo secundario {
mi ($fh) = @_;
flock($fh, LOCK_UN) or die "No se puede desbloquear el buzón - $!\n";
}
open(mi $mbox, ">>", "/usr/spool/mail/$ENV{'USUARIO'}")
o muere "No se puede abrir el buzón: $!";
bloquear ($ mbox);
imprimir $mbox $mensaje,"\n\n";
desbloquear($mbox);
En los sistemas que soportan un verdadero rebaño(2), los bloqueos se heredan entre tenedor() llamadas,
mientras que aquellos que deben recurrir a los más caprichosos fcntl(2) la función pierde su
bloqueos, lo que dificulta seriamente la escritura de servidores.
Ver también DB_File para otros rebaño() ejemplos.
Problemas de portabilidad: "rebaño" en perlport.
tenedor
Hace un tenedor(2) llamada al sistema para crear un nuevo proceso que ejecuta el mismo programa en el
mismo punto. Devuelve el pid hijo al proceso padre, 0 al proceso hijo,
o "undef" si la bifurcación no tiene éxito. Descriptores de archivo (y, a veces, bloqueos en
esos descriptores) se comparten, mientras que todo lo demás se copia. En la mayoría de los sistemas
secundario tenedor(), se ha puesto mucho cuidado en hacerlo extremadamente eficiente (por
ejemplo, el uso de la tecnología de copia en escritura en las páginas de datos), por lo que es el dominante
paradigma de la multitarea en las últimas décadas.
Perl intenta vaciar todos los archivos abiertos para la salida antes de bifurcar el proceso secundario,
pero es posible que esto no sea compatible con algunas plataformas (ver perlport). Para estar seguro, puede
necesita establecer $| ($AUTOFLUSH en inglés) o llamar al método "autoflush()" de
"IO::Handle" en cualquier identificador abierto para evitar resultados duplicados.
Si "bifurcas" sin esperar a tus hijos, acumularás zombis. En
algunos sistemas, puede evitar esto configurando $SIG{CHLD} a "IGNORAR". Véase también perlipc
para más ejemplos de bifurcar y cosechar niños moribundos.
Tenga en cuenta que si su hijo bifurcado hereda descriptores de archivos del sistema como STDIN y STDOUT
que en realidad están conectados por una tubería o enchufe, incluso si sale, entonces el control remoto
servidor (como, por ejemplo, un script CGI o un trabajo en segundo plano iniciado desde un shell remoto)
no pensará que has terminado. Deberías volver a abrirlos para / dev / null si es cualquier problema.
En algunas plataformas como Windows, donde el tenedor() la llamada al sistema no está disponible, Perl
se puede construir para emular tenedor() en el intérprete de Perl. La emulación está diseñada, en
el nivel del programa Perl, para que sea lo más compatible posible con el "Unix" tenedor().
Sin embargo, tiene limitaciones que deben tenerse en cuenta en el código destinado a ser portátil.
Ver perlfork para más detalles.
Problemas de portabilidad: "bifurcación" en perlport.
formato
Declare un formato de imagen para que lo use la función "escribir". Por ejemplo:
formatear algo =
Prueba: @<<<<<<<< @||||| @>>>>>
$cadena, $%, '$' . int ($ número)
.
$cadena = "widget";
$num = $coste/$cantidad;
$~ = 'Algo';
escribir;
Ver perlform para muchos detalles y ejemplos.
formline IMAGEN,LISTA
Esta es una función interna utilizada por los "formatos", aunque también puede llamarla. Eso
formatea (ver perlform) una lista de valores de acuerdo con el contenido de PICTURE, colocando
la salida en el acumulador de salida de formato, $^A (o $ACCUMULATOR en inglés).
Eventualmente, cuando se realiza una "escritura", el contenido de $^A se escribe en algún
identificador de archivo También puede leer $^A y luego volver a establecer $^A en "". Tenga en cuenta que un formato
normalmente hace una "línea de formulario" por línea de formulario, pero la función "línea de formulario" en sí misma
no le importa cuántas líneas nuevas están incrustadas en la IMAGEN. Esto significa que el "~"
y los tokens "~~" tratan la IMAGEN completa como una sola línea. Por lo tanto, es posible que necesite
use varias líneas de formulario para implementar un solo formato de registro, al igual que el "formato"
compilador
Tenga cuidado si pone comillas dobles alrededor de la imagen, porque un carácter "@" puede
debe tomarse como el comienzo de un nombre de matriz. "formline" siempre devuelve verdadero. Ver
realizar para otros ejemplos.
Si está tratando de usar esto en lugar de "escribir" para capturar la salida, puede encontrar
es más fácil abrir un identificador de archivo a un escalar ("abrir $fh, ">", \$salida") y escribir en
eso en su lugar.
getc IDENTIFICADOR DE ARCHIVO
conseguir
Devuelve el siguiente carácter del archivo de entrada adjunto a FILEHANDLE, o el
valor indefinido al final del archivo o si hubo un error (en el último caso $! es
colocar). Si se omite FILEHANDLE, se lee desde STDIN. Esto no es particularmente
eficiente. Sin embargo, no se puede utilizar por sí mismo para obtener caracteres individuales sin
esperando que el usuario presione enter. Para eso, intente algo más como:
si ($BSD_STYLE) {
sistema "stty cbreak / dev / tty 2> & 1 ";
}
else {
sistema "stty", '-icanon', 'eol', "\001";
}
$clave = getc(ESTDIN);
si ($BSD_STYLE) {
sistema "stty -cbreak / dev / tty 2> & 1 ";
}
else {
sistema 'stty', 'icanon', 'eol', '^@'; # ASCII NULO
}
imprimir "\ n";
La determinación de si se debe establecer $BSD_STYLE se deja como ejercicio para el
lector.
La función "POSIX::getattr" puede hacer esto de manera más portátil en sistemas que pretenden ser POSIX.
cumplimiento. Consulta también el módulo "Term::ReadKey" de tu CPAN más cercano
<http://www.cpan.org> sitio.
iniciar sesión
Esto implementa la función de biblioteca C del mismo nombre, que en la mayoría de los sistemas devuelve
el inicio de sesión actual de / etc / utmp, Si alguna. Si devuelve la cadena vacía, use
"obtenerpwuid".
$inicio de sesión = obtener inicio de sesión || obtenerpwuid($<) || "Kilroy";
No considere "getlogin" para la autenticación: no es tan seguro como "getpwuid".
Problemas de portabilidad: "getlogin" en perlport.
getpeername SOCKET
Devuelve la dirección sockaddr empaquetada del otro extremo de la conexión SOCKET.
utilizar Socket;
$hersockaddr = getpeername(SOCK);
($puerto, $iaddr) = sockaddr_in($hersockaddr);
$herhostname = gethostbyaddr($iaddr, AF_INET);
$herstraddr = inet_ntoa($iaddr);
obtener pgrp PID
Devuelve el grupo de procesos actual para el PID especificado. Use un PID de 0 para obtener el
grupo de proceso actual para el proceso actual. Generará una excepción si se usa en un
máquina que no implementa obtenerpgrp(2). Si se omite PID, devuelve el proceso
grupo del proceso actual. Tenga en cuenta que la versión POSIX de "getpgrp" no
acepte un argumento PID, por lo que solo "PID == 0" es realmente portátil.
Problemas de portabilidad: "getpgrp" en perlport.
obtener
Devuelve la identificación del proceso del proceso principal.
Nota para usuarios de Linux: entre v5.8.1 y v5.16.0, Perl funcionaría alrededor de POSIX
semántica de subprocesos la minoría de los sistemas Linux (y los sistemas Debian GNU/kFreeBSD) que
usó LinuxThreads, esta emulación se eliminó desde entonces. Consulte la documentación para
$$ para más detalles.
Problemas de portabilidad: "getppid" en perlport.
obtener prioridad CUÁL, QUIÉN
Devuelve la prioridad actual de un proceso, un grupo de procesos o un usuario. (Ver
obtener prioridad(2).) Generará una excepción fatal si se usa en una máquina que no
implementar obtener prioridad(2).
Problemas de portabilidad: "getpriority" en perlport.
getpwnam NOMBRE
getgrnam NOMBRE
gethostbyname NOMBRE
getnetbyname NOMBRE
getprotobyname NOMBRE
UID de getpwuid
obtener GID
getservbyname NOMBRE,PROTO
gethostbyaddr DIRECCIÓN,TIPODIRECCIÓN
getnetbyaddr DIRECCIÓN,TIPODIRECCIÓN
obtenerprotobynumber NÚMERO
getservbyport PUERTO,PROTO
conseguir
conseguir
recibirhostent
conseguir
ponerse protocolario
getervent
establecido
conjunto
sethostent PERMANECER ABIERTO
establecer PERMANECER ABIERTO
setprotoent PERMANECER ABIERTO
setserver STAYOPEN
terminó
final
endhostent
final
protocolo final
endoservicio
Estas rutinas son las mismas que sus contrapartes en la biblioteca del sistema C. En lista
contexto, los valores de retorno de las diversas rutinas de obtención son los siguientes:
# 0 1 2 3 4
( $nombre, $contraseña, $gid, $miembros) = getgr*
( $nombre, $alias, $tipodirección, $red) = getnet*
( $nombre, $alias, $puerto, $proto) = getserv*
( $nombre, $alias, $proto) = getproto*
( $nombre, $alias, $tipodirección, $longitud, @dirección ) = gethost*
( $nombre, $contraseña, $uid, $gid, $cuota,
$comentario, $gcos, $dir, $shell, $expire) = getpw*
# 5 6 7 8 9
(Si la entrada no existe, el valor devuelto es un único valor verdadero sin sentido).
El significado exacto del campo $gcos varía, pero generalmente contiene el nombre real de
el usuario (a diferencia del nombre de inicio de sesión) y otra información relacionada con el usuario.
Tenga cuidado, sin embargo, que en muchos sistemas los usuarios pueden cambiar esta información y
por lo tanto, no se puede confiar en él y, por lo tanto, $gcos está contaminado (ver perlsec). los
$passwd y $shell, la contraseña cifrada del usuario y el shell de inicio de sesión, también están contaminados, por
la misma razon.
En contexto escalar, obtiene el nombre, a menos que la función fuera una búsqueda por nombre, en
en cuyo caso obtienes la otra cosa, sea lo que sea. (Si la entrada no existe, usted
obtener el valor indefinido.) Por ejemplo:
$uid = getpwnam($nombre);
$nombre = getpwuid($num);
$nombre = getpwent();
$gid = getgrnam($nombre);
$nombre = getgrgid($num);
$nombre = getgrent();
#etc.
In obtener pw*() los campos $cuota, $comentario y $caducidad son especiales porque son
sin soporte en muchos sistemas. Si la cuota de $ no es compatible, es un escalar vacío. Si
es compatible, generalmente codifica la cuota de disco. Si el campo $comentario es
sin soporte, es un escalar vacío. Si es compatible, normalmente codifica algunos
comentario administrativo sobre el usuario. En algunos sistemas, el campo $cuota puede ser
$cambio o $edad, campos que tienen que ver con la antigüedad de la contraseña. En algunos sistemas el
El campo de $comentario puede ser $clase. El campo $expire, si está presente, codifica el vencimiento
período de la cuenta o la contraseña. Para la disponibilidad y el significado exacto de
estos campos en su sistema, por favor consulte conseguirpwnam(3) y su sistema pwd.h archivo.
También puede averiguar desde Perl qué significan sus campos $cuota y $comentario y
si tiene el campo $expire usando el módulo "Config" y los valores
"d_pwquota", "d_pwage", "d_pwchange", "d_pwcomment" y "d_pwexpire". Sombra
los archivos de contraseña son compatibles solo si su proveedor los ha implementado en el intuitivo
moda que llamar a las rutinas regulares de la biblioteca C obtiene las versiones ocultas si está
ejecutándose con privilegios o si existe el sombra(3) funciones como se encuentran en el Sistema
V (esto incluye Solaris y Linux). Aquellos sistemas que implementan un propietario
Es poco probable que se admita la función de contraseña oculta.
El valor de $miembros devuelto por obtenergr*() es una lista separada por espacios de los nombres de inicio de sesión
de los integrantes del grupo.
Para el obtenerhost*() funciones, si la variable "h_errno" es compatible con C, será
devuelto a usted a través de $? si la llamada a la función falla. El valor @addrs devuelto por un
llamada exitosa es una lista de direcciones sin procesar devueltas por la llamada de biblioteca correspondiente.
En el dominio de Internet, cada dirección tiene una longitud de cuatro bytes; puedes descomprimirlo diciendo
algo como:
($a,$b,$c,$d) = desempaquetar('W4',$dirección[0]);
La biblioteca Socket hace que esto sea un poco más fácil:
utilizar Socket;
$dirección = inet_aton("127.1"); # o cualquier dirección
$nombre = gethostbyaddr($iaddr, AF_INET);
# o yendo hacia el otro lado
$straddr = inet_ntoa($iaddr);
Por el contrario, para resolver un nombre de host a la dirección IP, puede escribir esto:
utilizar Socket;
$packed_ip = gethostbyname("www.perl.org");
if (definido $packed_ip) {
$dirección_ip = inet_ntoa($ip_empaquetada);
}
Asegúrese de llamar a "gethostbyname()" en contexto ESCALAR y que su valor de retorno sea
comprobado para la definición.
La función "getprotobynumber", aunque solo toma un argumento, tiene la
precedencia de un operador de lista, así que tenga cuidado:
getprotobynumber $número eq 'icmp' # INCORRECTO
getprotobynumber($number eq 'icmp') # en realidad significa esto
getprotobynumber($number) eq 'icmp' # mejor así
Si se cansa de recordar qué elemento de la lista de devolución contiene qué devolución
valor, las interfaces por nombre se proporcionan en módulos estándar: "File::stat",
"Net::hostent", "Net::netent", "Net::protoent", "Net::servent", "Time::gmtime",
"Hora::horalocal" y "Usuario::grant". Estos anulan los incorporados normales, suministrando
versiones que devuelven objetos con los nombres apropiados para cada campo. Por ejemplo:
use File :: stat;
usar Usuario::pwent;
$is_his = (stat($filename)->uid == pwent($quien sea)->uid);
Aunque parece que son las mismas llamadas de método (uid), no lo son,
porque un objeto "Archivo::stat" es diferente de un objeto "Usuario::pwent".
Problemas de portabilidad: "getpwnam" en perlport a "endservent" en perlport.
obtiene el nombre del calcetín
Devuelve la dirección sockaddr empaquetada de este extremo de la conexión SOCKET, en caso de que
no sé la dirección porque tiene varias IP diferentes que la conexión
podría haber entrado.
utilizar Socket;
$mysockaddr = getsockname(SOCK);
($puerto, $myaddr) = sockaddr_in($mysockaddr);
printf "Conectarse a %s [%s]\n",
escalar gethostbyaddr($myaddr, AF_INET),
inet_ntoa($midirección);
getsockopt SOCKET, LEVEL, OPTNAME
Consulta la opción denominada OPTNAME asociada con SOCKET en un NIVEL dado. Las opciones pueden
existen en múltiples niveles de protocolo dependiendo del tipo de socket, pero al menos el
existirá el nivel de socket superior SOL_SOCKET (definido en el módulo "Socket"). Para
opciones de consulta en otro nivel el número de protocolo del protocolo apropiado
debe suministrarse la opción de control. Por ejemplo, para indicar que una opción es
ser interpretado por el protocolo TCP, NIVEL debe establecerse en el número de protocolo de
TCP, que puede obtener usando "getprotobyname".
La función devuelve una cadena empaquetada que representa la opción de socket solicitada, o
"undef" en caso de error, con el motivo del error colocado en $!. Justo lo que hay en el
la cadena empaquetada depende de LEVEL y OPTNAME; consultar recibe(2) para más detalles. A
caso común es que la opción es un número entero, en cuyo caso el resultado es un paquete
entero, que puede decodificar usando "desempaquetar" con el formato "i" (o "I").
Aquí hay un ejemplo para probar si el algoritmo de Nagle está habilitado en un socket:
use el zócalo qw (: todos);
definido(mi $tcp = getprotobyname("tcp"))
o morir "No se pudo determinar el número de protocolo para tcp";
# mi $tcp = IPPROTO_TCP; # Alternativa
mi $empaquetado = getsockopt($socket, $tcp, TCP_NODELAY)
o muere "getsockopt TCP_NODELAY: $!";
my $nodelay = unpack("I", $packed);
print "El algoritmo de Nagle está activado",
$noretraso? "apagado\n": "encendido\n";
Problemas de portabilidad: "getsockopt" en perlport.
EXPR global
glob
En el contexto de la lista, devuelve una lista (posiblemente vacía) de expansiones de nombre de archivo en el valor
de EXPR como el shell estándar de Unix / bin / csh haría. En contexto escalar, glob
itera a través de tales expansiones de nombre de archivo, devolviendo undef cuando se agota la lista.
Esta es la función interna que implementa el operador "<*.c>", pero puede usarla
directamente. Si se omite EXPR, se usa $_. El operador "<*.c>" se analiza en más
detalle en "Operadores de E/S" en perlop.
Tenga en cuenta que "glob" divide sus argumentos en espacios en blanco y trata cada segmento como
patrón separado. Como tal, "glob("*.c *.h")" coincide con todos los archivos con un .c or .h
extensión. La expresión "glob(".* *")" coincide con todos los archivos en el trabajo actual
directorio. Si desea englobar nombres de archivo que pueden contener espacios en blanco, tendrá
para usar comillas adicionales alrededor del nombre de archivo espacial para protegerlo. Por ejemplo, para glob
nombres de archivo que tienen una "e" seguida de un espacio seguido de una "f", use cualquiera de los siguientes:
@espacios = <"*ef*">;
@espacios = globo '"*ef*"';
@espacios = global q("*ef*");
Si tuviera que pasar una variable, podría hacer esto:
@espacios = global "'*${var}ef*'";
@espacios = global qq("*${var}ef*");
Si las llaves no vacías son los únicos caracteres comodín utilizados en el "glob", no hay nombres de archivo
coinciden, pero potencialmente se devuelven muchas cadenas. Por ejemplo, esto produce
nueve cuerdas, una para cada combinación de frutas y colores:
@many = glob "{manzana, tomate, cereza} = {verde, amarillo, rojo}";
Este operador se implementa utilizando la extensión estándar "File::Glob". Ver
File::Glob para obtener detalles, incluido "bsd_glob", que no trata los espacios en blanco como
separador de patrones
Problemas de portabilidad: "glob" en perlport.
Gmtime EXPR
tiempo gm
Funciona como "hora local", pero los valores devueltos están localizados para el estándar
Huso horario de Greenwich.
Nota: cuando se llama en contexto de lista, $isdst, el último valor devuelto por gmtime, es
siempre 0. No hay horario de verano en GMT.
Problemas de portabilidad: "gmtime" en perlport.
ir a ETIQUETA
ir a EXPR
ir a &NOMBRE
El formulario "goto LABEL" encuentra la declaración etiquetada con LABEL y reanuda la ejecución
allí. No se puede usar para salir de un bloque o subrutina dada para "ordenar". Puede
ser utilizado para ir a casi cualquier otro lugar dentro del ámbito dinámico, incluso fuera de
subrutinas, pero por lo general es mejor usar alguna otra construcción como "último" o
"morir". El autor de Perl nunca ha sentido la necesidad de utilizar esta forma de "goto" (en
Perl, eso es; C es otra cosa). (La diferencia es que C no ofrece nombres
lazos combinados con control de lazo. Perl lo hace, y esto reemplaza la mayoría de los usos estructurados
de "goto" en otros idiomas).
El formulario "ir a EXPR" espera evaluar "EXPR" a una referencia de código o un nombre de etiqueta.
Si se evalúa como una referencia de código, se manejará como "ir a &NOMBRE", a continuación.
Esto es especialmente útil para implementar recursión de cola a través de "goto __SUB__".
Si la expresión se evalúa como un nombre de etiqueta, su alcance se resolverá dinámicamente.
Esto permite "ir a" calculados por FORTRAN, pero no se recomienda necesariamente si
está optimizando para la mantenibilidad:
goto ("FOO", "BAR", "GLARCH")[$i];
Como se muestra en este ejemplo, "goto EXPR" está exento de la regla "parece una función".
Un par de paréntesis a continuación no delimita (necesariamente) su argumento.
"goto("NE")."XT"" es equivalente a "goto NEXT". Además, a diferencia de la mayoría de los operadores con nombre,
esto tiene la misma precedencia que la asignación.
El uso de "goto LABEL" o "goto EXPR" para saltar a una construcción está en desuso y
emitir una advertencia. Incluso entonces, no se puede usar para entrar en ninguna construcción que requiera
inicialización, como una subrutina o un bucle "foreach". Tampoco se puede usar para ir.
en una construcción que está optimizada.
La forma "ir a &NOMBRE" es bastante diferente de las otras formas de "ir a". de hecho,
no es un goto en el sentido normal en absoluto, y no tiene el estigma asociado con
otros gotos. En su lugar, sale de la subrutina actual (perdiendo los cambios establecidos por
local()) e inmediatamente llama en su lugar a la subrutina nombrada usando el actual
valor de @_. Esto es utilizado por las subrutinas "AUTOLOAD" que desean cargar otro
subrutina y luego pretender que la otra subrutina había sido llamada en el primer
lugar (excepto que cualquier modificación a @_ en la subrutina actual se propaga a
la otra subrutina.) Después de "ir a", ni siquiera "la persona que llama" podrá decir que
esta rutina fue llamada primero.
NOMBRE no necesita ser el nombre de una subrutina; puede ser una variable escalar que contiene un
referencia de código o un bloque que se evalúa como una referencia de código.
LISTA DE BLOQUEO grep
grep EXPR, LISTA
Esto es similar en espíritu a, pero no lo mismo que, grep(1) y sus parientes. En
en particular, no se limita al uso de expresiones regulares.
Evalúa el BLOCK o EXPR para cada elemento de LIST (estableciendo localmente $_ para cada
elemento) y devuelve el valor de la lista que consta de aquellos elementos para los que el
expresión evaluada como verdadera. En contexto escalar, devuelve el número de veces que
expresión era cierta.
@foo = grep(!/^#/, @bar); # eliminar comentarios
o equivalente,
@foo = grep {!/^#/} @bar; # eliminar comentarios
Tenga en cuenta que $_ es un alias para el valor de la lista, por lo que puede usarse para modificar los elementos
de la LISTA. Si bien esto es útil y compatible, puede causar resultados extraños si el
los elementos de LIST no son variables. De manera similar, grep devuelve alias al original
list, al igual que la variable de índice de un bucle for crea un alias para los elementos de la lista. Es decir,
modificando un elemento de una lista devuelta por grep (por ejemplo, en un "foreach", "mapa" o
otro "grep") en realidad modifica el elemento en la lista original. esto suele ser
algo que debe evitarse al escribir código claro.
Si $_ es léxico en el ámbito donde aparece "grep" (porque ha sido declarado
con la obsoleta construcción "my $_") entonces, además de tener un alias local para
los elementos de la lista, $_ sigue siendo léxico dentro del bloque; es decir, no se puede ver
desde el exterior, evitando posibles efectos secundarios.
Consulte también "mapa" para obtener una lista compuesta por los resultados de BLOCK o EXPR.
EXPR hexadecimal
hex Interpreta EXPR como una cadena hexadecimal y devuelve el valor correspondiente. (Para convertir
cadenas que pueden comenzar con 0, "0x" o "0b", consulte "oct".) Si EXPR es
omitido, usa $_.
imprimir hexadecimal '0xAf'; # imprime '175'
imprimir hexadecimal 'aF'; # mismo
Las cadenas hexadecimales solo pueden representar números enteros. Cadenas que causarían un desbordamiento de enteros
activar una advertencia. Los espacios en blanco iniciales no se eliminan, a diferencia de oct(). Presentar
algo como hexadecimal, busca en "printf", "sprintf" y "unpack".
importar LISTA
No hay una función de "importación" incorporada. Es solo un método ordinario (subrutina)
definido (o heredado) por módulos que desean exportar nombres a otro módulo. los
La función "usar" llama al método "importar" para el paquete utilizado. Véase también "uso",
perlmod y Exportador.
índice STR,SUBSTR,POSICIÓN
índice STR,SUBSTR
La función de índice busca una cadena dentro de otra, pero sin el comodín.
como el comportamiento de una coincidencia de patrón de expresión regular completa. Devuelve la posición de
la primera aparición de SUBSTR en STR en o después de POSITION. Si se omite POSICIÓN,
comienza a buscar desde el principio de la cadena. POSICIÓN antes del comienzo de
la cadena o después de su final se trata como si fuera el principio o el final,
respectivamente. POSICIÓN y el valor devuelto se basan en cero. Si la subcadena es
no encontrado, "índice" devuelve -1.
EXPR int
int Devuelve la parte entera de EXPR. Si se omite EXPR, utiliza $_. no debes usar
esta función para redondear: uno porque trunca hacia 0, y dos porque
Las representaciones mecánicas de números de punto flotante a veces pueden producir
resultados contraintuitivos. Por ejemplo, "int(-6.725/0.025)" produce -268 en lugar de
el correcto -269; eso es porque en realidad es más como -268.99999999999994315658
en lugar de. Por lo general, "sprintf", "printf" o "POSIX::floor" y "POSIX::ceil"
funciones le servirán mejor que En t().
ioctl ARCHIVO, FUNCIÓN, ESCALAR
Implementa el ioctl(2) función. Probablemente primero tengas que decir
requiere "sys/ioctl.ph"; # probablemente en
# $Config{archlib}/sys/ioctl.ph
para obtener las definiciones de funciones correctas. Si sys / ioctl.ph no existe o no
tenga las definiciones correctas, tendrá que crear las suyas propias, en función de su encabezado C
archivos como . (Hay un script de Perl llamado h2ph que viene con el
kit de Perl que puede ayudarlo en esto, pero no es trivial.) SCALAR se leerá y/o
escrito dependiendo de la FUNCIÓN; un puntero C al valor de cadena de ESCALAR será
pasado como el tercer argumento de la llamada "ioctl" real. (Si ESCALAR no tiene cadena
valor pero tiene un valor numérico, ese valor se pasará en lugar de un puntero
al valor de la cadena. Para garantizar que esto sea cierto, agregue un 0 al escalar antes de usar
él.) Las funciones "empaquetar" y "desempaquetar" pueden ser necesarias para manipular los valores de
estructuras utilizadas por "ioctl".
El valor de retorno de "ioctl" (y "fcntl") es el siguiente:
si OS devuelve: entonces Perl devuelve:
-1 valor indefinido
0 cadena "0 pero cierto"
cualquier otra cosa ese numero
Por lo tanto, Perl devuelve verdadero en caso de éxito y falso en caso de error, pero aún puede fácilmente
determinar el valor real devuelto por el sistema operativo:
$retorno = ioctl(...) || -1;
printf "El sistema devolvió %d\n", $retval;
La cadena especial "0 pero verdadero" está exenta de -w quejas sobre números incorrectos
conversiones
Problemas de portabilidad: "ioctl" en perlport.
únete a EXPR, LISTA
Une las cadenas separadas de LIST en una sola cadena con campos separados por el
valor de EXPR, y devuelve esa nueva cadena. Ejemplo:
$rec = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);
Tenga en cuenta que, a diferencia de "split", "join" no toma un patrón como primer argumento.
Compárese con "dividir".
llaves HASH
MATRIZ DE TECLAS
teclas EXPR
Llamado en contexto de lista, devuelve una lista que consta de todas las claves del hash nombrado,
o solo en Perl 5.12 o posterior, los índices de una matriz. Versiones de Perl anteriores a la 5.12
producirá un error de sintaxis si intenta usar un argumento de matriz. En contexto escalar,
devuelve el número de claves o índices.
Las entradas hash se devuelven en un orden aparentemente aleatorio. El orden aleatorio real es
específico de un hash dado; la misma serie exacta de operaciones en dos hashes puede resultar
en un orden diferente para cada hash. Cualquier inserción en el hash puede cambiar el orden,
al igual que cualquier eliminación, con la excepción de que la clave más reciente devuelta por "cada"
o las "claves" pueden eliminarse sin cambiar el orden. Siempre que un hash determinado sea
sin modificar, puede confiar en "claves", "valores" y "cada uno" para devolver repetidamente el mismo
orden como el uno al otro. Consulte "Ataques de complejidad algorítmica" en perlsec para obtener detalles sobre
por qué el orden hash es aleatorio. Aparte de las garantías proporcionadas aquí, la exacta
Los detalles del algoritmo hash de Perl y el orden transversal de hash están sujetos a cambios en
cualquier versión de Perl. Los hashes vinculados pueden comportarse de manera diferente a los hashes de Perl con respecto
a los cambios en el orden de inserción y eliminación de artículos.
Como efecto secundario, llamar llaves() reinicia el iterador interno de HASH o ARRAY
(ver "cada uno"). En particular, llamar llaves() en contexto vacío restablece el iterador con
sin otros gastos generales.
Aquí hay otra forma de imprimir su entorno:
@keys = teclas %ENV;
@valores = valores %ENV;
mientras (@teclas) {
imprimir pop(@teclas), '=', pop(@valores), "\n";
}
o qué tal ordenados por clave:
foreach $clave (ordenar(claves %ENV)) {
imprimir $clave, '=', $ENV{$clave}, "\n";
}
Los valores devueltos son copias de las claves originales en el hash, por lo que modificarlos
no afectará el hash original. Comparar "valores".
Para ordenar un hash por valor, necesitará usar una función de "ordenar". Aquí hay un descenso
tipo numérico de un hash por sus valores:
foreach $clave (ordenar { $hash{$b} <=> $hash{$a} } claves %hash) {
printf "%4d %s\n", $hash{$clave}, $clave;
}
Utilizado como un valor l, "claves" le permite aumentar la cantidad de cubos de hash asignados
para el hash dado. Esto puede ganarle una medida de eficiencia si sabe que el hash es
va a hacerse grande (Esto es similar a pre-extender una matriz asignando una mayor
número a $#matriz.) Si dice
claves %hash = 200;
entonces %hash tendrá asignados al menos 200 cubos, 256 de ellos, de hecho,
ya que se redondea a la siguiente potencia de dos. Estos cubos se conservarán incluso si
haces "%hash = ()", usa "undef %hash" si quieres liberar el almacenamiento mientras %hash está
todavía en el alcance. No puede reducir la cantidad de cubos asignados para el hash usando
"teclas" de esta manera (pero no debe preocuparse por hacer esto por accidente, ya que intentarlo tiene
sin efecto). "keys @array" en un contexto lvalue es un error de sintaxis.
A partir de Perl 5.14, las "claves" pueden tomar una EXPR escalar, que debe contener una referencia
a un hash o matriz no bendecidos. El argumento será desreferenciado automáticamente. Esta
aspecto de "claves" se considera altamente experimental. El comportamiento exacto puede cambiar en
una versión futura de Perl.
para (claves $hashref) { ... }
for (teclas $obj->get_arrayref) { ... }
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.012; # así que las claves/valores/cada uno funciona en arreglos
usar 5.014; # entonces claves/valores/cada uno trabaja en escalares (experimental)
Consulte también "cada uno", "valores" y "ordenar".
matar SEÑAL, LISTA
matar SEÑAL
Envía una señal a una lista de procesos. Devuelve el número de argumentos que fueron
utilizado con éxito para señalar (que no es necesariamente el mismo que el número de
procesos realmente eliminados, por ejemplo, cuando se elimina un grupo de procesos).
$cnt = matar 'HUP', $niño1, $niño2;
matar 'MATAR', @goners;
SIGNAL puede ser un nombre de señal (una cadena) o un número de señal. Un nombre de señal puede
comience con un prefijo "SIG", por lo que "FOO" y "SIGFOO" se refieren a la misma señal. los
Se recomienda la forma de cadena de SEÑAL para la portabilidad porque la misma señal puede tener
diferentes números en diferentes sistemas operativos.
Puede encontrar una lista de nombres de señales admitidos por la plataforma actual en
$Config{sig_name}, que proporciona el módulo "Config". Ver configuración para más
Detalles.
Un nombre de señal negativo es lo mismo que un número de señal negativo, eliminando grupos de procesos
en lugar de procesos. Por ejemplo, "matar '-KILL', $pgrp" y "matar -9, $pgrp"
enviar "SIGKILL" a todo el grupo de procesos especificado. Eso significa que por lo general desea
Utilice señales positivas, no negativas.
Si SIGNAL es el número 0 o la cadena "ZERO" (o "SIGZERO"), no se emite ninguna señal.
enviado al proceso, pero "matar" comprueba si es posible para enviarle una señal
(eso significa, para ser breve, que el proceso es propiedad del mismo usuario, o somos los
superusuario). Esto es útil para comprobar que un proceso hijo todavía está vivo (incluso si
solo como zombie) y no ha cambiado su UID. Ver perlport para notas sobre el
portabilidad de esta construcción.
El comportamiento de matar cuando un NUESTRO PROCESO número es cero o negativo depende de la
Sistema operativo. Por ejemplo, en sistemas compatibles con POSIX, cero indicará el
grupo de proceso actual, -1 señalará todos los procesos, y cualquier otro PROCESO negativo
el número actuará como un número de señal negativa y matará a todo el grupo de procesos
especificado.
Si tanto la SEÑAL como el PROCESO son negativos, los resultados son indefinidos. Una advertencia
puede ser producido en una versión futura.
Ver "Señales" en perlipc para más detalles.
En algunas plataformas como Windows donde el tenedor() la llamada al sistema no está disponible, Perl
se puede construir para emular tenedor() a nivel de intérprete. Esta emulación tiene
limitaciones relacionadas con la eliminación que deben tenerse en cuenta para el código que se ejecuta en Windows
y en código destinado a ser portátil.
Ver perlfork para más detalles.
Si no hay Anuncia de procesos, no se envía ninguna señal y el valor devuelto es 0. Esto
Sin embargo, a veces se usa el formulario porque hace que se ejecuten verificaciones de corrupción. Pero mira
"Lavado y detección de datos corruptos" en perlsec.
Problemas de portabilidad: "matar" en perlport.
última ETIQUETA
última EXPR
pasado
El comando "último" es como la instrucción "romper" en C (como se usa en los bucles); eso
sale inmediatamente del bucle en cuestión. Si se omite LABEL, el comando se refiere
al bucle envolvente más interno. El formulario "última EXPR", disponible a partir de Perl
5.18.0, permite calcular un nombre de etiqueta en tiempo de ejecución y, por lo demás, es idéntico a
"última ETIQUETA". El bloque "continuar", si lo hay, no se ejecuta:
LINE: mientras ( ) {
última LÍNEA si / ^ $ /; # salir cuando termine con el encabezado
# ...
}
"last" no se puede usar para salir de un bloque que devuelve un valor como "eval {}", "sub
{}", o "do {}", y no debe usarse para salir de un grep () or mapa() operación.
Tenga en cuenta que un bloque en sí mismo es semánticamente idéntico a un bucle que se ejecuta una vez.
Por lo tanto, "último" se puede usar para efectuar una salida anticipada de dicho bloque.
Consulte también "continuar" para ver una ilustración de cómo funcionan "último", "siguiente" y "rehacer".
A diferencia de la mayoría de los operadores con nombre, tiene la misma prioridad que la asignación. Tambien es
exenta de la regla de parecerse a una función, por lo que "last ("foo"). "bar"" causará "bar"
ser parte del argumento de "último".
EXPR
lc Devuelve una versión en minúsculas de EXPR. Esta es la función interna que implementa el
Escape "\L" en cadenas entre comillas dobles.
Si se omite EXPR, utiliza $_.
Lo que se devuelve depende de varios factores:
Si "usar bytes" está en vigor:
Los resultados siguen las reglas ASCII. Solo cambian los caracteres "AZ", a "az"
respectivamente.
De lo contrario, si "usar configuración regional" para "LC_CTYPE" está en vigor:
Respeta la configuración regional actual "LC_CTYPE" para puntos de código < 256; y usa reglas Unicode
para los puntos de código restantes (esto último solo puede ocurrir si el indicador UTF8 también está
colocar). Véase perlocale.
A partir de v5.20, Perl usa reglas Unicode completas si la configuración regional es UTF-8.
De lo contrario, hay una deficiencia en este esquema, que es que los cambios de caso que
cruzan el límite 255/256 no están bien definidos. Por ejemplo, la minúscula de
LA LETRA MAYÚSCULA LATINA SHARP S (U+1E9E) en las reglas Unicode es U+00DF (en ASCII
plataformas). Pero en "usar configuración regional" (anterior a v5.20 o no una configuración regional UTF-8), el
la minúscula de U+1E9E es ella misma, porque 0xDF puede no ser LATINA MINÚSCULA SHARP S
en la configuración regional actual, y Perl no tiene forma de saber si ese personaje incluso
existe en la configuración regional, mucho menos qué punto de código es. Perl devuelve un resultado que
está por encima de 255 (casi siempre el carácter de entrada no cambia, para todos los casos (y
no hay muchos) donde de otro modo se cruzaría el límite 255/256; y
a partir de v5.22, genera una advertencia de configuración regional.
De lo contrario, si EXPR tiene el indicador UTF8 establecido:
Las reglas Unicode se utilizan para el cambio de mayúsculas y minúsculas.
De lo contrario, si "usar función 'unicode_strings'" o "usar configuración regional ':not_characters'" está en
efecto:
Las reglas Unicode se utilizan para el cambio de mayúsculas y minúsculas.
De otra manera:
Las reglas ASCII se utilizan para el cambio de mayúsculas y minúsculas. La minúscula de cualquier carácter fuera
el rango ASCII es el carácter en sí.
primera EXPR
primero
Devuelve el valor de EXPR con el primer carácter en minúsculas. este es el interno
función que implementa el escape "\l" en cadenas entre comillas dobles.
Si se omite EXPR, utiliza $_.
Esta función se comporta de la misma manera bajo varios pragmas, como en un lugar, como
"lc" lo hace.
longitud EXPR
de largo
Devuelve la longitud en personajes del valor de EXPR. Si se omite EXPR, devuelve
la longitud de $_. Si EXPR no está definido, devuelve "undef".
Esta función no se puede usar en una matriz completa o hash para averiguar cuántos elementos
éstas tienen. Para eso, use "scalar @array" y "scalar keys %hash", respectivamente.
Como todas las operaciones de caracteres de Perl, longitud () normalmente trata con caracteres lógicos, no
bytes físicos. Para saber cuántos bytes ocuparía una cadena codificada como UTF-8, utilice
"longitud (Encode::encode_utf8 (EXPR))" (primero tendrá que "usar Encode"). Ver Codificar
y perlunicode.
__LÍNEA__
Un token especial que compila al número de línea actual.
enlace ARCHIVO VIEJO, ARCHIVO NUEVO
Crea un nuevo nombre de archivo vinculado al antiguo nombre de archivo. Devuelve verdadero para el éxito, falso
de otra manera.
Problemas de portabilidad: "enlace" en perlport.
escuchar SOCKET,QUEUESIZE
Hace lo mismo que el escuchan(2) la llamada al sistema sí. Devuelve verdadero si
éxito, falso de lo contrario. Ver el ejemplo en "Sockets: Comunicación Cliente/Servidor"
en perlipc.
EXPR locales
Probablemente quieras usar "mi" en su lugar, porque "local" no es lo que más
la gente piensa que son "locales". Consulte "Variables privadas mediante mi()" en perlsub para más detalles.
Un local modifica las variables listadas para que sean locales al bloque, archivo o
evaluar Si se enumera más de un valor, la lista debe colocarse entre paréntesis. Ver
"Valores temporales a través de local()" en perlsub para más detalles, incluidos problemas con enlaces
matrices y hashes.
La construcción "eliminar EXPR local" también se puede utilizar para localizar la eliminación de
elementos de matriz/hash al bloque actual. Consulte "Eliminación localizada de elementos de
tipos compuestos" en perlsub.
hora local EXPR
hora local
Convierte una hora devuelta por la función de hora en una lista de 9 elementos con la hora
analizado para la zona horaria local. Normalmente se utiliza de la siguiente manera:
# 0 1 2 3 4 5 6 7 8
($seg,$min,$hora,$mday,$mon,$year,$wday,$yday,$isdst) =
horalocal(hora);
Todos los elementos de la lista son numéricos y provienen directamente de C `struct tm'. $seg, $min,
y $hora son los segundos, minutos y horas de la hora especificada.
$mday es el día del mes y $mon el mes en el rango 0..11, con 0 indicando
enero y 11 indicando diciembre. Esto hace que sea fácil obtener un nombre de mes de un
lista:
my @abbr = qw(Ene Feb Mar Abr May Jun Jul Ago Sep Oct Nov Dic);
print "$abbr[$mon] $mday";
# $mon=9, $mday=18 da "18 de octubre"
$year contiene el número de años desde 1900. Para obtener un año de 4 dígitos, escriba:
$año += 1900;
Para obtener los dos últimos dígitos del año (p. ej., "01" en 2001), haga lo siguiente:
$año = sprintf("%02d", $año % 100);
$wday es el día de la semana, donde 0 indica domingo y 3 indica miércoles.
$yday es el día del año, en el rango 0..364 (o 0..365 en años bisiestos).
$isdst es verdadero si la hora especificada ocurre durante el horario de verano, falso
de otra manera.
Si se omite EXPR, "localtime()" usa la hora actual (tal como lo devuelve time(3)).
En contexto escalar, "localtime()" devuelve el ctime(3) valor:
$ahora_cadena = horalocal; # p. ej., "Jue 13 de octubre 04:54:34 1994"
El formato de este valor escalar es no dependiente de la configuración regional pero integrado en Perl. Para GMT
en lugar de la hora local, use el incorporado "gmtime". Ver también el módulo "Hora::Local"
(para convertir segundos, minutos, horas y demás al valor entero devuelto
by hora()) y el módulo POSIX Strftime(3) y tiempo mk(3) funciones.
Para obtener cadenas de fecha algo similares pero dependientes de la configuración regional, configure su configuración regional
variables de entorno de manera adecuada (consulte perllocale) e intente, por ejemplo:
use POSIX qw (strftime);
$now_string = strftime "%a %b %e %H:%M:%S %Y", horalocal;
# o para GMT con el formato apropiado para su localidad:
$now_string = strftime "%a %b %e %H:%M:%S %Y", gmtime;
Tenga en cuenta que %a y %b, las formas abreviadas del día de la semana y el mes del
año, puede no tener necesariamente tres caracteres de ancho.
Los módulos Time::gmtime y Time::localtime proporcionan un cómodo acceso por nombre
mecanismo a la gmtime () y hora local() funciones, respectivamente.
Para obtener una representación completa de la fecha y la hora, consulte el módulo DateTime en CPAN.
Problemas de portabilidad: "localtime" en perlport.
bloquear COSA
Esta función coloca un bloqueo de aviso en una variable compartida o un objeto al que se hace referencia
contenida en COSA hasta que el candado quede fuera del alcance.
El valor devuelto es el propio escalar, si el argumento es un escalar o una referencia,
si el argumento es un hash, una matriz o una subrutina.
cerrar con llave() es una "palabra clave débil": esto significa que si ha definido una función con este nombre
(antes de cualquier llamada), se llamará a esa función en su lugar. Si no estás bajo
"usar hilos:: compartidos" esto no hace nada. Ver hilos::compartidos.
EXPR de registro
log Devuelve el logaritmo natural (base e) de EXP. Si se omite EXPR, devuelve el registro
de $_. Para obtener el logaritmo de otra base, usa álgebra básica: El logaritmo en base N de un número
es igual al logaritmo natural de ese número dividido por el logaritmo natural de N. Para
ejemplo:
registro secundario10 {
my $ n = turno;
registro de retorno ($ n) /log(10);
}
Véase también "exp" para la operación inversa.
lstat IDENTIFICADOR DE ARCHIVO
lstat EXPR
lstat DIRHANDLE
lstat
Hace lo mismo que la función "stat" (incluida la configuración del "_" especial
filehandle) pero establece un enlace simbólico en lugar del archivo al que apunta el enlace simbólico.
Si los enlaces simbólicos no están implementados en su sistema, se realiza una "estadística" normal. Por mucho
información más detallada, consulte la documentación de "stat".
Si se omite EXPR, las estadísticas son $_.
Problemas de portabilidad: "lstat" en perlport.
m// El operador de coincidencia. Consulte "Operadores similares a cotizaciones Regexp" en perlop.
mapa LISTA DE BLOQUES
mapa EXPR,LISTA
Evalúa el BLOCK o EXPR para cada elemento de LIST (estableciendo localmente $_ para cada
elemento) y devuelve el valor de la lista compuesta por los resultados de cada evaluación.
En contexto escalar, devuelve el número total de elementos así generados. Evalúa BLOQUE
o EXPR en contexto de lista, por lo que cada elemento de LIST puede producir cero, uno o más
elementos en el valor devuelto.
@chars = mapa(chr, @numbers);
traduce una lista de números a los caracteres correspondientes.
mis @cuadrados = map { $_ * $_ } @numbers;
traduce una lista de números a sus valores cuadrados.
mis @cuadrados = mapa { $_ > 5 ? ($_ * $_) : () } @números;
muestra que el número de elementos devueltos puede diferir del número de elementos de entrada.
Para omitir un elemento, devuelva una lista vacía (). Esto también podría lograrse escribiendo
my @squares = map { $_ * $_ } grep { $_ > 5 } @numbers;
lo que hace más clara la intención.
El mapa siempre devuelve una lista, que se puede asignar a un hash de modo que los elementos
convertirse en pares clave/valor. Ver perldata para más detalles.
%hash = map { get_a_key_for($_) => $_ } @array;
es solo una forma divertida de escribir
% hash = ();
foreach (@matriz) {
$hash{get_a_key_for($_)} = $_;
}
Tenga en cuenta que $_ es un alias para el valor de la lista, por lo que puede usarse para modificar los elementos
de la LISTA. Si bien esto es útil y compatible, puede causar resultados extraños si el
los elementos de LIST no son variables. Usando un bucle "foreach" regular para este propósito
sería más claro en la mayoría de los casos. Ver también "grep" para una matriz compuesta por esos elementos
de la lista original para la que BLOCK o EXPR se evalúa como verdadero.
Si $_ es léxico en el ámbito donde aparece el "mapa" (porque ha sido declarado
con la obsoleta construcción "my $_"), entonces, además de tener un alias local para
los elementos de la lista, $_ sigue siendo léxico dentro del bloque; es decir, no se puede ver
desde el exterior, evitando posibles efectos secundarios.
"{" inicia tanto las referencias hash como los bloques, por lo que "mapa { ..." podría ser el inicio
del mapa BLOCK LIST o mapa EXPR, LIST. Porque Perl no mira hacia adelante para el cierre.
"}" tiene que adivinar con qué está tratando en función de lo que encuentra
después de la "{". Por lo general, lo hace bien, pero si no lo hace, no se dará cuenta de algo.
está mal hasta que llega a "}" y encuentra la coma faltante (o inesperada).
El error de sintaxis se informará cerca de "}", pero deberá cambiar
algo cerca de "{", como usar un "+" unario o un punto y coma para ayudar a Perl:
%hash = map { "\L$_" => 1 } @array # perl adivina EXPR. equivocado
%hash = map { +"\L$_" => 1 } @array # perl adivina BLOQUE. derecho
% hash = mapa {; "\L$_" => 1 } @array # esto también funciona
%hash = map { ("\L$_" => 1) } @array # como hace esto
%hash = map { lc($_) => 1 } @array # y esto.
%hash = map +( lc($_) => 1 ), @array # ¡esto es EXPR y funciona!
%hash = mapa ( lc($_), 1 ), @array # se evalúa como (1, @array)
o para forzar un constructor anon hash use "+{":
@hashes = map +{ lc($_) => 1 }, @array # EXPR, por lo que necesita
# coma al final
para obtener una lista de hashes anónimos, cada uno con una sola entrada.
mkdir NOMBRE DE ARCHIVO, MÁSCARA
mkdir NOMBRE DE ARCHIVO
mkdir
Crea el directorio especificado por FILENAME, con permisos especificados por MASK (como
modificado por "umask"). Si tiene éxito, devuelve verdadero; de lo contrario, devuelve falso y
establece $! (errno). MASK por defecto es 0777 si se omite, y FILENAME por defecto es $_ si
omitido.
En general, es mejor crear directorios con una MASCARA permisiva y dejar que el usuario
modificar eso con su "umask" de lo que es proporcionar una MÁSCARA restrictiva y dar la
usuario no hay forma de ser más permisivo. Las excepciones a esta regla son cuando el archivo o
directorio debe mantenerse privado (archivos de correo, por ejemplo). los perlfunc(1) entrada en
"umask" analiza la elección de MÁSCARA con más detalle.
Tenga en cuenta que de acuerdo con POSIX 1003.1-1996, el NOMBRE DE ARCHIVO puede tener cualquier número de
barras inclinadas. Algunos sistemas operativos y de archivos no hacen esto bien, así que Perl
elimina automáticamente todas las barras inclinadas finales para mantener a todos contentos.
Para crear recursivamente una estructura de directorios, mire la función "make_path" del
Archivo::módulo de ruta.
msgctlID,CMD,ARG
Llama a la función System V IPC msgctl(2). Probablemente tendrás que decir
utilizar IPC::SysV;
primero en obtener las definiciones constantes correctas. Si CMD es "IPC_STAT", entonces ARG debe ser
una variable que contendrá la estructura "msqid_ds" devuelta. Devuelve como "ioctl":
el valor indefinido para el error, "0 pero verdadero" para cero, o el valor de retorno real
de lo contrario. Consulte también "SysV IPC" en perlipc y la documentación de "IPC::SysV" y
"IPC::Semáforo".
Problemas de portabilidad: "msgctl" en perlport.
msgget CLAVE, BANDERAS
Llama a la función System V IPC mensaje(2). Devuelve la identificación de la cola de mensajes, o "undef"
en error Consulte también "SysV IPC" en perlipc y la documentación de "IPC::SysV" y
"IPC::Mensaje".
Problemas de portabilidad: "msgget" en perlport.
msgrcv ID,VAR,TAMAÑO,TIPO,BANDERAS
Llama a la función msgrcv de System V IPC para recibir un mensaje de ID de cola de mensajes en
variable VAR con un tamaño de mensaje máximo de SIZE. Tenga en cuenta que cuando un mensaje es
recibido, el tipo de mensaje como un entero largo nativo será lo primero en VAR,
seguido del mensaje real. Este embalaje puede abrirse con "unpack("l! a*")".
Mancha la variable. Devuelve verdadero si tiene éxito, falso en caso de error. Véase también "SysV IPC"
en perlipc y la documentación para "IPC::SysV" y "IPC::SysV::Msg".
Problemas de portabilidad: "msgrcv" en perlport.
msjsnd ID,MSG,BANDERAS
Llama a la función msgsnd de System V IPC para enviar el mensaje MSG a la cola de mensajes.
IDENTIFICACIÓN. MSG debe comenzar con el tipo de mensaje de entero largo nativo, seguido del
longitud del mensaje real y, finalmente, el mensaje en sí. Este tipo de
El empaquetado se puede lograr con "pack("l! a*", $tipo, $mensaje)". Devuelve verdadero si
exitoso, falso en caso de error. Consulte también "IPC::SysV" y "IPC::SysV::Msg"
documentación.
Problemas de portabilidad: "msgsnd" en perlport.
mi LISTA DE VARIOS
mi TIPO VARLIST
mi LISTA DE VARL: ATTRS
mi TIPO VARLIST: ATTRS
Un "my" declara que las variables enumeradas son locales (léxicamente) al bloque que las encierra,
archivo, o "eval". Si se enumera más de una variable, la lista debe colocarse en
paréntesis.
La semántica exacta y la interfaz de TYPE y ATTRS aún están evolucionando. TIPO puede ser un
simple, una constante declarada con "usar constante" o "__PAQUETE__". es actualmente
ligado al uso del pragma de "campos", y los atributos se manejan usando el
pragma de "atributos", o a partir de Perl 5.8.0 también a través de "Atributo::Manejadores"
módulo. Consulte "Variables privadas mediante mi()" en perlsub para detalles y campos,
atributos y Atributo::Manejadores.
Tenga en cuenta que con una lista entre paréntesis, "undef" se puede usar como un marcador de posición ficticio, por
ejemplo para omitir la asignación de valores iniciales:
my ( undef, $min, $hora ) = horalocal;
siguiente ETIQUETA
próximo EXPR
Next
El comando "siguiente" es como la instrucción "continuar" en C; comienza la siguiente iteración
del bucle:
LINE: mientras ( ) {
siguiente LINE si / ^ # /; # descartar comentarios
# ...
}
Tenga en cuenta que si hubiera un bloque "continuar" en lo anterior, se ejecutaría incluso en
líneas descartadas. Si se omite LABEL, el comando se refiere al contenedor más interno
círculo. El formulario "siguiente EXPR", disponible a partir de Perl 5.18.0, permite que se
calculado en tiempo de ejecución, siendo por lo demás idéntico a "siguiente ETIQUETA".
"siguiente" no se puede usar para salir de un bloque que devuelve un valor como "eval {}", "sub
{}", o "do {}", y no debe usarse para salir de un grep () or mapa() operación.
Tenga en cuenta que un bloque en sí mismo es semánticamente idéntico a un bucle que se ejecuta una vez.
Por lo tanto, "siguiente" saldrá antes de ese bloque.
Consulte también "continuar" para ver una ilustración de cómo funcionan "último", "siguiente" y "rehacer".
A diferencia de la mayoría de los operadores con nombre, tiene la misma prioridad que la asignación. Tambien es
exento de la regla de parecerse a una función, por lo que "siguiente ("foo"). "bar"" causará "bar"
ser parte del argumento de "siguiente".
LISTA DE VERSIONES DE MÓDULOS
VERSIÓN DEL MÓDULO
LISTA DE MÓDULOS
sin MÓDULO
sin VERSIÓN
Véase la función "usar", de la cual "no" es lo contrario.
oct EXPR
oct Interpreta EXPR como una cadena octal y devuelve el valor correspondiente. (Si EXPR
sucede que comienza con "0x", lo interpreta como una cadena hexadecimal. Si EXPR comienza
con "0b", se interpreta como una cadena binaria. Los espacios en blanco iniciales se ignoran en todos
tres casos). Lo siguiente manejará decimal, binario, octal y hexadecimal en formato estándar.
Notación Perl:
$val = oct($val) si $val =~ /^0/;
Si se omite EXPR, utiliza $_. Para ir hacia el otro lado (producir un número en octal), use
sprintf () or printf ():
$dec_perms = (stat("nombre de archivo"))[2] & 07777;
$oct_perm_str = sprintf "%o", $perms;
El oct() La función se usa comúnmente cuando una cadena como 644 necesita ser convertida
en un modo de archivo, por ejemplo. Aunque Perl convierte cadenas automáticamente en
números según sea necesario, esta conversión automática asume la base 10.
Los espacios en blanco iniciales se ignoran sin previo aviso, al igual que cualquier no dígito final,
como un punto decimal ("oct" solo maneja números enteros no negativos, no negativos
números enteros o punto flotante).
abierto IDENTIFICADOR DE ARCHIVO,EXPR
abierto IDENTIFICADOR DE ARCHIVO, MODO, EXPR
abrir ARCHIVO,MODO,EXPR,LISTA
open IDENTIFICADOR DE ARCHIVO, MODO, REFERENCIA
abrir IDENTIFICADOR DE ARCHIVO
Abre el archivo cuyo nombre de archivo viene dado por EXPR y lo asocia con FILEHANDLE.
Ejemplos simples para abrir un archivo para leer:
abrir(mi $fh, "<", "entrada.txt")
o die "no se puede abrir < input.txt: $!";
y por escribir:
abierto(mi $fh, ">", "salida.txt")
o morir "no se puede abrir> salida.txt: $!";
(La siguiente es una referencia completa a open(): para una presentación más amable
puede considerar perlopentut.)
Si IDENTIFICADOR DE ARCHIVO es una variable escalar indefinida (o una matriz o un elemento hash), una nueva
filehandle se autovivifica, lo que significa que a la variable se le asigna una referencia a un
identificador de archivo anónimo recién asignado. De lo contrario, si FILEHANDLE es una expresión, su
value es el identificador de archivo real. (Esto se considera una referencia simbólica, así que "use
estrictas "refs"" deben no estar en efecto.)
Si se especifican tres (o más) argumentos, el modo abierto (incluidos los opcionales)
codificación) en el segundo argumento son distintos del nombre de archivo en el tercero. Si MODO
es "<" o nada, el archivo se abre para la entrada. Si MODE es ">", el archivo se abre
para la salida, con los archivos existentes primero truncados ("golpeados") y no existentes
archivos recién creados. Si MODE es ">>", el archivo se abre para agregarlo, siendo nuevamente
creado si es necesario.
Puede poner un "+" delante de ">" o "<" para indicar que desea leer y
acceso de escritura al archivo; por lo tanto, casi siempre se prefiere "+<" para lectura/escritura
actualizaciones: el modo "+>" golpearía el archivo primero. Por lo general, tampoco puedes usar
Modo de lectura y escritura para actualizar archivos de texto, ya que tienen registros de longitud variable. Ver
de la forma más -i cambie en perlrun para un mejor enfoque. El archivo se crea con permisos.
de 0666 modificado por el valor "umask" del proceso.
Estos diversos prefijos corresponden a los abierto(3) modos de "r", "r+", "w", "w+", "a",
y "a+".
En las formas de uno y dos argumentos de la llamada, el modo y el nombre del archivo deben ser
concatenados (en ese orden), preferiblemente separados por espacios en blanco. Puedes - pero
no debería--omitir el modo en estos formularios cuando ese modo es "<". Siempre es seguro
use la forma de dos argumentos de "abrir" si el argumento del nombre de archivo es un literal conocido.
Para tres o más argumentos si MODE es "|-", el nombre del archivo se interpreta como un comando
a la que se va a canalizar la salida, y si MODE es "-|", el nombre del archivo se interpreta como un
comando que canaliza la salida hacia nosotros. En la forma de dos argumentos (y de un argumento), uno
debe reemplazar el guión ("-") con el comando. Consulte "Uso open() para IPC" en perlipc para
más ejemplos de esto. (No se le permite "abrir" a un comando que canaliza tanto en
y pero consulte IPC::Open2, IPC::Open3 y "Comunicación bidireccional con otro
Proceso" en perlipc para alternativas).
En forma de tubería se abre tomando tres o más argumentos, si se especifica LISTA (extra
argumentos después del nombre del comando) entonces LIST se convierte en argumentos para el comando invocado
si la plataforma lo admite. El significado de "abierto" con más de tres argumentos a favor
los modos sin tubería aún no están definidos, pero las "capas" experimentales pueden proporcionar una LISTA adicional
significado de los argumentos.
En la forma de dos argumentos (y un argumento), al abrir "<-" o "-" se abre STDIN y
abrir ">-" abre STDOUT.
Puede (y generalmente debe) usar la forma de tres argumentos de abierto para especificar capas de E/S
(a veces denominadas "disciplinas") para aplicar al mango que afectan la forma en que
la entrada y la salida se procesan (consulte open y PerlIO para obtener más detalles). Por ejemplo:
open(mi $fh, "<:codificación(UTF-8)", "nombre de archivo")
|| die "no se puede abrir el nombre de archivo codificado en UTF-8: $!";
abre el archivo codificado en UTF8 que contiene caracteres Unicode; ver perluniintro. Nota
que si las capas se especifican en la forma de tres argumentos, entonces las capas predeterminadas almacenadas en
${^OPEN} (ver perlvar; generalmente establecido por el abierto pragma o el interruptor -CioD) son
ignorado Esas capas también se ignorarán si especifica dos puntos sin nombre
siguiéndolo. En ese caso, la capa predeterminada para el sistema operativo (:raw en Unix,
:crlf en Windows) se utiliza.
Open devuelve distinto de cero en caso de éxito, el valor indefinido de lo contrario. Si el "abierto"
involucró una tubería, el valor de retorno pasa a ser el pid del subproceso.
Si está ejecutando Perl en un sistema que distingue entre archivos de texto y binarios
archivos, entonces debe consultar "binmode" para obtener consejos sobre cómo lidiar con esto. La clave
distinción entre los sistemas que necesitan "binmode" y los que no es su texto
formatos de archivo. Sistemas como Unix, Mac OS y Plan 9, que terminan líneas con un solo
carácter y codificar ese carácter en C como "\ n" no necesita "binmode". El resto necesita
él.
Al abrir un archivo, rara vez es una buena idea continuar si la solicitud falló, por lo que
"abierto" se usa frecuentemente con "morir". Incluso si "morir" no hace lo que quieres (digamos, en un
Script CGI, donde desea formatear un mensaje de error adecuado (pero hay módulos
eso puede ayudar con ese problema)) siempre verifique el valor devuelto al abrir un archivo.
El identificador de archivo se cerrará cuando su cuenta de referencia llegue a cero. si es un
variable de alcance léxico declarada con "mi", que generalmente significa el final de la
alcance envolvente. Sin embargo, este cierre automático no comprueba si hay errores, por lo que es
es mejor cerrar explícitamente los identificadores de archivos, especialmente los que se usan para escribir:
cerrar ($ manejar)
|| advertir "cierre fallido: $!";
Un estilo más antiguo es usar una palabra simple como identificador de archivo, como
abierto(FH, "<", "entrada.txt")
o die "no se puede abrir < input.txt: $!";
Luego puede usar "FH" como identificador de archivo, en "cerrar FH" y " " y así sucesivamente. Nota
que es una variable global, por lo que no se recomienda esta forma en el código nuevo.
Como atajo, una llamada de un argumento toma el nombre de archivo de la variable escalar global
del mismo nombre que el identificador de archivo:
$ARTÍCULO = 100;
open(ARTÍCULO) or die "No se puede encontrar el artículo $ARTÍCULO: $!\n";
Aquí $ARTÍCULO debe ser una variable escalar global (paquete), no una declarada con "mi"
o "estado".
Como caso especial, la forma de tres argumentos con un modo de lectura/escritura y el tercer
el argumento es "undef":
abrir(mi $tmp, "+>", undef) o morir...
abre un identificador de archivo a un archivo temporal anónimo. También usar "+<" funciona para
simetría, pero realmente debería considerar escribir algo en el archivo temporal
primero. Necesitaras buscar() para hacer la lectura.
Perl está construido usando PerlIO por defecto; A menos que haya cambiado esto (como construir
Perl con "Configurar -Uuseperlio"), puede abrir identificadores de archivos directamente a los escalares de Perl
vía:
abierto($fh, ">", \$variable) || ..
Para (re)abrir "STDOUT" o "STDERR" como un archivo en memoria, ciérrelo primero:
cerrar STDOUT;
abierto(STDOUT, ">", \$variable)
o morir "No se puede abrir STDOUT: $!";
Ejemplos generales:
open(REGISTRO, ">>/usr/spool/noticias/twitlog"); # (el registro está reservado)
# si la apertura falla, la salida se descarta
open(my $dbase, "+<", "dbase.mine") # abrir para actualizar
o muere "No se puede abrir 'dbase.mine' para actualizar: $!";
abrir(mi $base de datos, "+
o muere "No se puede abrir 'dbase.mine' para actualizar: $!";
open(ARTÍCULO, "-|", "caesar <$artículo") # descifrar artículo
or die "No puedo iniciar caesar: $!";
open(ARTÍCULO, "césar <$artículo |") # ídem
or die "No puedo iniciar caesar: $!";
open(EXTRACT, "|sort >Tmp$$") # $$ es nuestro ID de proceso
o morir "No se puede empezar a ordenar: $!";
# archivos en memoria
abrir(MEMORIA, ">", \$var)
o morir "No se puede abrir el archivo de memoria: $!";
imprimir MEMORIA "foo!\n"; # salida aparecerá en $var
# lista de argumentos de proceso de archivos junto con cualquier inclusión
foreach $archivo (@ARGV) {
proceso($archivo, "fh00");
}
subproceso {
mi($nombre de archivo, $entrada) = @_;
$entrada++; # esto es un incremento de cadena
a menos que (abrir ($ entrada, "<", $ nombre de archivo)) {
print STDERR "No se puede abrir $nombre de archivo: $!\n";
volver;
}
locales $_;
while (<$input>) { # nota uso de direccionamiento indirecto
si (/^#incluye "(.*)"/) {
proceso ($1, $entrada);
Siguiente;
}
#... # lo que
}
}
Consulte perliol para obtener información detallada sobre PerlIO.
También puede, en la tradición de shell de Bourne, especificar un EXPR que comience con ">&", en
cuyo caso, el resto de la cadena se interpreta como el nombre de un identificador de archivo (o archivo
descriptor, si es numérico) para ser engañado (como dup(2)) y abierto. Puede usar "&" después
">", ">>", "<", "+>", "+>>" y "+<". El modo que especifique debe coincidir con el modo de
el identificador de archivo original. (La duplicación de un identificador de archivo no tiene en cuenta ningún
contenido de los búferes de E/S.) Si utiliza la forma de tres argumentos, puede pasar
un número, el nombre de un identificador de archivo o la "referencia normal a un globo".
Aquí hay un script que guarda, redirige y restaura "STDOUT" y "STDERR" usando
varios métodos:
#!/ usr / bin / perl
open(my $oldout, ">&STDOUT") or die "No se puede duplicar STDOUT: $!";
open(OLDERR, ">&", \*STDERR) o die "No se puede duplicar STDERR: $!";
open(STDOUT, '>', "foo.out") o die "No se puede redirigir STDOUT: $!";
open(STDERR, ">&STDOUT") o die "No se puede duplicar STDOUT: $!";
seleccione STDERR; $| = 1; # hacer sin búfer
seleccione SALIDA ESTÁNDAR; $| = 1; # hacer sin búfer
imprimir STDOUT "stdout 1\n"; # esto funciona para
imprimir STDERR "stderr 1\n"; # subprocesos también
open(STDOUT, ">&", $oldout) or die "No se puede duplicar \$oldout: $!";
open(STDERR, ">&OLDERR") or die "No se puede duplicar OLDERR: $!";
imprimir STDOUT "salida estándar 2\n";
imprimir STDERR "stderr 2\n";
Si especifica '<&=X', donde "X" es un número de descriptor de archivo o un identificador de archivo, entonces
Perl hará un equivalente de "fdopen" de C de ese descriptor de archivo (y no llamará
dup(2)); esto es más parsimonioso de los descriptores de archivo. Por ejemplo:
# abierto para entrada, reutilizando el archivo no de $fd
abrir(IDENTIFICADOR DE ARCHIVO, "<&=$fd")
or
abierto (MANejador de archivo, "<&=", $fd)
or
# abrir para agregar, usando el fileno de OLDFH
abierto(FH, ">>&=", OLDFH)
or
abierto(FH, ">>&=OLDFH")
Ser parco en los identificadores de archivo también es útil (además de ser parco) para
ejemplo cuando algo depende de los descriptores de archivo, como por ejemplo el bloqueo
usando rebaño(). Si simplemente "abre (A, ">>&B")", el identificador de archivo A no tendrá el
mismo descriptor de archivo que B, y por lo tanto la bandada (A) no la bandada (B) ni viceversa.
Pero con "open(A, ">>&=B")", los identificadores de archivo compartirán el mismo sistema subyacente
descriptor de archivo.
Tenga en cuenta que en Perls anteriores a 5.8.0, Perl usa la biblioteca C estándar fdopen ()
para implementar la funcionalidad "=". En muchos sistemas Unix, fdopen () falla cuando el archivo
descriptores superan un cierto valor, normalmente 255. Para Perls 5.8.0 y versiones posteriores, PerlIO
es (la mayoría de las veces) el predeterminado.
Puede ver si su Perl se creó con PerlIO ejecutando "perl -V" y mirando
para la línea "useperlio=". Si "useperlio" es "define", tiene PerlIO; de lo contrario, tú
no lo hagas
Si abre una tubería con el comando "-" (es decir, especifique "|-" o "-|" con el
formas de uno o dos argumentos de "abrir"), se realiza una "bifurcación" implícita, por lo que "abrir" devuelve
dos veces: en el proceso padre devuelve el pid del proceso hijo, y en el hijo
proceso devuelve (un definido) 0. Use "definido ($ pid)" o "//" para determinar si
la apertura fue un éxito.
Por ejemplo, utilice cualquiera
$child_pid = open(FROM_KID, "-|") // die "no se puede bifurcar: $!";
or
$child_pid = open(TO_KID, "|-") // die "no se puede bifurcar: $!";
seguido por
si ($child_pid) {
# soy el padre:
# escribe TO_KID o lee FROM_KID
...
esperarpid $niño_pid, 0;
} Else {
# soy el niño; use STDIN/STDOUT normalmente
...
Salida;
}
El identificador de archivo se comporta normalmente para el padre, pero la E/S a ese identificador de archivo se canaliza
desde/hacia STDOUT/STDIN del proceso hijo. En el proceso hijo, el identificador de archivo
no está abierto: la E/S ocurre desde/hacia el nuevo STDOUT/STDIN. Por lo general, esto se usa como
la tubería normal se abre cuando desea ejercer más control sobre cómo la tubería
el comando se ejecuta, como cuando se ejecuta setuid y no desea tener que escanear
Comandos de shell para metacaracteres.
Los siguientes bloques son más o menos equivalentes:
abrir(FOO, "|tr '[az]' '[AZ]'");
abierto(FOO, "|-", "tr '[az]' '[AZ]'");
abierto(FOO, "|-") || exec 'tr', '[az]', '[AZ]';
abierto(FOO, "|-", "tr", '[az]', '[AZ]');
open(FOO, "gato -n '$archivo'|");
open(FOO, "-|", "cat -n '$archivo'");
abierto(FOO, "-|") || exec "gato", "-n", $archivo;
open(FOO, "-|", "gato", "-n", $archivo);
Los últimos dos ejemplos en cada bloque muestran la tubería como "forma de lista", que aún no está
Compatible con todas las plataformas. Una buena regla general es que si su plataforma tiene un verdadero
"fork()" (en otras palabras, si su plataforma es Unix, incluyendo Linux y MacOS X), usted
puede utilizar el formulario de lista. Le gustaría usar la forma de lista de la tubería para que pueda
pasar argumentos literales al comando sin riesgo de que el shell interprete cualquier shell
metacaracteres en ellos. Sin embargo, esto también le impide abrir conductos a comandos.
que intencionalmente contienen metacaracteres de shell, como:
abierto(FOO, "|gato -n | expandir -4 | lpr")
// die "No se puede abrir la canalización a lpr: $!";
Consulte "Aperturas seguras de tuberías" en perlipc para obtener más ejemplos de esto.
Perl intentará vaciar todos los archivos abiertos para la salida antes de cualquier operación que pueda
hacer una bifurcación, pero es posible que esto no sea compatible con algunas plataformas (ver perlport). Ser - estar
seguro, es posible que deba configurar $| ($AUTOFLUSH en inglés) o llamar al método "autoflush()"
de "IO::Handle" en cualquier identificador abierto.
En los sistemas que admiten un indicador de cierre en el ejecutivo en los archivos, el indicador se establecerá para el
descriptor de archivo recién abierto determinado por el valor de $^F. Ver "$^F" en perlvar.
Cerrar cualquier identificador de archivo canalizado hace que el proceso padre espere a que el hijo
finish, luego devuelve el valor de estado en $? y "${^CHILD_ERROR_NATIVE}".
El nombre de archivo pasó a las formas de uno y dos argumentos de open() tendrá liderazgo y
Se eliminan los espacios en blanco finales y se respetan los caracteres de redirección normales. Esta propiedad,
conocida como "magia abierta", a menudo se puede utilizar con buenos resultados. Un usuario podría especificar un
nombre de archivo de "rsh gato presentar |", o puede cambiar ciertos nombres de archivo según sea necesario:
$nombre de archivo =~ s/(.*\.gz)\s*$/gzip -dc < $1|/;
open(FH, $nombredearchivo) or die "No se puede abrir $nombredearchivo: $!";
Use el formulario de tres argumentos para abrir un archivo con caracteres extraños arbitrarios,
abierto(FOO, "<", $archivo)
|| die "no se puede abrir < $archivo: $!";
de lo contrario, es necesario proteger cualquier espacio en blanco inicial y final:
$archivo =~ s#^(\s)#./$1#;
abierto(FOO, "< $archivo\0")
|| die "fallo al abrir: $!";
(esto puede no funcionar en algunos sistemas de archivos extraños). Uno debe elegir conscientemente
entre las magic y tres argumentos forma de open():
abierto(ENTRADA, $ARGV[0]) || die "no se puede abrir $ARGV[0]: $!";
permitirá al usuario especificar un argumento de la forma "rsh cat file |", pero no
trabajar en un nombre de archivo que tiene un espacio final, mientras que
abierto(ENTRADA, "<", $ARGV[0])
|| die "no se puede abrir < $ARGV[0]: $!";
tendrá exactamente las restricciones opuestas.
Si desea una C "real" "abierta" (consulte abierto(2) en su sistema), entonces debe usar el
función "sysopen", que no implica tal magia (pero puede usar sutilmente diferentes
modos de archivo que Perl open(), que se asigna a C fopen ()). Esta es otra manera de
proteja sus nombres de archivo de la interpretación. Por ejemplo:
use IO :: Handle;
sysopen(HANDLE, $ruta, O_RDWR|O_CREAT|O_EXCL)
o muere "sysopen $ruta: $!";
$oldfh = select(MANGO); $| = 1; select($oldfh);
imprimir MANGO "cosas $$\n";
buscar (MANGO, 0, 0);
imprimir "El archivo contiene: ", ;
Consulte "buscar" para obtener algunos detalles sobre la combinación de lectura y escritura.
Problemas de portabilidad: "abierto" en perlport.
opendir DIRHANDLE,EXPR
Abre un directorio llamado EXPR para ser procesado por "readdir", "telldir", "seekdir",
"rewinddir" y "closedir". Devuelve verdadero si tiene éxito. DIRHANDLE puede ser un
expresión cuyo valor se puede utilizar como un dirhandle indirecto, por lo general el real
nombre del identificador. Si DIRHANDLE es una variable escalar indefinida (o matriz o hash
elemento), a la variable se le asigna una referencia a un nuevo dirhandle anónimo; es decir,
es autovivificado. Los DIRHANDLE tienen su propio espacio de nombres separado de los FILEHANDLE.
Vea el ejemplo en "readdir".
pedido EXPR
ord Devuelve el valor numérico del primer carácter de EXPR. Si EXPR es una cadena vacía,
devuelve 0. Si se omite EXPR, utiliza $_. (Nota personaje, no byte.)
Para el reverso, véase "chr". Consulte perlunicode para obtener más información sobre Unicode.
nuestra LISTA DE VARIOS
nuestro TIPO VARLIST
nuestra LISTA DE VARL: ATTRS
nuestro TIPO VARLIST: ATTRS
"nuestro" crea un alias léxico para una variable de paquete (es decir, global) del mismo nombre en
el paquete actual para su uso dentro del ámbito léxico actual.
"nuestro" tiene las mismas reglas de alcance que "mi" o "estado", lo que significa que solo es válido
dentro de un ámbito léxico. A diferencia de "mi" y "estado", que declaran nuevo (léxico)
variables, "nuestro" solo crea un alias para una variable existente: una variable de paquete de
el mismo nombre.
Esto significa que cuando "usar 'vars' estrictos" está en vigor, "nuestro" le permite usar un paquete
variable sin calificarla con el nombre del paquete, pero solo dentro del léxico
alcance de la declaración "nuestro". Esto se aplica de inmediato, incluso dentro del mismo
.
paquete Foo;
uso estricto
$foo::foo = 23;
{
nuestro $foo; # alias para $Foo::foo
imprimir $foo; # impresiones 23
}
imprimir $Foo::foo; # impresiones 23
imprimir $foo; # ERROR: requiere un nombre de paquete explícito
Esto funciona incluso si la variable del paquete no se ha utilizado antes, como variables del paquete
cobra existencia cuando se usa por primera vez.
paquete Foo;
uso estricto
nuestro $foo = 23; # como $Foo::foo = 23
imprimir $Foo::foo; # impresiones 23
Debido a que la variable se vuelve legal inmediatamente bajo "usar 'vars' estrictas", siempre que
no hay ninguna variable con ese nombre que ya esté en el alcance, luego puede hacer referencia a la
variable de paquete nuevamente incluso dentro de la misma declaración.
paquete Foo;
uso estricto
mi $foo = $foo; # error, $foo no declarado en el lado derecho
nuestro $foo = $foo; # sin errores
Si se enumera más de una variable, la lista debe colocarse entre paréntesis.
nuestro($barra, $baz);
Una declaración "nuestra" declara un alias para una variable de paquete que será visible
en todo su alcance léxico, incluso a través de los límites del paquete. El paquete en el que
la variable se ingresa se determina en el punto de la declaración, no en el
punto de uso. Esto significa que se cumple el siguiente comportamiento:
paquete Foo;
nuestra $barra; # declara $Foo::bar para el resto del ámbito léxico
$ barra = 20;
paquete de barras;
imprimir $barra; # imprime 20, ya que se refiere a $Foo::bar
Se permiten múltiples declaraciones "nuestro" con el mismo nombre en el mismo ámbito léxico
si están en paquetes diferentes. Si se encuentran en el mismo paquete, Perl
emitirá advertencias si las ha solicitado, al igual que múltiples declaraciones "mi".
A diferencia de una segunda declaración "mi", que vinculará el nombre a una nueva variable, una
La segunda declaración "nuestra" en el mismo paquete, en el mismo alcance, es simplemente redundante.
use advertencias;
paquete Foo;
nuestra $barra; # declara $Foo::bar para el resto del ámbito léxico
$ barra = 20;
paquete de barras;
nuestro $barra = 30; # declara $Bar::bar para el resto del ámbito léxico
imprimir $barra; # impresiones 30
nuestra $barra; # emite una advertencia pero no tiene ningún otro efecto
imprimir $barra; # todavía imprime 30
Una declaración "nuestra" también puede tener una lista de atributos asociados.
La semántica exacta y la interfaz de TYPE y ATTRS aún están evolucionando. TIPO es
actualmente vinculado al uso del pragma de "campos", y los atributos se manejan usando
el pragma de "atributos" o, a partir de Perl 5.8.0, también a través del
Módulo "Atributo::Manejadores". Consulte "Variables privadas mediante mi()" en perlsub para
detalles y campos, atributos y Atributo::Manejadores.
Tenga en cuenta que con una lista entre paréntesis, "undef" se puede usar como un marcador de posición ficticio, por
ejemplo para omitir la asignación de valores iniciales:
nuestro ( undef, $min, $hora ) = horalocal;
"nuestro" difiere de "usar vars", que permite el uso de un nombre no calificado only en la pestaña
paquete afectado, pero entre ámbitos.
empaquetar PLANTILLA, LISTA
Toma una LISTA de valores y la convierte en una cadena usando las reglas dadas por el
PLANTILLA. La cadena resultante es la concatenación de los valores convertidos.
Por lo general, cada valor convertido se parece a su representación a nivel de máquina. Para
Por ejemplo, en máquinas de 32 bits, un número entero puede representarse mediante una secuencia de 4 bytes,
que en Perl se presentará como una cadena de 4 caracteres de longitud.
Ver perlpacktut para una introducción a esta función.
La PLANTILLA es una secuencia de caracteres que dan el orden y tipo de valores, como
manera:
a Una cadena con datos binarios arbitrarios se rellenará con nulos.
La cadena de texto AA (ASCII), se rellenará con espacios.
ZA cadena terminada en nulo (ASCIZ), se rellenará con nulos.
b Una cadena de bits (orden de bits ascendente dentro de cada byte,
como vec()).
Cadena de bits BA (orden de bits descendente dentro de cada byte).
h Una cadena hexadecimal (nybble bajo primero).
Cadena hexadecimal HA (nybble alto primero).
c Un valor de carácter con signo (8 bits).
C Un valor de carácter (octeto) sin signo.
W Un valor de carácter sin signo (puede ser superior a 255).
■ Un valor corto (16 bits) con signo.
S Un valor corto sin signo.
l Un valor largo (32 bits) con signo.
L Un valor largo sin signo.
q Un valor cuádruple con signo (64 bits).
P Un valor cuádruple sin signo.
(Los quads están disponibles solo si su sistema es compatible con 64 bits).
valores enteros _y_ si Perl ha sido compilado para soportar
aquellas. Genera una excepción de lo contrario).
i Un valor entero con signo.
IA valor entero sin signo.
(Este 'entero' tiene _al menos_ 32 bits de ancho. Es exacto
el tamaño depende de lo que un compilador local de C llame 'int').
n Un formato corto sin firmar (16 bits) en orden de "red" (big-endian).
N Un orden largo sin firmar (32 bits) en "red" (big-endian).
v Un corto sin firmar (16 bits) en orden "VAX" (little-endian).
V Una longitud sin firmar (32 bits) en orden "VAX" (little-endian).
j Un valor entero con signo interno de Perl (IV).
Valor entero sin signo interno de JA Perl (UV).
f Un flotador de precisión simple en formato nativo.
d Un flotador de doble precisión en formato nativo.
Valor interno de punto flotante (NV) de FA Perl en formato nativo
DA flotante de precisión larga-doble en formato nativo.
(Los dobles largos están disponibles solo si su sistema admite
valores dobles largos _y_ si Perl ha sido compilado para
apoyar a esos. En caso contrario, genera una excepción.
Tenga en cuenta que hay diferentes formatos dobles largos).
p Un puntero a una cadena terminada en cero.
Puntero PA a una estructura (cadena de longitud fija).
u Una cadena codificada en uu.
Número de carácter Unicode de UA. Codifica a un caracter en char-
modo acter y UTF-8 (o UTF-EBCDIC en plataformas EBCDIC) en
modo byte.
w Un entero comprimido BER (no un BER ASN.1, consulte perlpacktut
para detalles). Sus bytes representan un entero sin signo en
base 128, el dígito más significativo primero, con la menor cantidad de dígitos
como sea posible. El bit ocho (el bit alto) se establece en cada byte
excepto el último.
x Un byte nulo (también conocido como ASCII NUL, "\000", chr(0))
X Copia de seguridad de un byte.
@ Relleno nulo o truncado a la posición absoluta, contados desde el
comienzo del grupo () más interno.
. Relleno nulo o truncado a la posición absoluta especificada por
el valor.
( Comienzo de un ()-grupo.
Uno o más modificadores a continuación pueden opcionalmente seguir ciertas letras en la PLANTILLA (la
la segunda columna enumera las letras para las que el modificador es válido):
! sSlLiI Fuerza tamaños nativos (corto, largo, int) en su lugar
de tamaños fijos (16/32 bits).
! xX Hace que x y X actúen como comandos de alineación.
! nNvV Tratar los enteros como con signo en lugar de sin signo.
! @. Especificar la posición como desplazamiento de bytes en el interno
Representación de la cadena empaquetada. Eficiente
pero peligroso
> sSiIlLqQ Fuerza el orden de bytes big-endian en el tipo.
jJfFdDpP (El "extremo grande" toca la construcción.)
< sSiIlLqQ Fuerza el orden de bytes little-endian en el tipo.
jJfFdDpP (El "pequeño extremo" toca la construcción.)
Los modificadores ">" y "<" también se pueden usar en los grupos "()" para forzar un byte en particular.
orden en todos los componentes de ese grupo, incluidos todos sus subgrupos.
Se aplican las siguientes reglas:
· Opcionalmente, cada letra puede ir seguida de un número que indica el número de repeticiones. A
el recuento de repeticiones numéricas puede incluirse opcionalmente entre corchetes, como en "pack("C[80]",
@arr)". El conteo de repeticiones engulle tantos valores de la LISTA cuando se usa con
todos los tipos de formato que no sean "a", "A", "Z", "b", "B", "h", "H", "@", ".", "x", "X",
y "P", donde significa otra cosa, que se describe a continuación. Suministrando un "*" para el
repetir el conteo en lugar de un número significa usar la cantidad de elementos que queden, excepto
por:
· "@", "x" y "X", donde equivale a 0.
· <.>, donde significa relativo al inicio de la cadena.
· "u", donde equivale a 1 (o 45, que aquí equivale).
Se puede reemplazar un conteo de repeticiones numéricas con una letra de plantilla encerrada entre paréntesis
para utilizar la longitud de bytes empaquetados de la plantilla entre paréntesis para el recuento de repeticiones.
Por ejemplo, la plantilla "x[L]" salta tantos bytes como en un empaquetado largo, y el
la plantilla "$t X[$t] $t" desempaqueta el doble de lo que $t (cuando se expande de forma variable) desempaqueta.
Si la plantilla entre paréntesis contiene comandos de alineación (como "x![d]"), su
la longitud empaquetada se calcula como si el inicio de la plantilla tuviera la máxima
posible alineación.
Cuando se usa con "Z", se garantiza que un "*" como el recuento de repeticiones agregará un nulo final
byte, por lo que la cadena resultante siempre es un byte más larga que la longitud en bytes de
el artículo en sí.
Cuando se usa con "@", el conteo de repeticiones representa un desplazamiento desde el comienzo de la
grupo "()" más interno.
Cuando se usa con ".", el conteo de repeticiones determina la posición inicial para calcular
el valor compensado de la siguiente manera:
· Si el recuento de repeticiones es 0, es relativo a la posición actual.
· Si el recuento de repeticiones es "*", el desplazamiento es relativo al inicio del empaquetado
cadena.
· Y si es un número entero n, el desplazamiento es relativo al inicio de la nth
grupo "( )" más interno, o al comienzo de la cadena si n es mas grande que el
nivel de grupo
El recuento de repeticiones para "u" se interpreta como el número máximo de bytes para codificar
por línea de salida, con 0, 1 y 2 reemplazados por 45. El recuento de repeticiones no debe
ser mayor de 65.
· Los tipos "a", "A" y "Z" engullen solo un valor, pero lo empaquetan como una cadena de
recuento de longitud, relleno con nulos o espacios según sea necesario. Al desempacar, tiras "A"
espacios en blanco y nulos al final, "Z" quita todo después del primer nulo, y "a"
devuelve datos sin eliminarlos en absoluto.
Si el valor a empaquetar es demasiado largo, el resultado se trunca. Si es demasiado largo y
se proporciona un recuento explícito, "Z" empaqueta solo bytes "$count-1", seguido de un valor nulo
byte. Por lo tanto, "Z" siempre empaqueta un nulo final, excepto cuando el conteo es 0.
· Del mismo modo, los formatos "b" y "B" contienen una cadena que tiene muchos bits de longitud. Cada
dicho formato genera 1 bit del resultado. Estos son típicamente seguidos por un
repita la cuenta como "B8" o "B64".
Cada bit de resultado se basa en el bit menos significativo de la entrada correspondiente
carácter, es decir, en "ord($char)%2". En particular, los caracteres "0" y "1"
generar los bits 0 y 1, al igual que los caracteres "\000" y "\001".
Comenzando desde el comienzo de la cadena de entrada, cada tupla de 8 caracteres es
convertido a 1 carácter de salida. Con formato "b", el primer carácter de la
8-tuple determina el bit menos significativo de un carácter; con formato "B", se
determina la parte más significativa de un carácter.
Si la longitud de la cadena de entrada no es divisible por 8, el resto es
empaquetado como si la cadena de entrada estuviera rellena con caracteres nulos al final.
De manera similar, durante el desempaquetado, los bits "extra" se ignoran.
Si la cadena de entrada es más larga de lo necesario, los caracteres restantes se ignoran.
Un "*" para el conteo de repeticiones usa todos los caracteres del campo de entrada. Al desempacar,
los bits se convierten en una cadena de 0 y 1.
· Los formatos "h" y "H" empaquetan una cadena que contiene muchos nybbles (grupos de 4 bits,
representable como dígitos hexadecimales, "0".."9" "a".."f") de largo.
Para cada uno de estos formatos, paquete() genera 4 bits de resultado. con no alfabético
caracteres, el resultado se basa en los 4 bits menos significativos de la entrada
carácter, es decir, en "ord($char)%16". En particular, los caracteres "0" y "1"
generar nybbles 0 y 1, al igual que los bytes "\000" y "\001". Para caracteres "a".."f"
y "A".."F", el resultado es compatible con los dígitos hexadecimales habituales, por lo que
"a" y "A" generan el nybble "0xA==10". Use solo estos hexágonos específicos
caracteres con este formato.
Comenzando desde el principio de la plantilla hasta paquete(), cada par de caracteres es
convertido a 1 carácter de salida. Con formato "h", el primer carácter de la
par determina el nibble menos significativo del carácter de salida; con formato
"H", determina el nybble más significativo.
Si la longitud de la cadena de entrada no es uniforme, se comporta como si estuviera rellena con un valor nulo.
personaje al final. Del mismo modo, los nybbles "extra" se ignoran durante el desempaquetado.
Si la cadena de entrada es más larga de lo necesario, se ignoran los caracteres adicionales.
Un "*" para el conteo de repeticiones usa todos los caracteres del campo de entrada. Para deshacer(),
los nybbles se convierten en una cadena de dígitos hexadecimales.
· El formato "p" empaqueta un puntero a una cadena terminada en nulo. Tu eres responsable
para asegurarse de que la cadena no sea un valor temporal, ya que eso podría
ser desasignado antes de llegar a usar el resultado empaquetado. El formato "P"
empaqueta un puntero a una estructura del tamaño indicado por la longitud. un nulo
se crea un puntero si el valor correspondiente para "p" o "P" es "undef"; similar
con deshacer(), donde un puntero nulo se desempaqueta en "undef".
Si su sistema tiene un tamaño de puntero extraño, lo que significa que un puntero no es tan grande como
un int ni tan grande como un largo: puede que no sea posible empaquetar o desempaquetar punteros en
orden de bytes big- o little-endian. Intentar hacerlo genera una excepción.
· El carácter de plantilla "/" permite empaquetar y desempaquetar una secuencia de artículos
donde la estructura empacada contiene un conteo de artículos empacados seguido por el empacado
artículos en sí. Esto es útil cuando la estructura que está desempaquetando ha codificado
los tamaños o recuentos repetidos para algunos de sus campos dentro de la estructura misma como
campos separados.
Para "paquete", escribes artículo de longitud"/"elemento de secuencia, y el artículo de longitud describe
cómo se empaqueta el valor de longitud. Los formatos que probablemente sean de mayor uso son enteros.
empaquetando unos como "n" para cadenas Java, "w" para ASN.1 o SNMP, y "N" para Sun
XDR.
Para "paquete", elemento de secuencia puede tener un conteo repetido, en cuyo caso el mínimo de
eso y el número de elementos disponibles se utiliza como argumento para artículo de longitud.
Si no tiene un recuento de repeticiones o usa un '*', se usa la cantidad de elementos disponibles.
Para "desempaquetar", se utiliza una pila interna de argumentos enteros desempaquetados hasta el momento. Tú
escribe "/"elemento de secuencia y el recuento de repeticiones se obtiene extrayendo el último
elemento de la pila. Él elemento de secuencia no debe tener un conteo de repeticiones.
If elemento de secuencia se refiere a un tipo de cadena ("A", "a" o "Z"), el artículo de longitud is
la longitud de la cadena, no el número de cadenas. Con un conteo de repeticiones explícito para
paquete, la cuerda empaquetada se ajusta a esa longitud. Por ejemplo:
Este código: da este resultado:
desempaquetar("W/a", "\004Gurusamy") ("Gurú")
desempaquetar("a3/AA*", "007 Bono J") ("Bono", "J")
desempaquetar("a3 x2 /AA*", "007: Bono, J.") ("Bono, J", ".")
pack("n/a* w/a","hola,","mundo") "\000\006hola,\005mundo"
paquete("a/W2", pedido("a") .. pedido("z")) "2ab"
El artículo de longitud no se devuelve explícitamente desde "desempaquetar".
Suministrar un conteo a la artículo de longitud formato de letra solo es útil con "A", "a",
o "Z". embalaje con un artículo de longitud de "a" o "Z" puede introducir caracteres "\000",
que Perl no considera legal en cadenas numéricas.
· Los tipos enteros "s", "S", "l" y "L" pueden ir seguidos de un "!" modificador de
especificar cortos o largos nativos. Como se muestra en el ejemplo anterior, una "l" simple significa
exactamente 32 bits, aunque el "largo" nativo visto por el compilador C local puede ser
más grande Esto es principalmente un problema en las plataformas de 64 bits. Puedes ver si usando
"!" hace cualquier diferencia de esta manera:
printf "el formato s es %d, s! es %d\n",
paquete de longitud("s"), paquete de longitud("s!");
printf "el formato l es %d, l! es %d\n",
paquete de longitud("l"), paquete de longitud("l!");
"¡i!" ¡y yo!" también están permitidos, pero solo por el bien de la integridad: son
idéntico a "yo" y "yo".
Los tamaños reales (en bytes) de shorts, ints, longs y long long nativos en el
plataforma donde se creó Perl también están disponibles desde la línea de comandos:
$ perl -V:{corto,int,largo{,largo}}tamaño
tamaño corto = '2';
intsize='4';
tamañolargo='4';
largolargotamaño='8';
o programáticamente a través del módulo "Config":
usar configuración;
imprimir $Config{tamaño corto}, "\n";
imprimir $Config{intsize}, "\n";
imprimir $Config{tamaño largo}, "\n";
imprimir $Config{longlongsize}, "\n";
$Config{longlongsize} no está definido en sistemas sin soporte de larga duración.
· Los formatos enteros "s", "S", "i", "I", "l", "L", "j" y "J" son inherentemente no
portátiles entre procesadores y sistemas operativos porque obedecen a nativos
orden de bytes y endianidad. Por ejemplo, un entero de 4 bytes 0x12345678 (305419896
decimal) se ordenaría de forma nativa (organizado y manejado por los registros de la CPU)
en bytes como
0x12 0x34 0x56 0x78 # extremo grande
0x78 0x56 0x34 0x12 # little endian
Básicamente, las CPU Intel y VAX son little-endian, mientras que todos los demás, incluidos
Motorola m68k/88k, PPC, Sparc, HP PA, Power y Cray son big-endian. Alfa y
MIPS puede ser: Digital/Compaq los usa (bueno, los usa) en modo little-endian,
pero SGI/Cray los usa en modo big-endian.
Los nombres big endian y ascendente hacia la izquierda son referencias cómicas al comer huevos
hábitos de los liliputienses little-endian y los blefuscudianos big-endian del
la sátira clásica de jonathan swift, De Gulliver Travels. Esto entró en la jerga informática
a través del artículo "Sobre las guerras santas y una súplica por la paz" de Danny Cohen, USC/ISI IEN 137,
Abril 1, 1980.
Algunos sistemas pueden tener órdenes de bytes aún más extraños, como
0x56 0x78 0x12 0x34
0x34 0x12 0x78 0x56
Estos se llaman mid-endian, middle-endian, mixed-endian o simplemente extraños.
Puede determinar la endianidad de su sistema con este conjuro:
printf("%#02x ", $_) for desempaquetar("W*", empaque L=>0x12345678);
El orden de bytes en la plataforma donde se creó Perl también está disponible a través de Config:
usar configuración;
imprimir "$Config{orden de bytes}\n";
o desde la línea de comando:
$ perl -V: orden de bytes
Los byteorders "1234" y "12345678" son little-endian; "4321" y "87654321" son grandes
endiano Los sistemas con binarios multiarquitectura tendrán "ffff", lo que significa que
la información estática no funciona, se debe usar el sondeo en tiempo de ejecución.
Para enteros empaquetados de forma portátil, utilice los formatos "n", "N", "v" y "V" o
de lo contrario, use los modificadores ">" y "<" que se describen a continuación. Ver también
puerto perl
· También los números de punto flotante tienen endianness. Por lo general (pero no siempre) esto está de acuerdo
con el endianness entero. Aunque la mayoría de las plataformas en estos días usan el IEEE
754 formato binario, hay diferencias, especialmente si los dobles largos son
involucrado. Puede ver las variables "Config" "doublekind" y "longdblkind" (también
"doublesize", "longdblsize"): los valores de "tipo" son enumeraciones, a diferencia de "byteorder".
En cuanto a la portabilidad, la mejor opción es probablemente mantener el IEEE 754 de 64 bits
dobles, y de endianidad acordada. Otra posibilidad es el formato "%a")
de "printf".
· A partir de Perl 5.10.0, formatos enteros y de punto flotante, junto con la "p"
y los formatos "P" y los grupos "()", todos pueden ir seguidos del endianismo ">" o "<".
modificadores para hacer cumplir respectivamente el orden de bytes big-endian o little-endian. Estas
Los modificadores son especialmente útiles dado que "n", "N", "v" y "V" no cubren
enteros con signo, enteros de 64 bits o valores de coma flotante.
Aquí hay algunas preocupaciones a tener en cuenta al usar un modificador endianness:
· El intercambio de enteros con signo entre diferentes plataformas funciona solo cuando todos
las plataformas los almacenan en el mismo formato. La mayoría de las plataformas almacenan enteros con signo
en notación de complemento a dos, por lo que generalmente esto no es un problema.
· Los modificadores ">" o "<" solo se pueden usar en formatos de coma flotante en formatos grandes o
máquinas little-endian. De lo contrario, intentar usarlos genera una
excepción.
· Forzar el orden de bytes big-endian o little-endian en valores de punto flotante para datos
el intercambio solo puede funcionar si todas las plataformas usan la misma representación binaria
como punto flotante IEEE. Incluso si todas las plataformas usan IEEE, puede haber
Todavía habrá diferencias sutiles. Ser capaz de usar ">" o "<" en coma flotante
Los valores pueden ser útiles, pero también peligrosos si no sabes exactamente lo que estás
haciendo. No es una forma general de almacenar de forma portátil valores de punto flotante.
· Al usar ">" o "<" en un grupo "()", esto afecta a todos los tipos dentro del grupo
que aceptan modificadores de orden de bytes, incluidos todos los subgrupos. es en silencio
ignorado para todos los demás tipos. No se le permite anular el orden de bytes
dentro de un grupo que ya tiene un sufijo modificador de orden de bytes.
· Los números reales (flotantes y dobles) solo están en formato nativo de máquina. Debido a la
multiplicidad de formatos de punto flotante y la falta de una "red" estándar
representación para ellos, no se ha hecho ninguna facilidad para el intercambio. Esto significa
que los datos empaquetados de punto flotante escritos en una máquina pueden no ser legibles en
otro, incluso si ambos usan aritmética de punto flotante IEEE (porque el endianness
de la representación de la memoria no es parte de la especificación IEEE). Véase también puerto perl.
Si sabes exactamente lo que estás haciendo, puedes usar los modificadores ">" o "<" para
fuerza el orden de bytes big-endian o little-endian en valores de punto flotante.
Debido a que Perl usa dobles (o dobles largos, si está configurado) internamente para todos
cálculo numérico, convirtiendo de doble a flotante y de allí a doble nuevamente
pierde precisión, por lo que "unpack("f", pack("f", $foo)") en general no será igual a $foo.
· Empaquetar y desempaquetar puede operar en dos modos: modo de caracteres (modo "C0") donde el
la cadena empaquetada se procesa por carácter, y el modo de bytes UTF-8 (modo "U0") donde
la cadena empaquetada se procesa en su formato Unicode codificado en UTF-8 byte a byte
base. El modo de caracteres es el predeterminado a menos que la cadena de formato comience con "U".
Siempre puede cambiar el modo de formato medio con un "C0" o "U0" explícito en el formato.
Este modo permanece vigente hasta el próximo cambio de modo, o hasta el final del
Grupo "()" al que se aplica (directamente).
Usando "C0" para obtener caracteres Unicode mientras usa "U0" para obtener no-Los bytes Unicode son
no necesariamente obvio. Probablemente solo el primero de estos es lo que quieres:
$ perl -CS -E 'dice "\x{3B1}\x{3C9}"' |
perl -CS -ne 'printf "%v04X\n", $_ para desempaquetar("C0A*", $_)'
03B1.03C9
$ perl -CS -E 'dice "\x{3B1}\x{3C9}"' |
perl -CS -ne 'printf "%v02X\n", $_ para desempaquetar("U0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'dice "\x{3B1}\x{3C9}"' |
perl -C0 -ne 'printf "%v02X\n", $_ para desempaquetar("C0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'dice "\x{3B1}\x{3C9}"' |
perl -C0 -ne 'printf "%v02X\n", $_ para desempaquetar("U0A*", $_)'
C3.8E.C2.B1.C3.8F.C2.89
Esos ejemplos también ilustran que no debe intentar usar "empaquetar"/"desempaquetar" como
sustituye al módulo Encode.
· Usted mismo debe hacer cualquier alineación o relleno insertando, por ejemplo, suficiente
"x"es mientras empaca. No hay forma de paquete() y deshacer() saber donde
los caracteres van o vienen, por lo que manejan su salida y entrada como
secuencias planas de caracteres.
· Un grupo "()" es una sub-PLANTILLA encerrada entre paréntesis. Un grupo puede repetir
cuenta ya sea como sufijo, o para deshacer(), también a través del carácter de plantilla "/".
Dentro de cada repetición de un grupo, el posicionamiento con "@" comienza de nuevo en 0.
Por lo tanto, el resultado de
paquete("@1A((@2A)@3A)", qw[XYZ])
es la cadena "\0X\0\0YZ".
· "x" y "X" aceptan el "!" modificador para actuar como comandos de alineación: saltan
avanzar o retroceder a la posición más cercana alineada en un múltiplo de "contar"
caracteres. por ejemplo, a paquete() or deshacer() una estructura C como
estructura {
carácter c; /* un carácter firmado de 8 bits */
doble d;
charcc[2];
}
uno puede necesitar usar la plantilla "cx! [d] dc [2]". Esto supone que los dobles deben
alinearse al tamaño del doble.
Para los comandos de alineación, un "recuento" de 0 es equivalente a un "recuento" de 1; ambos son
sin operaciones
· "n", "N", "v" y "V" aceptan el "!" modificador para representar 16/32 bits firmados
enteros en orden big-/little-endian. Esto es portátil solo cuando todas las plataformas
compartir datos empaquetados usa la misma representación binaria para enteros con signo; por
ejemplo, cuando todas las plataformas usan representación de complemento a dos.
· Los comentarios se pueden incrustar en una PLANTILLA usando "#" hasta el final de la línea. Blanco
el espacio puede separar los códigos de paquete entre sí, pero los modificadores y la repetición cuentan
debe seguir inmediatamente. Dividir plantillas complejas en líneas individuales línea por línea
componentes, debidamente anotados, pueden hacer tanto para mejorar la legibilidad y
capacidad de mantenimiento de los formatos de paquete/desempaquetado como "/x" puede para un patrón complicado
partidos.
· Si TEMPLATE requiere más argumentos que paquete() es dado, paquete() asume
argumentos "" adicionales. Si TEMPLATE requiere menos argumentos que los dados, extra
los argumentos se ignoran.
· Intentar empaquetar los valores especiales de punto flotante "Inf" y "NaN" (infinito,
también en negativo, y no-un-número) en valores enteros empaquetados (como "L") es un
error fatal. La razón de esto es que simplemente no hay ningún mapeo sensato
para estos valores especiales en números enteros.
Ejemplos:
$foo = paquete("WWWW",65,66,67,68);
#foo eq "ABCD"
$foo = paquete("W4",65,66,67,68);
# la misma cosa
$foo = pack("W4",0x24b6,0x24b7,0x24b8,0x24b9);
# lo mismo con las letras circulares de Unicode.
$foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9);
# lo mismo con las letras circulares de Unicode. no obtienes el
# UTF-8 bytes porque la U al inicio del formato provocó
# un cambio al modo U0, por lo que los bytes UTF-8 se unen en
# caracteres
$foo = pack("C0U4",0x24b6,0x24b7,0x24b8,0x24b9);
# foo eq "\xe2\x92\xb6\xe2\x92\xb7\xe2\x92\xb8\xe2\x92\xb9"
# Esta es la codificación UTF-8 de la cadena en el
# ejemplo anterior
$ foo = paquete ("ccxxcc", 65,66,67,68);
# foo eq "AB\0\0CD"
# NOTA: Los ejemplos anteriores con "W" y "c" son verdaderos
# solo en ASCII y sistemas derivados de ASCII como ISO Latin 1
# y UTF-8. En los sistemas EBCDIC, el primer ejemplo sería
# $foo = paquete("WWWW",193,194,195,196);
$foo = paquete("s2",1,2);
# "\001\000\002\000" en little-endian
# "\000\001\000\002" en big-endian
$foo = paquete("a4","abcd","x","y","z");
# "a B C D"
$foo = paquete("aaaa","abcd","x","y","z");
# "axyz"
$foo = paquete("a14","abcdefg");
# "abcdefg\0\0\0\0\0\0\0"
$foo = paquete("i9pl", gmtime);
# una estructura real tm (en mi sistema de todos modos)
$utmp_template = "Z8 Z8 Z16 L";
$utmp = paquete($utmp_template, @utmp1);
# una estructura utmp (BSDish)
@utmp2 = descomprimir ($utmp_template, $utmp);
# "@utmp1" equivalente a "@utmp2"
subbintodec {
unpack("N", pack("B32", substr("0" x 32 . shift, -32)));
}
$foo = paquete('sx2l', 12, 34);
# corto 12, relleno de dos bytes cero, largo 34
$barra = paquete('s@4l', 12, 34);
# corto 12, relleno cero a la posición 4, largo 34
# $foo eq $barra
$baz = paquete('s.l', 12, 4, 34);
# corto 12, relleno cero a la posición 4, largo 34
$foo = paquete('nN', 42, 4711);
# empaquetar enteros sin signo big-endian de 16 y 32 bits
$foo = paquete('S>L>', 42, 4711);
# exactamente lo mismo
$foo = paquete('s
# paquete de enteros con signo little-endian de 16 y 32 bits
$foo = paquete('(sl)<', -42, 4711);
# exactamente lo mismo
Por lo general, la misma plantilla también se puede utilizar en deshacer().
paquete ESPACIO DE NOMBRES
paquete VERSIÓN DE ESPACIO DE NOMBRES
paquete BLOQUE DE ESPACIO DE NOMBRES
paquete BLOQUE DE VERSIÓN DE ESPACIO DE NOMBRES
Declara el BLOQUE o el resto de la unidad de compilación como estando en el dado
espacio de nombres El alcance de la declaración del paquete es el código BLOCK proporcionado o,
en ausencia de un BLOQUE, desde la declaración misma hasta el final de la actual
alcance (el bloque, archivo o "eval" adjunto). Es decir, las formas sin BLOQUE son
operativo hasta el final del alcance actual, al igual que "mi", "estado" y "nuestro"
operadores. Todos los identificadores dinámicos no calificados en este ámbito estarán en el dado
espacio de nombres, excepto donde sea anulado por otra declaración de "paquete" o cuando estén
uno de los identificadores especiales que califican como "principal::", como "STDOUT", "ARGV",
"ENV", y las variables de puntuación.
Una declaración de paquete afecta solo a las variables dinámicas, incluidas las que ha utilizado
"local" activado, pero no variables de ámbito léxico, que se crean con "my", "state",
o "nuestro". Por lo general, sería la primera declaración en un archivo incluido por "requerir"
o usar". Puede cambiar a un paquete en más de un lugar, ya que esto solo
determina qué tabla de símbolos predeterminada usa el compilador para el resto de ese bloque.
Puede hacer referencia a identificadores en otros paquetes que no sean el actual anteponiendo el prefijo
identificador con el nombre del paquete y dos puntos dobles, como en $SomePack::var o
"EsePaquete::INPUT_HANDLE". Si se omite el nombre del paquete, se asume el paquete "principal".
Es decir, $::sail es equivalente a $main::sail (así como a "$main'sail", todavía visto
en código antiguo, principalmente de Perl 4).
Si se proporciona VERSIÓN, "paquete" establece la variable $VERSIÓN en el espacio de nombres dado para
un objeto de versión con la VERSIÓN proporcionada. VERSION debe ser una versión de estilo "estricto"
número definido por el módulo de versión: un número decimal positivo (entero o
fracción decimal) sin exponenciación o bien una v-string decimal punteada con una
carácter 'v' inicial y al menos tres componentes. Debe establecer $ VERSION solamente
una vez por paquete.
Consulte "Paquetes" en perlmod para obtener más información sobre paquetes, módulos y clases.
Consulte perlsub para conocer otros problemas de alcance.
__PAQUETE__
Un token especial que devuelve el nombre del paquete en el que aparece.
MANGO DE LECTURA, MANGO DE ESCRITURA
Abre un par de tuberías conectadas como la llamada al sistema correspondiente. Tenga en cuenta que si usted
configurar un bucle de procesos canalizados, puede producirse un punto muerto a menos que tenga mucho cuidado. En
Además, tenga en cuenta que las canalizaciones de Perl utilizan el almacenamiento en búfer de E/S, por lo que es posible que deba configurar $| sonrojarse
su WRITEHANDLE después de cada comando, dependiendo de la aplicación.
Devuelve verdadero en caso de éxito.
Consulte IPC::Open2, IPC::Open3 y "Comunicación bidireccional con otro proceso" en
perlipc para ejemplos de tales cosas.
En los sistemas que admiten un indicador de cerrar al ejecutar en los archivos, ese indicador se establece en todos los archivos nuevos.
descriptores de archivos abiertos cuyos "fileno" son higher que el valor actual de $^F (por
predeterminado 2 para "STDERR"). Ver "$^F" en perlvar.
matriz pop
EXPR pop
pop Muestra y devuelve el último valor de la matriz, acortando la matriz en un elemento.
Devuelve el valor indefinido si la matriz está vacía, aunque esto también puede ocurrir en
otros tiempos. Si se omite ARRAY, aparece la matriz @ARGV en el programa principal, pero el
@_ array en subrutinas, como "shift".
A partir de Perl 5.14, "pop" puede tomar una EXPR escalar, que debe contener una referencia a
una matriz no bendecida. El argumento será desreferenciado automáticamente. Este aspecto de
"pop" se considera altamente experimental. El comportamiento exacto puede cambiar en un futuro.
versión de Perl.
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.014; # entonces push/pop/etc funciona en escalares (experimental)
pos ESCALAR
pos Devuelve el desplazamiento de donde quedó la última búsqueda "m//g" para la variable en
pregunta ($_ se usa cuando no se especifica la variable). Tenga en cuenta que 0 es un válido
compensación de coincidencia. "undef" indica que la posición de búsqueda se restablece (generalmente debido a
error de coincidencia, pero también puede deberse a que aún no se ha ejecutado ninguna coincidencia en el escalar).
"pos" accede directamente a la ubicación utilizada por el motor de expresiones regulares para almacenar el desplazamiento, por lo que
asignar a "pos" cambiará ese desplazamiento, y también influirá en el cero-\G"
aserción de ancho en expresiones regulares. Ambos efectos tienen lugar para el próximo
partido, por lo que no puede afectar la posición con "pos" durante el partido actual, como
en "(?{pos() = 5})" o "s//pos() = 5/e".
Establecer "pos" también restablece el emparejado con longitud cero bandera, descrita en "Repetidas
Patrones que coinciden con una subcadena de longitud cero" en perlre.
Debido a que una coincidencia fallida de "m//gc" no restablece el desplazamiento, el retorno de "pos" no
cambiar cualquiera en este caso. Véase perlre y perlop.
imprimir LISTA DE ARCHIVOS
imprimir ARCHIVO
imprimir LISTA
Imprimir
Imprime una cadena o una lista de cadenas. Devuelve verdadero si tiene éxito. IDENTIFICADOR DE ARCHIVO puede ser
una variable escalar que contiene el nombre o una referencia al identificador de archivo, por lo tanto
introduciendo un nivel de indirección. (NOTA: si FILEHANDLE es una variable y el siguiente
token es un término, puede malinterpretarse como un operador a menos que interponga un "+" o
poner paréntesis alrededor de los argumentos). Si se omite IDENTIFICADOR DE ARCHIVO, se imprime hasta el último
controlador de salida seleccionado (ver "seleccionar"). Si se omite LIST, imprime $_ en el actual
controlador de salida seleccionado. Para usar FILEHANDLE solo para imprimir el contenido de $_ en él, debe
debe usar un identificador de archivo real como "FH", no uno indirecto como $fh. Para configurar el
controlador de salida predeterminado a algo que no sea STDOUT, use la operación de selección.
El valor actual de $, (si lo hay) se imprime entre cada elemento de la LISTA. el valor actual
de "$\" (si lo hay) se imprime después de que se haya impreso la LISTA completa. porque imprimir
toma una LISTA, cualquier cosa en la LISTA se evalúa en el contexto de la lista, incluyendo cualquier
subrutinas cuyas listas de retorno pasas a "imprimir". Tenga cuidado de no seguir el
imprime la palabra clave con un paréntesis izquierdo a menos que quieras el derecho correspondiente
paréntesis para terminar los argumentos de la impresión; poner paréntesis alrededor de todo
argumentos (o interponer un "+", pero eso no se ve tan bien).
Si está almacenando identificadores en una matriz o hash, o en general siempre que esté usando cualquier
expresión más compleja que un identificador de palabra simple o un escalar simple sin subíndice
variable para recuperarlo, tendrá que usar un bloque que devuelva el valor del identificador de archivo
en cambio, en cuyo caso la LISTA no se puede omitir:
print { $archivos[$i] } "cosas\n";
imprimir {$OK? STDOUT: STDERR } "cosas\n";
La impresión en una tubería o enchufe cerrado generará una señal SIGPIPE. Ver perlipc para
más sobre el manejo de la señal.
printf FORMATO DE IDENTIFICADOR DE ARCHIVO, LISTA
printf IDENTIFICADOR DE ARCHIVO
printf FORMATO, LISTA
Printf
Equivalente a "print FILEHANDLE sprintf(FORMAT, LIST)", excepto que "$\" (la salida
separador de registros) no se adjunta. El FORMATO y la LISTA en realidad se analizan como un
lista única. El primer argumento de la lista se interpretará como "printf"
formato. Esto significa que "printf(@_)" usará $_[0] como formato. Ver sprintf para
una explicación del argumento de formato. Si "usar configuración regional" para "LC_NUMERIC", busque esto
throught pod está en efecto y POSIX :: setlocale () ha sido llamado, el carácter utilizado
para el separador decimal en números de punto flotante con formato se ve afectado por la
Configuración regional "LC_NUMERIC". Ver perlocale y POSIX.
Por razones históricas, si omite la lista, se usa $_ como formato; usar
FILEHANDLE sin una lista, debe usar un identificador de archivo real como "FH", no un identificador indirecto
uno como $fh. Sin embargo, esto rara vez hará lo que quieres; si $_ contiene formato
códigos, serán reemplazados con la cadena vacía y se emitirá una advertencia si
las advertencias están habilitadas. Simplemente use "imprimir" si desea imprimir el contenido de $_.
No caiga en la trampa de usar un "printf" cuando bastaría con un simple "print". Él
"imprimir" es más eficiente y menos propenso a errores.
prototipo FUNCIÓN
prototipo
Devuelve el prototipo de una función como una cadena (o "undef" si la función no tiene
prototipo). FUNCIÓN es una referencia o el nombre de la función cuyo prototipo
quieres recuperar. Si se omite FUNCIÓN, se usa $_.
Si FUNCIÓN es una cadena que comienza con "CORE::", el resto se toma como un nombre para un Perl
incorporado. Si los argumentos incorporados no pueden expresarse adecuadamente mediante un prototipo
(como "sistema"), prototipo() devuelve "undef", porque el incorporado realmente no
comportarse como una función de Perl. De lo contrario, la cadena que describe el equivalente
se devuelve el prototipo.
presione ARRAY, LIST
empuje EXPR,LISTA
Trata ARRAY como una pila agregando los valores de LIST al final de ARRAY. Él
la longitud de ARRAY aumenta según la longitud de LIST. Tiene el mismo efecto que
para $valor (LISTA) {
$ARRAY[++$#ARRAY] = $valor;
}
pero es más eficiente. Devuelve el número de elementos de la matriz que siguen al
completado "empuje".
A partir de Perl 5.14, "push" puede tomar una EXPR escalar, que debe contener una referencia a
una matriz no bendecida. El argumento será desreferenciado automáticamente. Este aspecto de
"empujar" se considera altamente experimental. El comportamiento exacto puede cambiar en un futuro.
versión de Perl.
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.014; # entonces push/pop/etc funciona en escalares (experimental)
q/CADENA/
qq/CADENA/
qw/CADENA/
qx/CADENA/
Citas generalizadas. Consulte "Operadores similares a comillas" en perlop.
qr/CADENA/
Cita similar a Regexp. Consulte "Operadores similares a cotizaciones Regexp" en perlop.
cita meta EXPR
cita
Devuelve el valor de EXPR con todos los caracteres ASCII que no son "palabras" con barra invertida. (Ese
es decir, todos los caracteres ASCII que no coincidan con "/[A-Za-z_0-9]/" estarán precedidos por una barra invertida
en la cadena devuelta, independientemente de la configuración regional.) Esta es la cadena interna
función que implementa el escape "\Q" en cadenas entre comillas dobles. (Vea abajo para el
comportamiento en puntos de código no ASCII).
Si se omite EXPR, utiliza $_.
quotemeta (y "\Q" ... "\E") son útiles cuando se interpolan cadenas en
expresiones, porque por defecto una variable interpolada se considerará una mini-
expresión regular. Por ejemplo:
my $sentence = 'El veloz zorro marrón saltó sobre el perro perezoso';
mi $subcadena = 'rápido.*?zorro';
$frase =~ s{$substring}{gran lobo feroz};
Hará que $frase se convierta en 'El lobo feroz saltó sobre...'.
Por otra parte:
my $sentence = 'El veloz zorro marrón saltó sobre el perro perezoso';
mi $subcadena = 'rápido.*?zorro';
$frase =~ s{\Q$substring\E}{gran lobo feroz};
o:
my $sentence = 'El veloz zorro marrón saltó sobre el perro perezoso';
mi $subcadena = 'rápido.*?zorro';
mi $quoted_substring = quotemeta($substring);
$frase =~ s{$quoted_substring}{gran lobo feroz};
Ambos dejarán la frase como está. Normalmente, al aceptar la entrada de cadena literal
del usuario, quotemeta () o "\Q".
En Perl v5.14, todos los caracteres que no son ASCII se citan en cadenas no codificadas en UTF-8, pero
no citado en cadenas UTF-8.
A partir de Perl v5.16, Perl adoptó una estrategia definida por Unicode para citar códigos no ASCII.
caracteres; las comillas de caracteres ASCII no se modifican.
Tampoco ha cambiado la citación de cadenas que no son UTF-8 cuando están fuera del alcance de un "uso
característica 'unicode_strings'", que consiste en citar todos los caracteres en latín1 superior
distancia. Esto proporciona compatibilidad completa con versiones anteriores para programas antiguos que no
utiliza Unicode. (Tenga en cuenta que "unicode_strings" se habilita automáticamente dentro del alcance
de "usar v5.12" o superior).
Dentro del alcance de "usar configuración regional", todos los puntos de código que no son ASCII Latin1 se citan ya sea
la cadena está codificada como UTF-8 o no. Como se mencionó anteriormente, la configuración regional no afecta la
comillas de caracteres de rango ASCII. Esto protege contra aquellas configuraciones regionales donde
caracteres como "|" se consideran caracteres de palabras.
De lo contrario, Perl cita caracteres que no son ASCII mediante una adaptación de Unicode (ver
<http://www.unicode.org/reports/tr31/>). Los únicos puntos de código que se citan son
aquellos que tienen alguna de las propiedades Unicode: Pattern_Syntax, Pattern_White_Space,
White_Space, Default_Ignorable_Code_Point o General_Category=Control.
De estas propiedades, las dos importantes son Pattern_Syntax y
Patrón_Blanco_Espacio. Han sido creados por Unicode exactamente con este propósito de
decidir qué caracteres en un patrón de expresión regular se deben citar. No
carácter que puede estar en un identificador tiene estas propiedades.
Perl promete que si alguna vez añadimos metacaracteres de patrón de expresión regular al
docena ya definida ("\ | ( ) [ { ^ $ * + ? ."), que solo usaremos las que
tener la propiedad Pattern_Syntax. Perl también promete que si alguna vez añadimos caracteres
que se consideran espacios en blanco en expresiones regulares (actualmente en su mayoría
afectados por "/x"), todos tendrán la propiedad Pattern_White_Space.
Unicode promete que el conjunto de puntos de código que tienen estas dos propiedades nunca
cambio, por lo que algo que no se cita en v5.16 nunca tendrá que citarse en ningún
futura versión de Perl. (No todos los puntos de código que coinciden con Pattern_Syntax tienen realmente
tenían personajes asignados a ellos; por lo que hay espacio para crecer, pero se citan si
asignado o no. Perl, por supuesto, nunca usaría un punto de código no asignado como
metacarácter real).
La cita de caracteres que tienen las otras 3 propiedades se realiza para mejorar la legibilidad.
de la expresión regular y no porque realmente necesiten ser citados para regular
propósitos de expresión (es probable que los caracteres con la propiedad White_Space
indistinguible en la página o pantalla de aquellos con Pattern_White_Space
propiedad; y las otras dos propiedades contienen caracteres no imprimibles).
EXPR en rand
rand
Devuelve un número fraccionario aleatorio mayor o igual a 0 y menor que el valor
de EXP. (EXPR debe ser positivo). Si se omite EXPR, se utiliza el valor 1.
Actualmente, EXPR con el valor 0 también tiene un caso especial como 1 (esto no estaba documentado
antes de Perl 5.8.0 y está sujeto a cambios en futuras versiones de Perl). Automáticamente
llama "srand" a menos que ya se haya llamado "srand". Véase también "sand".
Aplique "int()" al valor devuelto por "rand()" si desea números enteros aleatorios en lugar de
números fraccionarios aleatorios. Por ejemplo,
En t(rand(10))
devuelve un número entero aleatorio entre 0 y 9, ambos inclusive.
(Nota: si su función rand devuelve constantemente números que son demasiado grandes o demasiado
pequeño, entonces su versión de Perl probablemente se compiló con el número incorrecto de
RANDOS.)
"rand()" is no criptográficamente asegurar. You should no confiar on it in seguridad-
sensible situaciones En el momento de escribir este artículo, una serie de módulos CPAN de terceros ofrecen
generadores de números aleatorios destinados por sus autores a ser criptográficamente seguros,
incluyendo: Data::Entropy, Crypt::Random, Math::Random::Secure y Math::TrulyRandom.
leer IDENTIFICADOR DE ARCHIVO, ESCALAR, LONGITUD, DESPLAZAMIENTO
leer IDENTIFICADOR DE ARCHIVO, ESCALAR, LONGITUD
Intentos de leer LONGITUD personajes de datos en la variable ESCALAR de la especificada
ARCHIVO. Devuelve el número de caracteres realmente leídos, 0 al final del archivo o
undef si hubo un error (en este último caso también se establece $!). ESCALAR crecerá
o reducido para que el último carácter realmente leído sea el último carácter del escalar
después de la lectura.
Se puede especificar un DESPLAZAMIENTO para colocar los datos leídos en algún lugar de la cadena diferente
que el principio. Un DESPLAZAMIENTO negativo especifica la ubicación en esa cantidad de caracteres
contando hacia atrás desde el final de la cuerda. Un OFFSET positivo mayor que el
la longitud de SCALAR da como resultado que la cadena se rellene al tamaño requerido con "\0"
bytes antes de que se agregue el resultado de la lectura.
La llamada se implementa en términos de Perl o de su sistema nativo. miedo(3)
función de biblioteca. para obtener un verdadero read(2) llamada al sistema, consulte sysread.
Nota la personajes: según el estado del identificador de archivo, ya sea (8 bits) bytes
o se leen caracteres. De forma predeterminada, todos los identificadores de archivo funcionan en bytes, pero por ejemplo
si el identificador de archivo se ha abierto con la capa de E/S ":utf8" (consulte "abrir" y el
pragma "abierto", abierto), la E/S operará con caracteres Unicode codificados en UTF8, no
bytes De manera similar para el pragma ": codificación": en ese caso, casi cualquier carácter
puede ser leído.
leerdir DIRHANDLE
Devuelve la siguiente entrada de directorio para un directorio abierto por "opendir". Si se usa en la lista
context, devuelve el resto de las entradas del directorio. si no hay mas
entradas, devuelve el valor indefinido en contexto escalar y la lista vacía en lista
contexto.
Si planea probar los valores de retorno de un "readdir", será mejor que
anteponer el directorio en cuestión. De lo contrario, debido a que no "chdir" allí,
habría estado probando el archivo equivocado.
opendir(mi $dh, $some_dir) || die "no se puede abrir el directorio $some_dir: $!";
@puntos = grep { /^\./ && -f "$some_dir/$_" } readdir($dh);
cerrado $ dh;
A partir de Perl 5.12, puede usar un simple "readdir" en un bucle "while", que establecerá $_ en
cada iteración.
opendir(mi $dh, $some_dir) || morir;
while(leerdir $dh) {
imprimir "$some_dir/$_\n";
}
cerrado $ dh;
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con fallas misteriosas, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.012; # así que readdir se asigna a $_ en una sola prueba while
línea de lectura EXPR
readline
Lee del identificador de archivo cuyo typeglob está contenido en EXPR (o de *ARGV si EXPR
no se proporciona). En contexto escalar, cada llamada lee y devuelve la siguiente línea hasta que
se llega al final del archivo, después de lo cual la siguiente llamada devuelve "undef". En lista
context, lee hasta que se alcanza el final del archivo y devuelve una lista de líneas. Tenga en cuenta que
la noción de "línea" utilizada aquí es lo que haya definido con $/ o
$INPUT_RECORD_SEPARATOR). Ver "$/" en perlvar.
Cuando $/ se establece en "undef", cuando "readline" está en contexto escalar (es decir, file slurp
modo), y cuando se lee un archivo vacío, devuelve '' la primera vez, seguido de
"undef" posteriormente.
Esta es la función interna que implementa el " "operador, pero puedes usarlo
directamente. Él " El operador " se trata con más detalle en "Operadores de E/S" en
perlop
$ línea = ;
$línea = readline(*STDIN); # la misma cosa
Si "readline" encuentra un error del sistema operativo, $! se establecerá con el
mensaje de error correspondiente. ¡Puede ser útil verificar $! cuando estás leyendo de
maneja archivos en los que no confía, como un tty o un socket. El siguiente ejemplo utiliza
la forma de operador de "readline" y muere si el resultado no está definido.
mientras ( ! eof($fh) ) {
definido ($_ = <$fh>) o die "falló la línea de lectura: $!";
...
}
Tenga en cuenta que no puede manejar los errores de "línea de lectura" de esa manera con el identificador de archivo "ARGV".
En ese caso, debe abrir cada elemento de @ARGV usted mismo ya que "eof" maneja
"ARGV" de manera diferente.
foreach mi $arg (@ARGV) {
open(my $fh, $arg) o advertir "No se puede abrir $arg: $!";
mientras ( ! eof($fh) ) {
definido( $_ = <$fh> )
o muere "la línea de lectura falló para $arg: $!";
...
}
}
EXPR de enlace de lectura
enlace de lectura
Devuelve el valor de un enlace simbólico, si se implementan enlaces simbólicos. Que no,
plantea una excepción. Si hay un error del sistema, devuelve el valor indefinido y establece
ps (errno). Si se omite EXPR, utiliza $_.
Problemas de portabilidad: "readlink" en perlport.
EXPR de tubería de lectura
tubo de lectura
EXPR se ejecuta como un comando del sistema. La salida estándar recopilada del comando es
devuelto En contexto escalar, regresa como un solo (potencialmente multilínea)
cuerda. En el contexto de la lista, devuelve una lista de líneas (sin embargo, ha definido líneas con
$/ o $INPUT_RECORD_SEPARATOR). Esta es la función interna que implementa el
operador "qx/EXPR/", pero puede usarlo directamente. El operador "qx/EXPR/" es
discutido con más detalle en "Operadores de E/S" en perlop. Si se omite EXPR, utiliza $_.
recepv SOCKET, ESCALAR, LONGITUD, BANDERAS
Recibe un mensaje en un socket. Intenta recibir LENGTH caracteres de datos en
variable ESCALAR del identificador de archivo SOCKET especificado. ESCALAR crecerá o se reducirá
a la longitud realmente leída. Toma las mismas banderas que la llamada al sistema del mismo
nombre. Devuelve la dirección del remitente si el protocolo de SOCKET lo admite; devoluciones
una cadena vacía de lo contrario. Si hay un error, devuelve el valor indefinido. Este
la llamada se implementa realmente en términos de recvfrom(2) llamada al sistema. Ver "UDP: Mensaje
Passing" en perlipc para ver ejemplos.
Nota la personajes: dependiendo del estado del socket, ya sea bytes (8 bits) o
Se reciben caracteres. Por defecto, todos los sockets operan en bytes, pero por ejemplo si
el zócalo ha sido cambiado usando binmode () para operar con la E/S ":encoding(utf8)"
capa (consulte el pragma "abierto", abierto), la E/S operará en Unicode codificado en UTF8
caracteres, no bytes. De manera similar para el pragma ": codificación": en ese caso más o menos
se puede leer cualquier carácter.
rehacer ETIQUETA
rehacer EXPR
rehacer
El comando "rehacer" reinicia el bloque de bucle sin volver a evaluar el condicional.
El bloque "continuar", si lo hay, no se ejecuta. Si se omite LABEL, el comando
se refiere al bucle envolvente más interno. El formulario "rehacer EXPR", disponible a partir de
Perl 5.18.0, permite que se calcule un nombre de etiqueta en tiempo de ejecución y, de lo contrario, es
idéntico a "rehacer ETIQUETA". Programas que quieren mentirse a sí mismos sobre lo que fue
simplemente ingrese normalmente use este comando:
# un simple separador de comentarios de Pascal
# (advertencia: asume que no hay { o } en las cadenas)
LINE: mientras ( ) {
mientras (s|({.*}.*){.*}|$1 |) {}
s|{.*}| |;
si (s|{.*| |) {
$frente = $_;
tiempo ( ) {
if (/}/) { # final del comentario?
s|^|$frente\{|;
rehacer LÍNEA;
}
}
}
impresión;
}
"rehacer" no se puede usar para volver a intentar un bloque que devuelve un valor como "eval {}", "sub
{}", o "do {}", y no debe usarse para salir de un grep () or mapa() operación.
Tenga en cuenta que un bloque en sí mismo es semánticamente idéntico a un bucle que se ejecuta una vez.
Por lo tanto, "rehacer" dentro de dicho bloque lo convertirá efectivamente en una construcción en bucle.
Consulte también "continuar" para ver una ilustración de cómo funcionan "último", "siguiente" y "rehacer".
A diferencia de la mayoría de los operadores con nombre, tiene la misma prioridad que la asignación. Tambien es
exento de la regla de parecerse a una función, por lo que "redo ("foo"). "bar"" causará "bar"
ser parte del argumento para "rehacer".
referencia EXPR
ref Devuelve una cadena no vacía si EXPR es una referencia; de lo contrario, la cadena vacía. Si
EXPR no está especificado, se usará $_. El valor devuelto depende del tipo de
cosa a la que la referencia es una referencia.
Los tipos incorporados incluyen:
ESCALAR
FORMACIÓN
Hachís
CÓDIGO
REF
MUNDIALIZA
VALOR
FORMATO
IO
VSTRING
expresión regular
Puede pensar en "ref" como un operador "typeof".
si (ref($r) eq "HASH") {
print "r es una referencia a un hash.\n";
}
a menos que (ref($r)) {
print "r no es una referencia en absoluto.\n";
}
El valor devuelto "LVALUE" indica una referencia a un lvalue que no es una variable.
Obtienes esto al tomar la referencia de llamadas a funciones como "pos()" o "substr()".
Se devuelve "VSTRING" si la referencia apunta a una cadena de versión.
El resultado "Regexp" indica que el argumento es una expresión regular resultante de
"qr//".
Si el objeto al que se hace referencia ha sido bendecido en un paquete, entonces ese nombre de paquete es
devuelto en su lugar. Pero no use eso, ya que ahora se considera una "mala práctica". Para uno
razón, un objeto podría estar usando una clase llamada "Regexp" o "IO", o incluso "HASH".
Además, "ref" no tiene en cuenta las subclases, como sí lo hace "isa".
En su lugar, use "bendecido" (en el módulo Scalar::Util) para verificaciones booleanas, "isa" para
controles de clase específicos y "reftype" (también de Scalar::Util) para controles de tipo. (Ver
perlobj para más detalles y un ejemplo de "bendita/isa".)
Véase también perlref.
renombrar OLDNAME, NEWNAME
Cambia el nombre de un archivo; un archivo existente NEWNAME será golpeado. devuelve verdadero
para el éxito, falso en caso contrario.
El comportamiento de esta función varía enormemente según la implementación de su sistema. Para
ejemplo, por lo general no funcionará a través de los límites del sistema de archivos, aunque el
te mv el comando a veces compensa esto. Otras restricciones incluyen si
funciona en directorios, archivos abiertos o archivos preexistentes. Compruebe perlport y
de la forma más rebautizar(2) página de manual o documentación del sistema equivalente para obtener detalles.
Para una función de "mover" independiente de la plataforma, consulte el módulo Archivo::Copiar.
Problemas de portabilidad: "renombrar" en perlport.
requiere VERSIÓN
requiere EXPR
exigir
Exige una versión de Perl especificada por VERSION, o demanda alguna semántica especificada por
EXPR o por $_ si no se proporciona EXPR.
VERSION puede ser un argumento numérico como 5.006, que se comparará con $],
o un literal de la forma v5.6.1, que se comparará con $^V (también conocido como $PERL_VERSION).
Se lanza una excepción si VERSION es mayor que la versión del Perl actual
intérprete. Compare con "uso", que puede hacer una verificación similar en tiempo de compilación.
Por lo general, se debe evitar especificar VERSION como un literal de la forma v5.6.1,
porque conduce a mensajes de error engañosos en versiones anteriores de Perl que no
no es compatible con esta sintaxis. En su lugar, se debe utilizar la versión numérica equivalente.
requiere v5.6.1; # comprobación de la versión en tiempo de ejecución
requiere 5.6.1; # ídem
requiere 5.006_001; # ídem; preferido para al revés
compatibilidad
De lo contrario, "requerir" exige que se incluya un archivo de biblioteca si aún no se ha incluido.
incluido. El archivo se incluye a través del mecanismo do-FILE, que es esencialmente solo un
variedad de "eval" con la advertencia de que las variables léxicas en el script de invocación
ser invisible para el código incluido. Si se implementara en Perl puro, tendría
semántica similar a la siguiente:
use carpa 'croar';
versión de uso;
sub requiere {
mi ($nombre de archivo) = @_;
if ( mi $version = eval { version->parse($filename) } ) {
if ( $versión > $^V ) {
my $vn = $version->normal;
croak "Perl $vn requerido--esto es solo $^V, detenido";
}
1 regresar;
}
si (existe $INC{$nombre de archivo}) {
devuelve 1 si $INC{$nombrearchivo};
croar "La compilación falló en la solicitud";
}
foreach $prefijo (@INC) {
si (ref ($ prefijo)) {
#... hacer otras cosas - ver el texto a continuación....
}
# (consulte el texto a continuación sobre la posible adición de .pmc
# sufijo de $nombre de archivo)
my $nombrearchivoreal = "$prefijo/$nombrearchivo";
siguiente si! -e $nombrearchivoreal || -d _ || -b _;
$INC{$nombre de archivo} = $nombre de archivo real;
mi $resultado = hacer($nombrearchivoreal);
# pero se ejecuta en el espacio de nombres de la persona que llama
if (!definido $resultado) {
$INC{$nombre de archivo} = undef;
croar $@? "$@Error de compilación en el requisito"
: "No se puede ubicar $nombre de archivo: $!\n";
}
si (!$resultado) {
eliminar $INC{$nombre de archivo};
croak "$filename no devolvió el valor verdadero";
}
PS = 0;
devolver $ resultado;
}
croar "No se puede ubicar $nombre de archivo en \@INC ...";
}
Tenga en cuenta que el archivo no se incluirá dos veces con el mismo nombre especificado.
El archivo debe devolver verdadero como la última declaración para indicar la ejecución exitosa de
cualquier código de inicialización, por lo que es habitual terminar dicho archivo con "1;" a menos que seas
seguro que devolverá verdadero de lo contrario. Pero es mejor solo poner el "1;", en caso de que
añadir más declaraciones.
Si EXPR es una palabra simple, el requerimiento asume un ".pm"extensión y reemplaza"::" con
"/" en el nombre del archivo para facilitar la carga de módulos estándar. Esta forma de
la carga de módulos no corre el riesgo de alterar su espacio de nombres.
En otras palabras, si prueba esto:
requiere Foo::Bar; # una espléndida palabra desnuda
La función require en realidad buscará el "Foo / Bar.pm" archivo en los directorios
especificado en la matriz @INC.
Pero si intentas esto:
$clase = 'Foo::Bar';
requiere $clase; # $clase no es una simple palabra
#o
requieren "Foo::Bar"; # no es una simple palabra por el ""
La función require buscará el "Foo :: Bar" archivo en la matriz @INC y
quejarse de no encontrar"Foo :: Bar" allí. En este caso puedes hacer:
eval "requerir $clase";
Ahora que comprende cómo "requerir" busca archivos con un argumento de palabra simple, hay
es una pequeña funcionalidad adicional que sucede detrás de escena. Antes de "requerir" miradas
para ".pm" extensión, primero buscará un nombre de archivo similar con un ".pmc"
extensión. Si se encuentra este archivo, se cargará en lugar de cualquier archivo que termine en un
".pm"extensión.
También puede insertar ganchos en la función de importación colocando el código Perl directamente en
la matriz @INC. Hay tres formas de ganchos: referencias a subrutinas, matriz
referencias y objetos benditos.
Las referencias a subrutinas son el caso más simple. Cuando el sistema de inclusión avanza
@INC y encuentra una subrutina, esta subrutina se llama con dos parámetros, el
primero una referencia a sí mismo, y el segundo el nombre del archivo que se incluirá (por ejemplo,
"Foo / Bar.pm"). La subrutina debe devolver nada o una lista de hasta
cuatro valores en el siguiente orden:
1. Una referencia a un escalar, que contiene cualquier código fuente inicial para anteponer al archivo
o salida del generador.
2. Un identificador de archivo, desde el que se leerá el archivo.
3. Una referencia a una subrutina. Si no hay identificador de archivo (elemento anterior), entonces este
Se espera que la subrutina genere una línea de código fuente por llamada, escribiendo el
línea en $_ y devolviendo 1, luego finalmente al final del archivo devolviendo 0. Si hay
es un identificador de archivo, entonces se llamará a la subrutina para que actúe como una fuente simple
filtro, con la línea como se lee en $_. Nuevamente, devuelva 1 para cada línea válida y 0
después de que se hayan devuelto todas las líneas.
4. Estado opcional para la subrutina. El estado se pasa como $_[1]. Una referencia
a la subrutina misma se pasa como $_[0].
Si una lista vacía, "undef", o nada que coincida con los primeros 3 valores anteriores es
devuelto, luego "requerir" mira los elementos restantes de @INC. Tenga en cuenta que esto
identificador de archivo debe ser un identificador de archivo real (estrictamente un typeglob o una referencia a un typeglob,
ya sea bendecida o no bendecida); los identificadores de archivo vinculados se ignorarán y el procesamiento se
detente ahí.
Si el enlace es una referencia de matriz, su primer elemento debe ser una referencia de subrutina.
Esta subrutina se llama como se indicó anteriormente, pero el primer parámetro es la referencia de la matriz.
Esto le permite pasar argumentos indirectamente a la subrutina.
En otras palabras, puedes escribir:
empuje @INC, \&my_sub;
sub mi_sub {
my ($coderef, $nombre de archivo) = @_; # $coderef es \&mi_sub
...
}
o bien:
empuje @INC, [ \&my_sub, $x, $y, ... ];
sub mi_sub {
mi ($arrayref, $nombre de archivo) = @_;
# Recuperar $x, $y, ...
mis @parámetros = @$arrayref[1..$#$arrayref];
...
}
Si el gancho es un objeto, debe proporcionar un método INC que se llamará como se indicó anteriormente,
siendo el primer parámetro el objeto mismo. (Tenga en cuenta que debe calificar completamente el
sub, ya que "INC" no calificado siempre se fuerza en el paquete "principal"). Aquí hay un
diseño de código típico:
# En Foo.pm
paquete Foo;
sub nuevo { ... }
subFoo::INC {
mi ($self, $nombre de archivo) = @_;
...
}
# En el programa principal
empuje @INC, Foo->nuevo(...);
Estos ganchos también pueden establecer la entrada %INC correspondiente a los archivos que
han cargado. Ver "%INC" en perlvar.
Para una función de importación aún más potente, consulte "use" y perlmod.
restablecer EXPR
reajustar
Generalmente se usa en un bloque "continuar" al final de un bucle para borrar variables y restablecer
"??" búsquedas para que vuelvan a funcionar. La expresión se interpreta como una lista de
caracteres individuales (guiones permitidos para rangos). Todas las variables y matrices que comienzan
con una de esas letras se restablecen a su estado original. Si la expresión es
omitidas, las búsquedas de una sola coincidencia ("?patrón?") se restablecen para que coincidan nuevamente. Solo reinicios
variables o búsquedas en el paquete actual. Siempre devuelve 1. Ejemplos:
restablecer 'X'; # restablecer todas las variables X
restablecer 'a-z'; # restablecer variables en minúsculas
Reiniciar; # solo reinicie ?una vez? búsquedas
No se recomienda restablecer "AZ" porque eliminará sus arreglos @ARGV y @INC
y su hash %ENV. Restablece solo las variables del paquete; las variables léxicas no se ven afectadas,
pero se limpian solos al salir del alcance de todos modos, por lo que probablemente querrá usarlos
en cambio. Mira mi".
devolución EXPR
volvemos
Retorna desde una subrutina, "eval", o "do FILE" con el valor dado en EXPR.
La evaluación de EXPR puede estar en contexto de lista, escalar o vacío, dependiendo de cómo
se usará el valor de retorno, y el contexto puede variar de una ejecución a la siguiente
(ver "quiero rayar"). Si no se proporciona EXPR, devuelve una lista vacía en el contexto de la lista, el
valor indefinido en contexto escalar, y (por supuesto) nada en absoluto en contexto vacío.
(En ausencia de un "return" explícito, una subrutina, eval o do FILE automáticamente
devuelve el valor de la última expresión evaluada).
A diferencia de la mayoría de los operadores con nombre, esto también está exento de la regla de apariencia de una función,
entonces "return ("foo")."bar"" hará que "bar" sea parte del argumento para "return".
LISTA inversa
En contexto de lista, devuelve un valor de lista que consta de los elementos de LISTA en el
orden opuesto. En contexto escalar, concatena los elementos de LIST y devuelve un
valor de cadena con todos los caracteres en el orden opuesto.
print join(", ", reverse "mundo", "Hola"); # Hola Mundo
imprimir escalar inversa "dlrow", "olleH"; # Hola Mundo
Usado sin argumentos en contexto escalar, contrarrestar () invierte $_.
$_ = "dlrow ,olleH";
imprimir al revés; # Sin salida, lista de contexto
imprimir reverso escalar; # Hola Mundo
Tenga en cuenta que invertir una matriz en sí misma (como en "@a = invertir @a") conservará
elementos existentes siempre que sea posible; es decir, para arreglos no mágicos o para arreglos vinculados
con los métodos "EXISTE" y "DELETE".
Este operador también es útil para invertir un hash, aunque existen algunas advertencias. Si
un valor se duplica en el hash original, solo uno de ellos se puede representar como un
clave en el hash invertido. Además, esto tiene que desenredar un hash y construir uno completamente nuevo
one, que puede llevar algún tiempo en un hash grande, como un archivo DBM.
%by_name = invertir %by_address; # Invertir el hash
rebobinar dirhandle
Establece la posición actual al principio del directorio para la rutina "readdir"
en DIRHANDLE.
Problemas de portabilidad: "rewinddir" en perlport.
rindex STR, SUBSTR, POSITION
rindex STR, SUBSTR
Funciona igual que índice() excepto que devuelve la posición del pasado Ocurrencia de
SUBSTR en STR. Si se especifica POSICIÓN, devuelve la última ocurrencia que comienza en o
antes de esa posición.
rmdir NOMBRE DE ARCHIVO
rmdir
Elimina el directorio especificado por FILENAME si ese directorio está vacío. Si se
tiene éxito devuelve verdadero; de lo contrario, devuelve falso y establece $! (errno). Si NOMBRE DE ARCHIVO
se omite, usa $_.
Para eliminar un árbol de directorios de forma recursiva ("rm -rf" en Unix), mire el "rmtree"
función del módulo File::Path.
s///
El operador de sustitución. Consulte "Operadores similares a cotizaciones Regexp" en perlop.
decir LISTA DE IDENTIFICADORES DE ARCHIVO
diga IDENTIFICADOR DE ARCHIVO
decir LISTA
dice Al igual que "imprimir", pero agrega implícitamente una nueva línea. "decir LISTA" es simplemente una
abreviatura de "{ local $\ = "\n"; print LIST }". Para usar IDENTIFICADOR DE ARCHIVO sin una LISTA
para imprimir el contenido de $_, debe usar un identificador de archivo real como "FH", no un
uno indirecto como $fh.
Esta palabra clave está disponible solo cuando la función "decir" está habilitada o cuando tiene un prefijo
con "NÚCLEO::"; ver característica. Como alternativa, incluya "usar v5.10" o posterior en el
alcance actual.
EXPR escalar
Obliga a EXPR a interpretarse en contexto escalar y devuelve el valor de EXPR.
@cuentas = ( escalar @a, escalar @b, escalar @c );
No existe un operador equivalente para forzar la interpolación de una expresión en la lista
contexto porque en la práctica, esto nunca es necesario. Si realmente quisieras hacerlo,
sin embargo, podría usar la construcción "@{[ (alguna expresión) ]}", pero generalmente un
el simple "(alguna expresión)" es suficiente.
Debido a que "escalar" es un operador unario, si accidentalmente usa una lista entre paréntesis para
la EXPR, se comporta como una expresión de coma escalar, evaluando todos menos el último
elemento en contexto vacío y devolver el elemento final evaluado en contexto escalar.
Esto rara vez es lo que quieres.
La siguiente declaración única:
imprimir uc(escalar(&foo,$barra)),$baz;
es el equivalente moral de estos dos:
& foo;
imprimir(uc($barra),$baz);
Consulte perlop para obtener más detalles sobre los operadores unarios y el operador de coma.
buscar IDENTIFICADOR DE ARCHIVO,POSICIÓN,DÓNDE
Establece la posición de FILEHANDLE, al igual que la llamada "fseek" de "stdio". IDENTIFICADOR DE ARCHIVO puede ser
una expresión cuyo valor da el nombre del identificador de archivo. Los valores para DONDE son
0 para establecer la nueva posición in bytes posicionar; 1 para establecerlo en la posición actual
más POSICIÓN; y 2 para establecerlo en EOF más POSICIÓN, normalmente negativo. para DONDE
puede utilizar las constantes "SEEK_SET", "SEEK_CUR" y "SEEK_END" (inicio del archivo,
posición actual, final del archivo) desde el módulo Fcntl. Devuelve 1 en caso de éxito, falso
de otra manera.
Nota la in bytes: incluso si el identificador de archivo se ha configurado para operar con caracteres (por
ejemplo usando la capa abierta ":encoding(utf8)"), contar() devolverá compensaciones de bytes,
no compensaciones de caracteres (porque implementar eso haría que buscar() y contar() más bien
lento).
Si desea colocar el archivo para "sysread" o "syswrite", no use "buscar",
porque el almacenamiento en búfer hace que su efecto en la posición de lectura y escritura del archivo sea impredecible y
no portátil. Utilice "sysseek" en su lugar.
Debido a las reglas y los rigores de ANSI C, en algunos sistemas debe realizar una búsqueda siempre que
cambias entre leer y escribir. Entre otras cosas, esto puede tener la
efecto de llamar a stdio más claro(3). Un DONDE de 1 ("SEEK_CUR") es útil para no
moviendo la posición del archivo:
buscar (PRUEBA, 0,1);
Esto también es útil para aplicaciones que emulan "tail -f". Una vez que presione EOF en su
lee y luego duerme un rato, (probablemente) tienes que meterte un chupete buscar() a
restablecer las cosas. El "buscar" no cambia la posición, pero sí borrar el final de-
condición de archivo en el mango, de modo que el siguiente " " hace que Perl intente leer de nuevo
algo. (Esperamos.)
Si eso no funciona (algunas implementaciones de E/S son particularmente cascarrabias),
podría necesitar algo como esto:
por (;;) {
for ($curpos = tell(ARCHIVO); $_ = ;
$curpos = decir(ARCHIVO)) {
# busca algunas cosas y ponlas en archivos
}
dormir ($por_un_tiempo);
buscar(ARCHIVO, $curpos, 0);
}
seekdir MANGO DIRH, POS
Establece la posición actual de la rutina "readdir" en DIRHANDLE. POS debe ser un valor
devuelto por "telldir". "seekdir" también tiene las mismas advertencias sobre el posible directorio
compactación como la rutina de biblioteca del sistema correspondiente.
seleccione IDENTIFICADOR DE ARCHIVO
selecciona
Devuelve el identificador de archivo seleccionado actualmente. Si se proporciona FILEHANDLE, establece el nuevo
identificador de archivo predeterminado actual para la salida. Esto tiene dos efectos: primero, una "escritura" o una
"imprimir" sin un identificador de archivo por defecto a este identificador de archivo. En segundo lugar, las referencias a
las variables relacionadas con la salida se referirán a este canal de salida.
Por ejemplo, para establecer el formato de inicio de formulario para más de un canal de salida, puede
Haz lo siguiente:
seleccione (INFORME1);
$^ = 'informe1_superior';
seleccione (INFORME2);
$^ = 'informe2_superior';
FILEHANDLE puede ser una expresión cuyo valor proporcione el nombre del identificador de archivo real.
Así:
$oldfh = seleccionar(STDERR); $| = 1; seleccionar($oldfh);
Algunos programadores pueden preferir pensar en los identificadores de archivos como objetos con métodos,
prefiriendo escribir el último ejemplo como:
use IO :: Handle;
STDERR->lavado automático(1);
Problemas de portabilidad: "seleccionar" en perlport.
seleccione RBITS,WBITS,EBITS,TIEMPO DE ESPERA
Esto llama el selecciona(2) llamada al sistema con las máscaras de bits especificadas, que se pueden
construido usando "fileno" y "vec", así:
$rin = $ganar = $ein = '';
vec ($ rin, fileno (STDIN), 1) = 1;
vec($ganar, fileno(STDOUT), 1) = 1;
$ein = $rin | $ganar;
Si desea seleccionar muchos identificadores de archivo, es posible que desee escribir una subrutina como
modo:
subfbits {
mi @fhlist = @_;
mis $bits = "";
para mi $fh (@fhlist) {
vec($bits, fileno($fh), 1) = 1;
}
devolver $bits;
}
$rin = fhbits(*STDIN, *TTY, *MYSOCK);
El modismo habitual es:
($nencontrado,$tiempo restante) =
select($rout=$rin, $wout=$win, $eout=$ein, $timeout);
o para bloquear hasta que algo esté listo solo haz esto
$nfound = select($rout=$rin, $wout=$win, $eout=$ein, undef);
La mayoría de los sistemas no se molestan en devolver nada útil en $timeleft, por lo que llamar Seleccione()
en contexto escalar solo devuelve $nfound.
Cualquiera de las máscaras de bits también puede estar indefinida. El tiempo de espera, si se especifica, es en segundos,
que puede ser fraccionario. Nota: no todas las implementaciones son capaces de devolver el
$ tiempo restante. De lo contrario, siempre devuelven $timeleft igual al $timeout proporcionado.
Puede efectuar un sueño de 250 milisegundos de esta manera:
seleccionar(undef, undef, undef, 0.25);
Tenga en cuenta que si "seleccionar" se reinicia después de las señales (por ejemplo, SIGALRM) es
dependiente de la implementación. Ver también perlport para notas sobre la portabilidad de "select".
En caso de error, "seleccionar" se comporta como selecciona(2): devuelve -1 y establece $!.
En algunos Unix, selecciona(2) puede informar un descriptor de archivo de socket como "listo para leer"
incluso cuando no hay datos disponibles y, por lo tanto, cualquier "lectura" posterior se bloquearía. Esto puede
debe evitarse si siempre usa O_NONBLOCK en el zócalo. Ver selecciona(2) y fcntl(2) para
más detalles.
El módulo estándar "IO::Select" proporciona una interfaz más fácil de usar para "seleccionar",
principalmente porque hace todo el trabajo de máscara de bits por usted.
ADVERTENCIA: No se debe intentar mezclar E/S almacenadas en búfer (como "leer" o ) con
"seleccionar", excepto lo permitido por POSIX, e incluso entonces solo en sistemas POSIX. Tú tienes
para usar "sysread" en su lugar.
Problemas de portabilidad: "seleccionar" en perlport.
ID de semctl, SEMNUM, CMD, ARG
Llama a la función System V IPC semctl(2). Probablemente tendrás que decir
utilizar IPC::SysV;
primero en obtener las definiciones constantes correctas. Si CMD es IPC_STAT o GETALL, entonces ARG
debe ser una variable que contendrá la estructura semid_ds devuelta o el valor del semáforo
formación. Devuelve como "ioctl": el valor indefinido para el error, ""0 pero verdadero"" para cero,
o el valor de retorno real de lo contrario. El ARG debe consistir en un vector de nativo
enteros cortos, que pueden crearse con "pack("s!",(0)x$nsem)". Véase también "SysV IPC"
en perlipc, documentación "IPC::SysV", "IPC::Semaphore".
Problemas de portabilidad: "semctl" en perlport.
semget CLAVE, NSEMS, BANDERAS
Llama a la función System V IPC semget(2). Devuelve el id del semáforo, o el indefinido
valor en caso de error. Consulte también "SysV IPC" en perlipc, "IPC::SysV", "IPC::SysV::Semaphore"
documentación.
Problemas de portabilidad: "semget" en perlport.
CLAVE semop, CADENA OP
Llama a la función System V IPC semo(2) para operaciones de semáforo como señalización
y esperando. OPSTRING debe ser una matriz empaquetada de estructuras semop. cada semop
La estructura se puede generar con "pack("s!3", $semnum, $semop, $semflag)". La longitud
de OPSTRING implica el número de operaciones de semáforo. Devuelve verdadero si tiene éxito,
falso en caso de error. Como ejemplo, el siguiente código espera en el semáforo $semnum de
id de semáforo $semid:
$semop = pack("s!3", $semnum, -1, 0);
die "Problema de semáforo: $!\n" a menos que semop($semid, $semop);
Para señalar el semáforo, reemplace "-1" con 1. Ver también "SysV IPC" en perlipc,
Documentación "IPC::SysV" e "IPC::SysV::Semaphore".
Problemas de portabilidad: "semop" en perlport.
enviar SOCKET,MSG,FLAGS,TO
enviar SOCKET,MSG,BANDERAS
Envía un mensaje en un socket. Intenta enviar el MSG escalar al SOCKET
identificador de archivo Toma las mismas banderas que la llamada al sistema del mismo nombre. en desconectado
sockets, debe especificar un destino para send a, en cuyo caso hace un SendTo(2)
llamada al sistema. Devuelve el número de caracteres enviados o el valor indefinido en caso de error. Él
enviarmsg(2) syscall actualmente no está implementado. Ver "UDP: Paso de mensajes" en perlipc
por ejemplo.
Nota la personajes: dependiendo del estado del socket, ya sea bytes (8 bits) o
Se envían caracteres. De forma predeterminada, todos los sockets funcionan con bytes, pero, por ejemplo, si el
socket ha sido cambiado usando binmode () para operar con la E/S ":encoding(utf8)"
capa (ver "abierto", o el pragma "abierto", abierto), la E/S operará en UTF-8 codificado
Caracteres Unicode, no bytes. De manera similar para el pragma ": codificación": en ese caso
Se puede enviar prácticamente cualquier carácter.
setpgrp PID, PGRP
Establece el grupo de procesos actual para el PID especificado, 0 para el proceso actual.
Genera una excepción cuando se usa en una máquina que no implementa POSIX establecerpgid(2) o
BSD setpgrp(2). Si se omiten los argumentos, el valor predeterminado es "0,0". Tenga en cuenta que el
La versión BSD 4.2 de "setpgrp" no acepta ningún argumento, por lo que solo "setpgrp(0,0)" es
portátil. Véase también "POSIX::setsid()".
Problemas de portabilidad: "setpgrp" en perlport.
establecer prioridad CUÁL, QUIÉN, PRIORIDAD
Establece la prioridad actual para un proceso, un grupo de procesos o un usuario. (Ver
fijar prioridad(2).) Genera una excepción cuando se usa en una máquina que no implementa
fijar prioridad(2).
Problemas de portabilidad: "setpriority" en perlport.
setsockopt SOCKET, NIVEL, OPT NOMBRE, OPTVAL
Establece la opción de socket solicitada. Devuelve "undef" en caso de error. Usar constantes enteras
proporcionado por el módulo "Socket" para LEVEL y OPNAME. Los valores para LEVEL también se pueden
obtenido de getprotobyname. OPTVAL puede ser una cadena empaquetada o un número entero.
Un entero OPTVAL es la abreviatura de pack("i", OPTVAL).
Un ejemplo deshabilitando el algoritmo de Nagle en un socket:
use Socket qw (IPPROTO_TCP TCP_NODELAY);
setsockopt($enchufe, IPPROTO_TCP, TCP_NODELAY, 1);
Problemas de portabilidad: "setsockopt" en perlport.
matriz de cambio
turno EXPR
Turno
Desplaza el primer valor de la matriz y lo devuelve, acortando la matriz en 1 y
moviendo todo hacia abajo. Si no hay elementos en la matriz, devuelve el indefinido
valor. Si se omite ARRAY, desplaza la matriz @_ dentro del alcance léxico de
subrutinas y formatos, y la matriz @ARGV fuera de una subrutina y también dentro de la
alcances léxicos establecidos por "eval STRING", "BEGIN {}", "INIT {}", "CHECK {}",
Construcciones "UNITCHECK {}" y "END {}".
A partir de Perl 5.14, "shift" puede tomar un EXPR escalar, que debe contener una referencia
a una matriz no bendecida. El argumento será desreferenciado automáticamente. Este aspecto
de "cambio" se considera altamente experimental. El comportamiento exacto puede cambiar en un
futura versión de Perl.
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.014; # entonces push/pop/etc funciona en escalares (experimental)
Véase también "unshift", "push" y "pop". "shift" y "unshift" hacen lo mismo con el
extremo izquierdo de una matriz que "pop" y "push" hacen en el extremo derecho.
ID de shmctl,CMD,ARG
Llama a la función shmctl de System V IPC. Probablemente tendrás que decir
utilizar IPC::SysV;
primero en obtener las definiciones constantes correctas. Si CMD es "IPC_STAT", entonces ARG debe ser
una variable que contendrá la estructura "shmid_ds" devuelta. Devuelve como ioctl:
"undef" para error; "0 pero cierto" por cero; y el valor de retorno real de lo contrario. Ver
también "SysV IPC" en perlipc y documentación "IPC::SysV".
Problemas de portabilidad: "shmctl" en perlport.
shmget CLAVE, TAMAÑO, BANDERAS
Llama a la función shmget de System V IPC. Devuelve la identificación del segmento de memoria compartida, o
"undef" en caso de error. Consulte también "SysV IPC" en perlipc y la documentación "IPC::SysV".
Problemas de portabilidad: "shmget" en perlport.
shmread ID, VAR, POS, TAMAÑO
shmwrite ID,CADENA,POS,TAMAÑO
Lee o escribe el ID de segmento de memoria compartida de System V comenzando en la posición POS para
size SIZE anexándolo, copiándolo/desincorporándolo y separándolo. Al leer,
VAR debe ser una variable que contendrá la lectura de datos. Al escribir, si STRING es demasiado
de largo, solo se utilizan bytes de TAMAÑO; si STRING es demasiado corto, se escriben nulos para completar
TAMAÑO bytes. Devuelve verdadero si tiene éxito, falso en caso de error. shmread () contamina el
variable. Consulte también "SysV IPC" en perlipc, "IPC::SysV" y "IPC::Shareable"
módulo de CPAN.
Problemas de portabilidad: "shmread" en perlport y "shmwrite" en perlport.
apagado SOCKET, CÓMO
Cierra una conexión de enchufe de la manera indicada por CÓMO, que tiene el mismo
interpretación como en la llamada al sistema del mismo nombre.
apagado (CONECTOR, 0); # He/hemos dejado de leer datos
apagado (CONECTOR, 1); # He/hemos dejado de escribir datos
apagado (CONECTOR, 2); # Yo/hemos dejado de usar este socket
Esto es útil con sockets cuando quiere decirle al otro lado que ha terminado de escribir
pero no terminó de leer, o viceversa. También es una forma más insistente de cierre porque
también deshabilita el descriptor de archivo en cualquier copia bifurcada en otros procesos.
Devuelve 1 para éxito; en caso de error, devuelve "undef" si el primer argumento no es válido
identificador de archivo, o devuelve 0 y establece $! por cualquier otro fallo.
pecado EXPR
sin Devuelve el seno de EXPR (expresado en radianes). Si se omite EXPR, devuelve el seno de
PS
Para la operación del seno inverso, puede usar la función "Math::Trig::asin", o usar
esta relación:
sub asen { atan2($_[0], sqrt(1 - $_[0] * $_[0])) }
sueño EXPR
sleep
Hace que la secuencia de comandos se duerma durante (entero) EXPR segundos, o para siempre si no hay ningún argumento
dado. Devuelve el número entero de segundos realmente dormidos.
Puede interrumpirse si el proceso recibe una señal como "SIGALRM".
evaluar {
local $SIG{ALARMA} = sub { die "¡Alarma!\n" };
dormir
};
die $@ a menos que $@ eq "¡Alarma!\n";
Probablemente no pueda mezclar las llamadas de "alarma" y "dormir", porque "dormir" a menudo
implementado usando "alarma".
En algunos sistemas más antiguos, puede dormir hasta un segundo completo menos de lo que solicitó,
dependiendo de cómo cuente los segundos. La mayoría de los sistemas modernos siempre duermen la cantidad completa.
Sin embargo, puede parecer que duermen más que eso, porque su proceso podría no ser
programado de inmediato en un sistema multitarea ocupado.
Para retrasos de granularidad más fina que un segundo, el módulo Time :: HiRes (de CPAN,
y a partir de Perl 5.8 parte de la distribución estándar) proporciona tu duerme(). Usted
también puede usar la versión de cuatro argumentos de Perl de Seleccione() dejando los tres primeros
argumentos no definidos, o puede utilizar la interfaz "syscall" para acceder
temporizador(2) si su sistema lo admite. Consulte perlfaq8 para obtener más detalles.
Consulte también la función de "pausa" del módulo POSIX.
socket SOCKET,DOMINIO,TIPO,PROTOCOLO
Abre un socket del tipo especificado y lo adjunta al identificador de archivo SOCKET. DOMINIO,
TYPE y PROTOCOL se especifican igual que para la llamada al sistema del mismo nombre. Tú
debe "usar Socket" primero para obtener las definiciones adecuadas importadas. Vea los ejemplos en
"Sockets: Comunicación Cliente/Servidor" en perlipc.
En los sistemas que admiten un indicador de cierre en el ejecutivo en los archivos, el indicador se establecerá para el
descriptor de archivo recién abierto, según lo determinado por el valor de $ ^ F. Ver "$ ^ F" en
perlvar.
par de sockets SOCKET1, SOCKET2, DOMINIO, TIPO, PROTOCOLO
Crea un par de sockets sin nombre en el dominio especificado, del tipo especificado.
DOMINIO, TIPO y PROTOCOLO se especifican igual que para la llamada al sistema del mismo nombre.
Si no se implementa, genera una excepción. Devuelve verdadero si tiene éxito.
En los sistemas que admiten un indicador de cierre en el ejecutivo en los archivos, el indicador se establecerá para el
descriptores de archivos recién abiertos, según lo determinado por el valor de $^F. Ver "$^F" en
perlvar.
Algunos sistemas definieron "tubería" en términos de "par de enchufes", en los que una llamada a "tubería (Rdr,
Wtr)" es esencialmente:
utilizar Socket;
par de enchufes (Rdr, Wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC);
apagar (Rdr, 1); # no más escribir para el lector
apagado (Wtr, 0); # no más lectura para escritor
Consulte perlipc para ver un ejemplo del uso de pares de sockets. Perl 5.8 y versiones posteriores emularán
par de sockets usando sockets IP para localhost si su sistema implementa sockets pero no
par de enchufes
Problemas de portabilidad: "par de sockets" en perlport.
ordenar LISTA DE SUBNOMBRES
ordenar LISTA DE BLOQUEO
Lista Ordenada
En el contexto de la lista, ordena la LISTA y devuelve el valor de la lista ordenada. en escalar
contexto, el comportamiento de "sort()" no está definido.
Si se omite SUBNAME o BLOCK, se "ordena" en el orden de comparación de cadenas estándar. Si
Se especifica SUBNAME, da el nombre de una subrutina que devuelve un entero menos
que, igual o mayor que 0, dependiendo de cómo se vayan a clasificar los elementos de la lista
ordenado. (Los operadores "<=>" y "cmp" son extremadamente útiles en este tipo de rutinas).
SUBNAME puede ser un nombre de variable escalar (sin subíndice), en cuyo caso el valor
proporciona el nombre de (o una referencia a) la subrutina real a usar. en lugar de un
SUBNOMBRE, puede proporcionar un BLOQUE como una subrutina de clasificación en línea anónima.
Si el prototipo de la subrutina es "($$)", los elementos a comparar se pasan por
referencia en @_, como para una subrutina normal. Esto es más lento que sin prototipo
subrutinas, donde los elementos a comparar se pasan a la subrutina como el
paquete de variables globales $a y $b (ver ejemplo a continuación). Nótese que en este último caso,
suele ser muy contraproducente declarar $a y $b como léxicos.
Si la subrutina es una XSUB, los elementos a comparar se empujan a la pila,
la forma en que los argumentos generalmente se pasan a los XSUB. $a y $b no están configurados.
Los valores a comparar siempre se pasan por referencia y no deben modificarse.
Tampoco puede salir del bloque de clasificación o subrutina usando cualquiera de los controles de bucle.
operadores descritos en perlsyn o con "goto".
Cuando "use locale" (pero no "use locale 'not_characters'") está en efecto, "ordenar LISTA"
ordena LIST de acuerdo con la configuración regional actual. Véase perlocale.
ordenar() devuelve los alias a la lista original, como una variable de índice del bucle for
alias los elementos de la lista. Es decir, modificar un elemento de una lista devuelta por ordenar()
(por ejemplo, en un "foreach", "mapa" o "grep") en realidad modifica el elemento en el
lista original Esto suele ser algo que debe evitarse cuando se escribe código claro.
Perl 5.6 y versiones anteriores usaban un algoritmo de ordenación rápida para implementar la ordenación. Ese algoritmo fue
no es estable, por lo que could ir cuadrático. (UN estable sort conserva el orden de entrada de
elementos que se comparan iguales. Aunque el tiempo de ejecución de quicksort es O (NlogN) cuando se promedia
sobre todas las matrices de longitud N, el tiempo puede ser O(N**2), cuadrático comportamiento, para algunos
entradas.) En 5.7, la implementación de clasificación rápida se reemplazó con una clasificación de combinación estable
algoritmo cuyo comportamiento en el peor de los casos es O(NlogN). Pero los puntos de referencia indicaron que para
algunas entradas, en algunas plataformas, el quicksort original era más rápido. 5.8 tiene una especie
pragma para el control limitado de la clase. Su control bastante contundente de la subyacente
El algoritmo puede no persistir en Perls futuros, pero la capacidad de caracterizar la entrada
o la salida en formas independientes de la implementación muy probablemente lo hará. ver el tipo
pragma.
Ejemplos:
# ordenar léxicamente
@articulos = ordenar @archivos;
# lo mismo, pero con una rutina de clasificación explícita
@articulos = ordenar {$a cmp $b} @archivos;
# ahora distingue entre mayúsculas y minúsculas
@articulos = ordenar {fc($a) cmp fc($b)} @archivos;
# lo mismo en orden inverso
@articulos = ordenar {$b cmp $a} @archivos;
# ordenar numéricamente de forma ascendente
@articulos = ordenar {$a <=> $b} @archivos;
# ordenar numéricamente de forma descendente
@articulos = ordenar {$b <=> $a} @archivos;
# esto ordena el hash de %age por valor en lugar de por clave
# usando una función en línea
@mayor = ordenar { $edad{$b} <=> $edad{$a} } claves %edad;
# ordenar usando un nombre de subrutina explícito
sub porage {
$edad{$a} <=> $edad{$b}; # presunción numérica
}
@sortedclass = ordenar por edad @class;
sub al revés { $b cmp $a }
@harry = qw(perro gato x Cain Abel);
@george = qw(perseguido y castigado con hacha);
tipo de impresión @harry;
# imprime AbelCaincatdogx
imprimir ordenar al revés @harry;
# imprime xdogcatCainAbel
imprimir ordenar @george, 'a', @harry;
# imprime AbelAxedCainCastigadoatrapadoperseguidoperronetoxyz
# ordenar de manera ineficiente mediante comparación numérica descendente usando
# el primer entero después del primer signo =, o el
# registro completo sin distinción entre mayúsculas y minúsculas de lo contrario
mi @nuevo = ordenar {
($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
||
fc($a) cmp fc($b)
} @antiguo;
# lo mismo, pero mucho más eficiente;
# construiremos índices auxiliares en su lugar
# por velocidad
mi (@nums, @caps);
para (@antiguo) {
empuje @nums, ( /=(\d+)/ ? $1 : undef );
empuje @mayúsculas, fc($_);
}
mi @nuevo = @antiguo[ ordenar {
$numeros[$b] <=> $numeros[$a]
||
$mayúsculas[$a] cmp $mayúsculas[$b]
} 0..$#antiguo
];
# lo mismo, pero sin ninguna temperatura
@nuevo = mapa { $_->[0] }
ordenar { $b->[1] <=> $a->[1]
||
$ a -> [2] cmp $ b -> [2]
} mapa { [$_, /=(\d+)/, fc($_)] } @old;
# usar un prototipo le permite usar cualquier subrutina de comparación
# como una subrutina de clasificación (incluidas las subrutinas de otros paquetes)
otro paquete;
sub hacia atrás ($$) { $_[1] cmp $_[0]; } # $a y $b son
# no establecido aquí
paquete principal;
@nuevo = ordenar otro::hacia atrás @antiguo;
# garantizar la estabilidad, independientemente del algoritmo
use ordenar 'estable';
@nuevo = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
# forzar el uso de mergesort (no portátil fuera de Perl 5.8)
usar ordenar '_mergesort'; # nota desalentadora _
@nuevo = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
Advertencia: se requiere cuidado sintáctico al ordenar la lista devuelta por una función.
Si desea ordenar la lista devuelta por la llamada de función "find_records(@key)", debe
puedo usar:
@contacto = sort { $a cmp $b } find_records @key;
@contacto = ordenar +buscar_registros(@clave);
@contacto = ordenar &buscar_registros(@clave);
@contacto = ordenar(buscar_registros(@clave));
Si, en cambio, desea ordenar la matriz @key con la rutina de comparación
"find_records()" entonces puedes usar:
@contacto = sort { find_records() } @key;
@contacto = ordenar find_records(@key);
@contacto = sort(find_records @key);
@contacto = ordenar(buscar_registros (@clave));
Si está usando estricto, usted deben no declarar $a y $b como léxicos. son paquete
globales Eso significa que si está en el paquete "principal" y escribe
@articulos = ordenar {$b <=> $a} @archivos;
entonces $a y $b son $main::a y $main::b (o $::a y $::b), pero si estás en el
Paquete "FooPack", es lo mismo que escribir
@articulos = sort {$FooPack::b <=> $FooPack::a} @files;
Se requiere que la función de comparación se comporte. Si devuelve resultados inconsistentes
(a veces se dice que $x[1] es menor que $x[2] y a veces se dice lo contrario, por
ejemplo) los resultados no están bien definidos.
Debido a que "<=>" devuelve "undef" cuando cualquiera de los operandos es "NaN" (no es un número), tenga cuidado
al ordenar con una función de comparación como "$a <=> $b" cualquier lista que pueda contener
un "NaN". El siguiente ejemplo aprovecha que "NaN != NaN" para eliminar cualquier
"NaN"s de la lista de entrada.
@resultado = sort { $a <=> $b } grep { $_ == $_ } @input;
empalme MATRIZ, DESPLAZAMIENTO, LONGITUD, LISTA
empalme MATRIZ, DESPLAZAMIENTO, LONGITUD
matriz de empalme, DESPLAZAMIENTO
matriz de empalme
empalme EXPR, DESPLAZAMIENTO, LONGITUD, LISTA
empalme EXPR, DESPLAZAMIENTO, LONGITUD
empalme EXPR, DESPLAZAMIENTO
empalme EXPR
Elimina los elementos designados por OFFSET y LENGTH de una matriz y los reemplaza
con los elementos de LIST, si los hubiere. En contexto de lista, devuelve los elementos eliminados de
la matriz En contexto escalar, devuelve el último elemento eliminado, o "undef" si no
se eliminan los elementos. La matriz crece o se reduce según sea necesario. Si OFFSET es negativo
entonces comienza tan lejos del final de la matriz. Si se omite LONGITUD, elimina
todo desde OFFSET en adelante. Si LENGTH es negativo, elimina los elementos de
DESPLAZAMIENTO en adelante excepto para los elementos -LENGTH al final de la matriz. Si tanto OFFSET como
LENGTH se omiten, elimina todo. Si OFFSET está más allá del final de la matriz y un
Se proporcionó LENGTH, Perl emite una advertencia y se empalma al final de la matriz.
Se mantienen las siguientes equivalencias (suponiendo que "$#a >= $i" )
empujar(@a,$x,$y) empalme(@a,@a,0,$x,$y)
pop(@a) empalme(@a,-1)
cambio(@a) empalme(@a,0,1)
unshift(@a,$x,$y) empalme(@a,0,0,$x,$y)
$a[$i] = $y empalme(@a,$i,1,$y)
"empalme" se puede utilizar, por ejemplo, para implementar el procesamiento de colas n-arias:
subnary_print {
my $ n = turno;
while (mi @next_n = empalme @_, 0, $n) {
decir unir q{ -- }, @next_n;
}
}
nary_print(3, qw(abcdefgh));
# impresiones:
# a B C
# re -- e -- f
#g-h
A partir de Perl 5.14, "empalme" puede tomar EXPR escalar, que debe contener una referencia a
una matriz no bendecida. El argumento será desreferenciado automáticamente. Este aspecto de
"empalme" se considera altamente experimental. El comportamiento exacto puede cambiar en un
futura versión de Perl.
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.014; # entonces push/pop/etc funciona en escalares (experimental)
dividir /PATRÓN/,EXPR,LÍMITE
dividir /PATRÓN/,EXPR
dividir /PATRÓN/
split
Divide la cadena EXPR en una lista de cadenas y devuelve la lista en contexto de lista, o
el tamaño de la lista en contexto escalar.
Si solo se da PATRÓN, EXPR por defecto es $_.
Cualquier cosa en EXPR que coincida con PATTERN se toma como un separador que separa el
EXPR en subcadenas (llamadas "campos") Esto hace no incluir el separador. Tenga en cuenta que un
separador puede tener más de un carácter o incluso no tener ningún carácter (el
cadena vacía, que es una coincidencia de ancho cero).
El PATRÓN no necesita ser constante; se puede usar una expresión para especificar un patrón que
varía en tiempo de ejecución.
Si PATRÓN coincide con la cadena vacía, EXPR se divide en la posición de coincidencia (entre
caracteres). Como ejemplo, lo siguiente:
imprimir unir(':', dividir('b', 'abc')), "\n";
usa la 'b' en 'abc' como separador para producir la salida 'a:c'. Sin embargo, esto:
imprimir unir(':', dividir('', 'abc')), "\n";
utiliza coincidencias de cadenas vacías como separadores para producir la salida 'a:b:c'; así, el vacío
La cadena se puede usar para dividir EXPR en una lista de sus caracteres componentes.
Como un caso especial para "dividir", el patrón vacío dado en la sintaxis del operador de coincidencia ("//")
coincide específicamente con la cadena vacía, lo que es contrario a su interpretación habitual
como el último partido exitoso.
Si PATRÓN es "/^/", entonces se trata como si usara el modificador multilínea ("/^/m"),
ya que de otra manera no sirve de mucho.
Como otro caso especial, "dividir" emula el comportamiento predeterminado de la línea de comando
del IRS awk cuando se omite el PATRÓN o se literal cadena compuesto por un solo
carácter de espacio (como ' ' o "\x20", pero no, por ejemplo, "/ /"). En este caso, cualquier
el espacio en blanco inicial en EXPR se elimina antes de que se produzca la división, y el PATRÓN se
en cambio, se trata como si fuera "/\s+/"; en particular, esto significa que any contiguo
El espacio en blanco (no solo un carácter de espacio único) se usa como separador. Sin embargo, esto
se puede evitar un tratamiento especial especificando el patrón "/ /" en lugar de la cadena
" ", lo que permite que solo un carácter de espacio único sea un separador. en antes
Perls este caso especial estaba restringido al uso de un simple " " como patrón
argumento para dividir, en Perl 5.18.0 y versiones posteriores, este caso especial se desencadena por cualquier
expresión que se evalúa como la cadena simple " ".
Si se omite, el PATRÓN se establece por defecto en un solo espacio, " ", activando el
descrito awk emulación.
Si se especifica LIMIT y es positivo, representa el número máximo de campos en
que la EXPR puede dividirse; en otras palabras, LIMIT es uno mayor que el máximo
número de veces que se puede dividir EXPR. Por lo tanto, el valor LIMIT 1 significa que EXPR puede ser
dividir un máximo de cero veces, produciendo un máximo de un campo (es decir, todo el
valor de EXPR). Por ejemplo:
imprimir unir(':', dividir(//, 'abc', 1)), "\n";
produce la salida 'abc', y esto:
imprimir unir(':', dividir(//, 'abc', 2)), "\n";
produce la salida 'a:bc', y cada uno de estos:
imprimir unir(':', dividir(//, 'abc', 3)), "\n";
imprimir unir(':', dividir(//, 'abc', 4)), "\n";
produce la salida 'a:b:c'.
Si LIMIT es negativo, se trata como si fuera arbitrariamente grande; como muchos
se producen campos como sea posible.
Si se omite LIMIT (o, equivalentemente, cero), generalmente se trata como si fuera
en lugar negativo, pero con la excepción de que los campos vacíos finales se eliminan (vacío
los campos principales siempre se conservan); si todos los campos están vacíos, entonces todos los campos están
considerados de seguimiento (y, por lo tanto, se eliminan en este caso). Así, lo siguiente:
print join(':', split(',', 'a,b,c,,,')), "\n";
produce la salida 'a:b:c', pero lo siguiente:
print join(':', split(',', 'a,b,c,,,', -1)), "\n";
produce la salida 'a:b:c:::'.
En aplicaciones de tiempo crítico, vale la pena evitar dividir en más campos
de lo necesario. Por lo tanto, al asignar a una lista, si se omite LIMIT (o cero), entonces
LIMIT se trata como si fuera uno más grande que el número de variables en el
lista; para lo siguiente, LIMIT es implícitamente 3:
($inicio de sesión, $contraseña) = split(/:/);
Tenga en cuenta que dividir un EXPR que se evalúa como la cadena vacía siempre produce cero
campos, independientemente del LÍMITE especificado.
Se produce un campo inicial vacío cuando hay una coincidencia de ancho positivo en el
principio de EXPR. Por ejemplo:
imprimir unir(':', dividir(/ /, 'abc')), "\n";
produce la salida ':abc'. Sin embargo, una coincidencia de ancho cero al comienzo de EXPR
nunca produce un campo vacío, por lo que:
imprimir unir(':', dividir(//, 'abc'));
produce la salida ' :a:b:c' (en lugar de ': :a:b:c').
Un campo final vacío, por otro lado, se produce cuando hay una coincidencia en el
final de EXPR, independientemente de la duración del partido (por supuesto, a menos que un LIMIT distinto de cero
se da explícitamente, dichos campos se eliminan, como en el último ejemplo). Por lo tanto:
imprimir unir(':', dividir(//, 'abc', -1)), "\n";
produce la salida ' :a:b:c:'.
Si el PATRÓN contiene grupos de captura, entonces para cada separador, un campo adicional
se produce para cada subcadena capturada por un grupo (en el orden en que los grupos
se especifican, según las referencias anteriores); si algún grupo no coincide, entonces captura
el valor "undef" en lugar de una subcadena. Además, tenga en cuenta que cualquier campo adicional
se produce cada vez que hay un separador (es decir, cada vez que se produce una división), y tal
un campo adicional hace no cuenta para el LÍMITE. Considera lo siguiente
expresiones evaluadas en contexto de lista (cada lista devuelta se proporciona en el
comentario asociado):
dividir(/-|,/, "1-10,20", 3)
# ('1', '10', '20')
división(/(-|,)/, "1-10,20", 3)
# ('1', '-', '10', ',', '20')
dividir(/-|(,)/, "1-10,20", 3)
# ('1', sin definir, '10', ',', '20')
dividir(/(-)|,/, "1-10,20", 3)
# ('1', '-', '10', indefinido, '20')
división(/(-)|(,)/, "1-10,20", 3)
# ('1', '-', no definido, '10', no definido, ',', '20')
sprintf FORMATO, LISTA
Devuelve una cadena formateada según las convenciones habituales de "printf" de la función de biblioteca C
"sprintf". Vea a continuación para obtener más detalles y ver correr(3) o Printf(3) en su sistema
para una explicación de los principios generales.
Por ejemplo:
# Formato de número con hasta 8 ceros a la izquierda
$resultado = sprintf("%08d", $numero);
# Número redondeado a 3 dígitos después del punto decimal
$redondeado = sprintf("%.3f", $numero);
Perl hace su propio formateo "sprintf": emula la función C correr(3), pero
no lo usa excepto para números de coma flotante, e incluso entonces solo estándar
Se permiten modificadores. Extensiones no estándar en tu local correr(3) son por lo tanto
no disponible en Perl.
A diferencia de "printf", "sprintf" no hace lo que probablemente quiere decir cuando le pasa un
matriz como su primer argumento. La matriz recibe un contexto escalar y, en lugar de usar
el elemento 0 de la matriz como formato, Perl utilizará el recuento de elementos en el
array como formato, que casi nunca es útil.
El "sprintf" de Perl permite las siguientes conversiones universalmente conocidas:
%% un signo de porcentaje
%ca carácter con el número dado
%sa cadena
%da entero con signo, en decimal
%u un entero sin signo, en decimal
%o un entero sin signo, en octal
%x un entero sin signo, en hexadecimal
%ea número de punto flotante, en notación científica
%fa número de coma flotante, en notación decimal fija
%ga número de punto flotante, en notación %e o %f
Además, Perl permite las siguientes conversiones ampliamente admitidas:
%X como %x, pero usando letras mayúsculas
%E como %e, pero usando una "E" mayúscula
%G como %g, pero con una "E" mayúscula (si corresponde)
%b un entero sin signo, en binario
%B como %b, pero usando una "B" mayúscula con el indicador #
Puntero %pa (muestra la dirección del valor de Perl en hexadecimal)
%n especial: *almacena* el número de caracteres emitidos hasta el momento
en el siguiente argumento en la lista de parámetros
%un punto flotante hexadecimal
%A como %a, pero usando letras mayúsculas
Finalmente, para compatibilidad con versiones anteriores (y queremos decir "hacia atrás"), Perl permite estos
Conversiones innecesarias pero ampliamente admitidas:
%ia sinónimo de %d
%D un sinónimo de %ld
%U un sinónimo de %lu
%O un sinónimo de %lo
%F un sinónimo de %f
Tenga en cuenta que el número de dígitos del exponente en la notación científica producida por %e, %E,
%g y %G para números con el módulo del exponente menor que 100 es sistema-
dependiente: puede ser tres o menos (se rellena con ceros según sea necesario). En otras palabras, 1.23
multiplicado por diez elevado a 99 puede ser "1.23e99" o "1.23e099". Del mismo modo para %a y %A:
el exponente o los dígitos hexadecimales pueden flotar: especialmente los "dobles largos" Perl
opción de configuración puede causar sorpresas.
Entre el "%" y la letra de formato, puede especificar varios atributos adicionales
controlar la interpretación del formato. En orden, estos son:
índice de parámetros de formato
Un índice de parámetro de formato explícito, como "2$". Por defecto, sprintf formateará
el siguiente argumento no utilizado en la lista, pero esto le permite tomar los argumentos
fuera de servicio:
printf '%2$d %1$d', 12, 34; # imprime "34 12"
printf '%3$d %d %1$d', 1, 2, 3; # imprime "3 1 1"
banderas
uno o más de:
prefijo de espacio número no negativo con un espacio
+ prefijo número no negativo con un signo más
- justificar a la izquierda dentro del campo
0 use ceros, no espacios, para justificar a la derecha
# asegurar el "0" inicial para cualquier octal,
prefijo hexadecimal distinto de cero con "0x" o "0X",
prefijo binario distinto de cero con "0b" o "0B"
Por ejemplo:
printf '<% d>', 12; # imprime "<12>"
imprimirf '<%+d>', 12; # imprime "<+12>"
imprimirf '<%6s>', 12; # imprime "<12>"
imprimirf '<%-6s>', 12; # imprime "<12>"
imprimirf '<%06s>', 12; # imprime "<000012>"
imprimirf '<%#o>', 12; # imprime "<014>"
imprimirf '<%#x>', 12; # imprime "<0xc>"
imprimirf '<%#X>', 12; # imprime "<0XC>"
imprimirf '<%#b>', 12; # imprime "<0b1100>"
imprimirf '<%#B>', 12; # imprime "<0B1100>"
Cuando se dan un espacio y un signo más como banderas a la vez, se usa un signo más
anteponer un número positivo.
printf '<%+d>', 12; # imprime "<+12>"
imprimirf '<%+d>', 12; # imprime "<+12>"
Cuando se dan el indicador # y una precisión en la conversión %o, la precisión es
incrementado si es necesario para el "0" inicial.
imprimirf '<%#.5o>', 012; # imprime "<00012>"
imprimirf '<%#.5o>', 012345; # imprime "<012345>"
imprimirf '<%#.0o>', 0; # imprime "<0>"
bandera vectorial
Esta bandera le dice a Perl que interprete la cadena proporcionada como un vector de enteros, uno
para cada carácter de la cadena. Perl aplica el formato a cada entero en
turn, luego une las cadenas resultantes con un separador (un punto "." por defecto).
Esto puede ser útil para mostrar valores ordinales de caracteres en forma arbitraria.
instrumentos de cuerda:
printf "%vd", "AB\x{100}"; # imprime "65.66.256"
printf "la versión es v% vd \ n", $ ^ V; # Versión de Perl
Coloque un asterisco "*" antes de la "v" para anular la cadena que se usará para separar los
números:
printf "la dirección es %*vX\n", ":", $dirección; # dirección IPv6
printf "los bits son %0*v8b\n", " ", $bits; # cadena de bits aleatoria
También puede especificar explícitamente el número de argumento que se usará para la cadena de unión
usando algo como "*2$v"; por ejemplo:
printf '%*4$vX %*4$vX %*4$vX', # 3 direcciones IPv6
@dir[1..3], ":";
(mínimo) ancho
Los argumentos se suelen formatear para que tengan el ancho necesario para mostrar el
valor dado. Puede anular el ancho poniendo un número aquí, u obtener el
ancho del siguiente argumento (con "*") o de un argumento especificado (por ejemplo, con
"*2$"):
printf "<%s>", "un"; # imprime " "
printf "<%6s>", "un"; # imprime "<a>"
printf "<%*s>", 6, "a"; # imprime "<a>"
printf '<%*2$s>', "a", 6; # imprime "<a>"
printf "<%2s>", "largo"; # imprime " " (no se trunca)
Si un ancho de campo obtenido mediante "*" es negativo, tiene el mismo efecto que el
Indicador "-": justificación a la izquierda.
precisión, o ancho máximo
Puede especificar una precisión (para conversiones numéricas) o un ancho máximo (para
conversiones de cadena) especificando un "." seguido de un número. Para punto flotante
formatos excepto "g" y "G", esto especifica cuántos lugares a la derecha del decimal
punto a mostrar (el valor predeterminado es 6). Por ejemplo:
# estos ejemplos están sujetos a variaciones específicas del sistema
imprimirf '<%f>', 1; # imprime "<1.000000>"
imprimirf '<%.1f>', 1; # imprime "<1.0>"
imprimirf '<%.0f>', 1; # imprime "<1>"
imprimirf '<%e>', 10; # imprime "<1.000000e+01>"
imprimirf '<%.1e>', 10; # imprime "<1.0e+01>"
Para "g" y "G", esto especifica el número máximo de dígitos a mostrar, incluidos
los anteriores al punto decimal y los posteriores; por ejemplo:
# Estos ejemplos están sujetos a variaciones específicas del sistema.
imprimirf '<%g>', 1; # imprime "<1>"
imprimirf '<%.10g>', 1; # imprime "<1>"
imprimirf '<%g>', 100; # imprime "<100>"
imprimirf '<%.1g>', 100; # imprime "<1e+02>"
imprimirf '<%.2g>', 100.01; # imprime "<1e+02>"
imprimirf '<%.5g>', 100.01; # imprime "<100.01>"
imprimirf '<%.4g>', 100.01; # imprime "<100>"
Para conversiones de enteros, especificar una precisión implica que la salida del
el número en sí debe tener un relleno con ceros hasta este ancho, donde se ignora el indicador 0:
imprimirf '<%.6d>', 1; # imprime "<000001>"
imprimirf '<%+.6d>', 1; # imprime "<+000001>"
imprimirf '<%-10.6d>', 1; # imprime "<000001 >"
imprimirf '<%10.6d>', 1; # imprime "<000001>"
imprimirf '<%010.6d>', 1; # imprime "<000001>"
imprimirf '<%+10.6d>', 1; # imprime "<+000001>"
imprimirf '<%.6x>', 1; # imprime "<000001>"
imprimirf '<%#.6x>', 1; # imprime "<0x000001>"
imprimirf '<%-10.6x>', 1; # imprime "<000001 >"
imprimirf '<%10.6x>', 1; # imprime "<000001>"
imprimirf '<%010.6x>', 1; # imprime "<000001>"
imprimirf '<%#10.6x>', 1; # imprime "<0x000001>"
Para conversiones de cadenas, especificar una precisión trunca la cadena para que se ajuste al
ancho especificado:
printf '<%.5s>', "truncado"; # imprime " "
printf '<%10.5s>', "truncado"; # imprime "<trunc>"
También puede obtener la precisión del siguiente argumento usando ".*":
imprimirf '<%.6x>', 1; # imprime "<000001>"
imprimirf '<%.*x>', 6, 1; # imprime "<000001>"
Si una precisión obtenida mediante "*" es negativa, cuenta como sin precisión
en absoluto.
printf '<%.*s>', 7, "cadena"; # imprime " "
printf '<%.*s>', 3, "cadena"; # imprime " "
printf '<%.*s>', 0, "cadena"; # imprime "<>"
printf '<%.*s>', -1, "cadena"; # imprime " "
imprimirf '<%.*d>', 1, 0; # imprime "<0>"
imprimirf '<%.*d>', 0, 0; # imprime "<>"
imprimirf '<%.*d>', -1, 0; # imprime "<0>"
Actualmente no puede obtener la precisión de un número específico, pero se pretende
que esto será posible en el futuro, por ejemplo usando ".*2$":
imprimirf '<%.*2$x>', 1, 6; # NO VÁLIDO, pero en el futuro se imprimirá
# "<000001>"
tamaño
Para conversiones numéricas, puede especificar el tamaño para interpretar el número como usando
"l", "h", "V", "q", "L" o "ll". Para conversiones de enteros ("duox X bi DU
O"), generalmente se supone que los números son cualquiera que sea el tamaño entero predeterminado en
su plataforma (generalmente 32 o 64 bits), pero puede anular esto para usar en su lugar
uno de los tipos estándar de C, como lo admite el compilador utilizado para compilar Perl:
hh interpreta entero como tipo C "char" o "sin signo
char" en Perl 5.14 o posterior
h interpreta entero como tipo C "corto" o
"corto sin firmar"
j interpreta entero como tipo C "intmax_t" en Perl
5.14 o posterior, y solo con un compilador C99
(no portátil)
interpreto entero como tipo C "largo" o
"largo sin firmar"
q, L o ll interpretan enteros como tipo C "largo largo",
"unsigned long long" o "quad" (típicamente
enteros de 64 bits)
t interprete entero como tipo C "ptrdiff_t" en Perl
5.14 o posterior
z interpreta entero como tipo C "size_t" en Perl 5.14
o después
A partir de la versión 5.14, ninguno de estos genera una excepción si no son compatibles con su
plataforma. Sin embargo, si las advertencias están habilitadas, una advertencia de la advertencia "printf"
la clase se emite en un indicador de conversión no admitido. Si en cambio prefiere un
excepción, haz esto:
usar advertencias FATAL => "printf";
Si desea conocer la dependencia de una versión antes de comenzar a ejecutar el
programa, ponga algo como esto en su parte superior:
usar 5.014; # para modificadores hh/j/t/z/printf
Puede averiguar si su Perl admite quads a través de Config:
usar configuración;
si ($Config{use64bitint} eq "definir"
|| $Config{tamaño largo} >= 8) {
print "¡Buenos quads!\n";
}
Para las conversiones de punto flotante ("efg EFG"), generalmente se supone que los números son
el tamaño de punto flotante predeterminado en su plataforma (doble o doble largo), pero usted
puede forzar "doble largo" con "q", "L" o "ll" si su plataforma los admite.
Puede averiguar si su Perl admite dobles largos a través de Config:
usar configuración;
imprime "dobles largos\n" if $Config{d_longdbl} eq "define";
Puede averiguar si Perl considera que "doble largo" es el valor flotante predeterminado.
tamaño de punto para usar en su plataforma a través de Config:
usar configuración;
if ($Config{uselongdouble} eq "define") {
imprimir "dobles largos por defecto\n";
}
También puede ser que dobles largos y dobles sean lo mismo:
usar configuración;
($Config{doble tamaño} == $Config{longdblsize}) &&
print "los dobles son dobles largos\n";
El especificador de tamaño "V" no tiene efecto para el código Perl, pero es compatible con
compatibilidad con el código XS. Significa "usar el tamaño estándar para un número entero de Perl o
número de coma flotante", que es el predeterminado.
orden de argumentos
Normalmente, sprintf () toma el siguiente argumento no utilizado como el valor a formatear para cada
especificación de formato. Si la especificación de formato usa "*" para requerir información adicional
argumentos, estos se consumen de la lista de argumentos en el orden en que aparecen en
la especificación de formato antes el valor a formatear. Donde hay un argumento
especificado por un índice explícito, esto no afecta el orden normal para el
argumentos, incluso cuando el índice explícitamente especificado habría sido el siguiente
argumento.
De modo que:
printf "<%*.*s>", $a, $b, $c;
usa $a para el ancho, $b para la precisión y $c como el valor para formatear; mientras:
printf '<%*1$.*s>', $a, $b;
usaría $a para el ancho y la precisión, y $b como el valor para formatear.
Aquí hay algunos ejemplos más; tenga en cuenta que al usar un índice explícito, el "$"
puede necesitar escapar:
printf "%2\$d %d\n", 12, 34; # imprimirá "34 12\n"
printf "%2\$d %d %d\n", 12, 34; # imprimirá "34 12 34\n"
printf "%3\$d %d %d\n", 12, 34, 56; # imprimirá "56 12 34\n"
printf "%2\$*3\$d %d\n", 12, 34, 3; # imprimirá " 34 12\n"
Si "use locale" (incluido "use locale 'not_characters'") está en vigor y
POSIX :: setlocale () ha sido llamado, el carácter utilizado para el separador decimal en
los números de coma flotante formateados se ven afectados por la configuración regional "LC_NUMERIC". Ver
perllocale y POSIX.
EXPR sqrt
sqrt
Devuelve la raíz cuadrada positiva de EXPR. Si se omite EXPR, utiliza $_. Funciona solo para
operandos no negativos a menos que haya cargado el módulo "Math::Complex".
usar Matemáticas::Complejo;
imprimir sqrt(-4); # imprime 2i
srand EXPR
sardina
Establece y devuelve la semilla de número aleatorio para el operador "rand".
El objetivo de la función es "sembrar" la función "rand" para que "rand" pueda producir
una secuencia diferente cada vez que ejecute su programa. Cuando se llama con un parámetro,
"srand" usa eso para la semilla; de lo contrario, elige (semi-)aleatoriamente una semilla. En
en cualquier caso, a partir de Perl 5.14, devuelve la semilla. Para señalar que su código
funcionará only en Perls de una cosecha reciente:
usar 5.014; # entonces srand devuelve la semilla
Si "srand()" no se llama explícitamente, se llama implícitamente sin un parámetro en
el primer uso del operador "rand". Sin embargo, hay algunas situaciones en las que
es probable que los programas quieran llamar "srand". Uno es para generar predecible
resultados, generalmente para pruebas o depuración. Ahí, usas "srand($seed)", con el
mismo $ semilla cada vez. Otro caso es que puede querer llamar a "srand()" después de un
"fork ()" para evitar que los procesos secundarios compartan el mismo valor semilla que el padre (y
en consecuencia, entre sí).
Do no llamar a "srand()" (es decir, sin argumento) más de una vez por proceso. Él
El estado interno del generador de números aleatorios debe contener más entropía de la que se puede
proporcionado por cualquier semilla, por lo que llamar a "srand ()" nuevamente en realidad pierde aleatoriedad.
La mayoría de las implementaciones de "srand" toman un número entero y truncarán silenciosamente el decimal
números. Esto significa "sardina(42)" generalmente producirá los mismos resultados que
"sand (42.1)". Para estar seguro, siempre pase "srand" un número entero.
Un uso típico de la semilla devuelta es para un programa de prueba que tiene demasiadas
combinaciones para probar exhaustivamente en el tiempo disponible para cada ejecución. Puede
pruebe un subconjunto aleatorio cada vez, y si hay una falla, registre la semilla utilizada para
que se ejecuta para que luego se pueda utilizar para reproducir los mismos resultados.
"rand()" is no criptográficamente asegurar. You should no confiar on it in seguridad-
sensible situaciones En el momento de escribir este artículo, una serie de módulos CPAN de terceros ofrecen
generadores de números aleatorios destinados por sus autores a ser criptográficamente seguros,
incluyendo: Data::Entropy, Crypt::Random, Math::Random::Secure y Math::TrulyRandom.
identificador de archivo stat
EXPR estadística
estadística DIRHANDLE
stat
Devuelve una lista de 13 elementos que proporciona la información de estado de un archivo, ya sea el archivo abierto
a través de FILEHANDLE o DIRHANDLE, o nombrado por EXPR. Si se omite EXPR, indica $_ (no
"_"!). Devuelve la lista vacía si falla "stat". Normalmente se utiliza de la siguiente manera:
($desarrollo,$ino,$modo,$nlink,$uid,$gid,$rdev,$tamaño,
$atime,$mtime,$ctime,$blksize,$bloques)
= stat($nombrearchivo);
No todos los campos son compatibles con todos los tipos de sistemas de archivos. Aquí están los significados de los
campos:
0 número de dispositivo de desarrollo del sistema de archivos
1 ino número de inodo
Modo de archivo de 2 modos (tipo y permisos)
3 nlink número de enlaces (fijos) al archivo
4 ID de usuario numérico uid del propietario del archivo
5 ID de grupo numérico gid del propietario del archivo
6 rdev el identificador del dispositivo (solo archivos especiales)
7 tamaño tamaño total del archivo, en bytes
8 atime tiempo de último acceso en segundos desde la época
9 mtime tiempo de última modificación en segundos desde la época
10 ctime tiempo de cambio de inodo en segundos desde la época (*)
11 blksize tamaño de E/S preferido en bytes para interactuar con el
archivo (puede variar de un archivo a otro)
12 bloques número real de bloques específicos del sistema asignados
en disco (a menudo, pero no siempre, 512 bytes cada uno)
(La época fue a las 00:00 del 1 de enero de 1970 GMT).
(*) No todos los campos son compatibles con todos los tipos de sistemas de archivos. En particular, el campo ctime es
no portátil. En particular, no puedes esperar que sea un "tiempo de creación"; ver "Archivos
and Filesystems" en perlport para más detalles.
Si se pasa "stat" al identificador de archivo especial que consiste en un subrayado, no se
hecho, pero el contenido actual de la estructura stat de la última "stat", "lstat" o
se devuelven filetest. Ejemplo:
if (-x $archivo && (($d) = estadística(_)) && $d < 0) {
print "$archivo es un archivo NFS ejecutable\n";
}
(Esto funciona solo en máquinas para las que el número de dispositivo es negativo en NFS).
Debido a que el modo contiene tanto el tipo de archivo como sus permisos, debe enmascarar
la parte del tipo de archivo y (s)printf usando un "%o" si desea ver el verdadero
permisos
$modo = (stat($nombre de archivo))[2];
printf "Los permisos son %04o\n", $modo & 07777;
En contexto escalar, "stat" devuelve un valor booleano que indica éxito o fracaso y,
si tiene éxito, establece la información asociada con el identificador de archivo especial "_".
El módulo File :: stat proporciona un conveniente mecanismo de acceso por nombre:
use File :: stat;
$sb = stat($nombrearchivo);
printf "El archivo es %s, el tamaño es %s, perm %04o, mtime %s\n",
$nombre de archivo, $sb->tamaño, $sb->modo & 07777,
escalar localtime $sb->mtime;
Puede importar constantes de modo simbólico ("S_IF*") y funciones ("S_IS*") desde el
módulo fcntl:
usa Fcntl ':modo';
$modo = (stat($nombre de archivo))[2];
$usuario_rwx = ($modo & S_IRWXU) >> 6;
$group_read = ($modo & S_IRGRP) >> 3;
$otro_ejecutar = $modo & S_IXOTH;
printf "Los permisos son %04o\n", S_IMODE($modo), "\n";
$is_setuid = $modo & S_ISUID;
$es_directorio = S_ISDIR($modo);
Puede escribir los dos últimos utilizando los operadores "-u" y "-d". Comúnmente disponible
Las constantes "S_IF*" son:
# Permisos: leer, escribir, ejecutar, para usuario, grupo, otros.
S_IRWXU S_IRUSR S_IWUSR S_IXUSR
S_IRWXG S_IRGRP S_IWGRP S_IXGRP
S_IRWXO S_IROTH S_IWOTH S_IXOTH
# Setuid/Setgid/Stickiness/SaveText.
# Tenga en cuenta que el significado exacto de estos depende del sistema.
S_ISUID S_ISGID S_ISVTX S_ISTXT
# Tipos de archivo. No todos están necesariamente disponibles en
# tu sistema.
S_IFREG S_IFDIR S_IFLNK S_IFBLK S_IFCHR
S_IFIFO S_IFSOCK S_IFWHT S_ENFMT
# Los siguientes son alias de compatibilidad para S_IRUSR,
# S_IWUSR y S_IXUSR.
S_ILEER S_IESCRIBIR S_IEXEC
y las funciones "S_IF*" son
S_IMODE($mode) la parte de $mode que contiene el permiso
bits y los bits setuid/setgid/sticky
S_IFMT($modo) la parte de $modo que contiene el tipo de archivo
que se puede bitear con (por ejemplo)
S_IFREG o con las siguientes funciones
# Los operadores -f, -d, -l, -b, -c, -p y -S.
S_ISREG($modo) S_ISDIR($modo) S_ISLNK($modo)
S_ISBLK($modo) S_ISCHR($modo) S_ISFIFO($modo) S_ISSOCK($modo)
# Sin contrapartida directa del operador -X, pero para el primero
# el operador -g suele ser equivalente. La ENFMT significa
# registro de cumplimiento de bandadas, una función que depende de la plataforma.
S_ISENFMT($modo) S_ISWHT($modo)
Ver a su nativo chmod(2) y stat(2) documentación para más detalles sobre el "S_*"
constantes Para obtener información de estado para un enlace simbólico en lugar del archivo de destino detrás
el enlace, utilice la función "lstat".
Problemas de portabilidad: "stat" en perlport.
estado VARLIST
estado TIPO VARLIST
estado VARLIST: ATTRS
estado TIPO VARLIST: ATTRS
"estado" declara una variable de ámbito léxico, al igual que "mi". Sin embargo, esos
Las variables nunca se reinicializarán, a diferencia de las variables léxicas que se
se reinicializa cada vez que se ingresa a su bloque adjunto. Ver "Privado persistente
Variables" en perlsub para más detalles.
Si se enumera más de una variable, la lista debe colocarse entre paréntesis. Con un
lista entre paréntesis, "undef" se puede utilizar como marcador de posición ficticio. Sin embargo, desde
la inicialización de las variables de estado en el contexto de la lista no es posible actualmente, esto sería
no sirven para nada.
Las variables de "estado" están habilitadas solo cuando el pragma "usar función de "estado"" está en vigor,
a menos que la palabra clave esté escrita como "CORE::state". Véase también función. Alternativamente,
incluir un "use v5.10" o posterior al alcance actual.
estudio ESCALAR
Estudio
Puede tomar tiempo adicional para estudiar ESCALAR ($_ si no se especifica) antes de hacer muchas
el patrón coincide con la cadena antes de que se modifique a continuación. Esto puede o no salvar
tiempo, según la naturaleza y el número de patrones que esté buscando y el
distribución de frecuencias de caracteres en la cadena a buscar; probablemente quieras
para comparar los tiempos de ejecución con y sin él para ver cuál es más rápido. Esos bucles que
buscar muchas cadenas constantes cortas (incluidas las partes constantes de cadenas más complejas)
patrones) se beneficiarán más.
Tenga en cuenta que desde la versión 5.16 de Perl, esta función no ha funcionado, pero esto podría
cambio en una versión futura.
(La forma en que "estudio" funciona es la siguiente: una lista enlazada de cada carácter en la cadena a ser
se realiza la búsqueda, por lo que sabemos, por ejemplo, dónde están todos los caracteres 'k'. Desde
cada cadena de búsqueda, se selecciona el carácter más raro, en función de alguna frecuencia estática
tablas construidas a partir de algunos programas en C y texto en inglés. Sólo aquellos lugares que
contienen este carácter "más raro" se examinan.)
Por ejemplo, aquí hay un bucle que inserta entradas productoras de índice antes de cualquier línea
que contiene un cierto patrón:
while (<>) {
estudiar;
imprime ".IX foo\n" if /\bfoo\b/;
imprime ".IX barra\n" si /\bbar\b/;
imprime ".IX blurfl\n" if /\bblurfl\b/;
#...
impresión;
}
Al buscar "/\bfoo\b/", solo se buscarán las ubicaciones en $_ que contengan "f".
porque "f" es más raro que "o". En general, esta es una gran victoria excepto en casos patológicos.
casos. La única pregunta es si le ahorra más tiempo del que tomó construir el
lista enlazada en primer lugar.
Tenga en cuenta que si tiene que buscar cadenas que no conoce hasta el tiempo de ejecución, puede
construir un bucle completo como una cadena y "evaluar" eso para evitar volver a compilar todos sus
patrones todo el tiempo. Junto con la indefinición de $/ para ingresar archivos completos como uno solo
registro, esto puede ser bastante rápido, a menudo más rápido que los programas especializados como fgrep(1).
Lo siguiente escanea una lista de archivos (@files) en busca de una lista de palabras (@words), e imprime
a cabo los nombres de los archivos que contienen una coincidencia:
$buscar = 'while (<>) { estudio;';
foreach $palabra (@palabras) {
$buscar .= "++\$visto{\$ARGV} if /\\b$palabra\\b/;\n";
}
$buscar .= "}";
@ARGV = @archivos;
indefinido $/;
eval $buscar; # esto grita
$/ = "\n"; # volver a poner el delimitador de entrada normal
foreach $archivo (ordenar claves(%visto)) {
imprimir $archivo, "\n";
}
BLOQUE DE NOMBRE secundario
sub NOMBRE (PROTO) BLOQUE
sub NOMBRE : BLOQUE ATTRS
sub NOMBRE (PROTO): BLOQUE ATTRS
Esta es una definición de subrutina, no una función real. per se. Sin un BLOQUE es solo
una declaración anticipada. Sin un NOMBRE, es una declaración de función anónima, por lo que
devuelve un valor: la referencia CÓDIGO del cierre recién creado.
Ver perlsub y perlref para detalles sobre subrutinas y referencias; ver atributos
y Attribute::Handlers para obtener más información sobre los atributos.
__SUB__
Un token especial que devuelve una referencia a la subrutina actual, o "undef" fuera
de una subrutina.
El comportamiento de "__SUB__" dentro de un bloque de código regex (como "/(?{...})/") está sujeto
cambiar.
Este token solo está disponible en "usar v5.16" o la función "current_sub". Ver
.
substr EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO
substr EXPR,DESPLAZAMIENTO,LONGITUD
substr EXPR,DESPLAZAMIENTO
Extrae una subcadena de EXPR y la devuelve. El primer carácter está en el desplazamiento cero.
Si OFFSET es negativo, comienza tan atrás desde el final de la cadena. Si la LONGITUD es
omitido, devuelve todo hasta el final de la cadena. Si LONGITUD es negativo,
deja esa cantidad de caracteres al final de la cadena.
my $s = "El gato negro subió al árbol verde";
mi $color = substr $s, 4, 5; # negro
mi $medio = substr $s, 4, -11; #gato negro subió al
mi $fin = substr $s, 14; # subí al árbol verde
mi $cola = substr $s, -4; # árbol
mi $z = substr $s, -4, 2; #tr
Puede utilizar el substr () funcionar como un lvalue, en cuyo caso EXPR debe ser en sí mismo un
lvalor. Si asigna algo más corto que LENGTH, la cadena se reducirá, y si
asigna algo más largo que LENGTH, la cadena crecerá para acomodarlo. Para
mantenga la cadena de la misma longitud, es posible que deba rellenar o cortar su valor usando
"sprintf".
Si OFFSET y LENGTH especifican una subcadena que está parcialmente fuera de la cadena, solo el
se devuelve la parte dentro de la cadena. Si la subcadena está más allá de cualquiera de los extremos de la
cuerda, substr () devuelve el valor indefinido y produce una advertencia. Cuando se usa como un
lvalue, especificar una subcadena que está completamente fuera de la cadena genera un
excepción. Aquí hay un ejemplo que muestra el comportamiento de los casos límite:
mi $nombre = 'fred';
substr($nombre, 4) = 'dy'; # $nombre ahora es 'freddy'
my $null = substr $nombre, 6, 2; # devuelve "" (sin advertencia)
mi $ups = substr $nombre, 7; # devuelve undef, con advertencia
substr($nombre, 7) = 'brecha'; # genera una excepción
Una alternativa al uso substr () como un lvalue es especificar la cadena de reemplazo como
el 4to argumento. Esto le permite reemplazar partes del EXPR y devolver lo que fue
allí antes en una sola operación, al igual que puede hacerlo con empalme().
my $s = "El gato negro subió al árbol verde";
my $z = substr $s, 14, 7, "saltó desde"; # trepado
# $s ahora es "El gato negro saltó del árbol verde"
Tenga en cuenta que el lvalue devuelto por la versión de tres argumentos de substr () actúa como un
'bala mágica'; cada vez que se le asigna, recuerda qué parte del original
la cadena se está modificando; por ejemplo:
$x = '1234';
para (substr($x,1,2)) {
$_ = 'un'; imprime $x,"\n"; # imprime 1a4
$_ = 'xyz'; imprime $x,"\n"; # imprime 1xyz4
$x = '56789';
$_ = 'pq'; imprime $x,"\n"; # imprime 5pq9
}
Con compensaciones negativas, recuerda su posición desde el final de la cadena cuando el
la cadena de destino se modifica:
$x = '1234';
para (sustancia ($x, -3, 2)) {
$_ = 'a'; imprime $x,"\n"; # imprime 1a4, como arriba
$x = 'abcdefg';
imprimir $_,"\n"; # impresiones f
}
Antes de la versión 5.10 de Perl, el resultado de usar un lvalue varias veces era
no especificado Antes de 5.16, no se especificaba el resultado con compensaciones negativas.
enlace simbólico ARCHIVO VIEJO, ARCHIVO NUEVO
Crea un nuevo nombre de archivo vinculado simbólicamente al antiguo nombre de archivo. Devuelve 1 para
éxito, 0 en caso contrario. En los sistemas que no admiten enlaces simbólicos, genera un
excepción. Para verificar eso, use eval:
$enlace simbólico_existe = eval { enlace simbólico("",""); 1 };
Problemas de portabilidad: "enlace simbólico" en perlport.
syscall NÚMERO, LISTA
Llama a la llamada del sistema especificada como el primer elemento de la lista, pasando el
elementos restantes como argumentos para la llamada al sistema. Si no se implementa, plantea un
excepción. Los argumentos se interpretan de la siguiente manera: si un argumento dado es numérico,
el argumento se pasa como un int. Si no, se pasa el puntero al valor de cadena.
Usted es responsable de asegurarse de que una cadena se extienda previamente lo suficiente para recibir cualquier
resultado que podría escribirse en una cadena. No puede usar un literal de cadena (u otro
cadena de solo lectura) como un argumento para "syscall" porque Perl tiene que asumir que cualquier
podría escribirse un puntero de cadena. Si sus argumentos enteros no son literales
y nunca se han interpretado en un contexto numérico, es posible que deba agregarles 0 para
forzarlos a parecer números. Esto emula la función "syswrite" (o viceversa).
viceversa):
requiere 'syscall.ph'; # puede necesitar ejecutar h2ph
$s = "hola\n";
syscall(&SYS_write, fileno(STDOUT), $s, longitud $s);
Tenga en cuenta que Perl admite el paso de hasta 14 argumentos a su llamada al sistema, lo que en
la práctica debería (generalmente) ser suficiente.
Syscall devuelve cualquier valor devuelto por la llamada del sistema que llama. Si el sistema
la llamada falla, "syscall" devuelve "-1" y establece $! (errno). Tenga en cuenta que algunas llamadas al sistema
can devolver legítimamente "-1". La forma correcta de manejar este tipo de llamadas es asignar "$!=0"
antes de la llamada, luego verifique el valor de $! si "syscall" devuelve "-1".
Hay un problema con "syscall(&SYS_pipe)": devuelve el número de archivo de la lectura
final de la canalización que crea, pero no hay manera de recuperar el número de archivo de la
Otro final. Puede evitar este problema utilizando "tubería" en su lugar.
Problemas de portabilidad: "syscall" en perlport.
sysopen IDENTIFICADOR DE ARCHIVO, NOMBRE DE ARCHIVO, MODO
sysopen IDENTIFICADOR DE ARCHIVO, NOMBRE DE ARCHIVO, MODO, PERMISOS
Abre el archivo cuyo nombre de archivo viene dado por FILENAME y lo asocia con FILEHANDLE.
Si FILEHANDLE es una expresión, su valor se usa como el identificador de archivo real deseado; un
escalar indefinido será convenientemente autovivificado. Esta función llama al subyacente
sistemas operativos abierto(2) funciona con los parámetros FILENAME, MODE y PERMS.
Devuelve verdadero en caso de éxito y "undef" en caso contrario.
Los valores posibles y los bits de bandera del parámetro MODE dependen del sistema; ellos son
disponible a través del módulo estándar "Fcntl". Consulte la documentación de su funcionamiento
sistema abierto(2) llamada al sistema para ver qué valores y bits de bandera están disponibles. Puedes
combine varias banderas usando el operador "|".
Algunos de los valores más comunes son "O_RDONLY" para abrir el archivo en modo de solo lectura,
"O_WRONLY" para abrir el archivo en modo de solo escritura y "O_RDWR" para abrir el archivo
en modo lectura-escritura.
Por razones históricas, algunos valores funcionan en casi todos los sistemas compatibles con Perl: 0
significa solo lectura, 1 significa solo escritura y 2 significa lectura/escritura. Sabemos que estos
los valores hacen no trabajar bajo OS/390 y en Macintosh; probablemente no quieras usar
ellos en código nuevo.
Si el archivo nombrado por FILENAME no existe y la llamada "abrir" lo crea (típicamente
porque MODE incluye el indicador "O_CREAT"), entonces el valor de PERMS especifica el
permisos del archivo recién creado. Si omite el argumento PERMS para "sysopen",
Perl usa el valor octal 0666. Estos valores de permiso deben estar en octal y son
modificado por el "umask" actual de su proceso.
En muchos sistemas, el indicador "O_EXCL" está disponible para abrir archivos en modo exclusivo.
Es no bloqueo: exclusividad significa aquí que si el archivo ya existe,
sysopen () falla "O_EXCL" puede no funcionar en sistemas de archivos de red y no tiene ningún efecto
a menos que también se establezca el indicador "O_CREAT". Establecer "O_CREAT|O_EXCL" evita que el archivo
de ser abierto si se trata de un enlace simbólico. No protege contra simbolismo.
enlaces en la ruta del archivo.
A veces, es posible que desee truncar un archivo ya existente. Esto se puede hacer usando
la bandera "O_TRUNC". El comportamiento de "O_TRUNC" con "O_RDONLY" no está definido.
Rara vez, si alguna vez, debe usar 0644 como argumento para "sysopen", porque eso le quita
la opción del usuario de tener un umask más permisivo. Mejor omitirlo. Ver el
perlfunc(1) entrada en "umask" para más información sobre esto.
Tenga en cuenta que "sysopen" depende de la fdopen () Función de biblioteca C. En muchos sistemas Unix,
fdopen () se sabe que falla cuando los descriptores de archivos exceden un cierto valor, generalmente 255.
Si necesita más descriptores de archivo que eso, considere usar el POSIX::abrir()
función.
Consulte perlopentut para obtener una explicación más amable y gentil sobre la apertura de archivos.
Problemas de portabilidad: "sysopen" en perlport.
sysread IDENTIFICADOR DE ARCHIVO, ESCALAR, LONGITUD, DESPLAZAMIENTO
sysread IDENTIFICADOR DE ARCHIVO, ESCALAR, LONGITUD
Intenta leer LONGITUD bytes de datos en la variable ESCALAR del especificado
IDENTIFICADOR DE ARCHIVO, usando el read(2). Omite la E/S almacenada en búfer, por lo que mezclar esto con otros
tipos de lecturas, "imprimir", "escribir", "buscar", "decir" o "eof" pueden causar confusión porque
las capas perlio o stdio generalmente almacenan datos en búfer. Devuelve el número de bytes realmente
read, 0 al final del archivo o undef si hubo un error (en este último caso $! también es
colocar). ESCALAR se ampliará o reducirá de modo que el último byte que se lea sea el último
byte del escalar después de la lectura.
Se puede especificar un DESPLAZAMIENTO para colocar los datos leídos en algún lugar de la cadena diferente
que el principio. Un DESPLAZAMIENTO negativo especifica la ubicación en esa cantidad de caracteres
contando hacia atrás desde el final de la cuerda. Un OFFSET positivo mayor que el
la longitud de SCALAR da como resultado que la cadena se rellene al tamaño requerido con "\0"
bytes antes de que se agregue el resultado de la lectura.
No hay sistema de () función, lo cual está bien, ya que eof () no funciona bien en el dispositivo
archivos (como ttys) de todos modos. Usar sysread () y verifique un valor de retorno para 0 para decidir
si has terminado.
Tenga en cuenta que si el identificador de archivo se ha marcado como ":utf8", se leen los caracteres Unicode
en lugar de bytes (la LONGITUD, el DESPLAZAMIENTO y el valor de retorno de sysread () están en Unicode
caracteres). La capa ":encoding(...)" introduce implícitamente la capa ":utf8". Ver
"modo bin", "abierto" y el pragma "abierto", abierto.
sysseek IDENTIFICADOR DE ARCHIVO, POSICIÓN, DONDE
Establece la posición del sistema de FILEHANDLE en bytes usando buscar(2). FILEHANDLE puede ser un
expresión cuyo valor da el nombre del identificador de archivo. Los valores para DONDE son 0
para establecer la nueva posición en POSICIÓN; 1 para configurarlo en la posición actual más
POSICIÓN; y 2 para establecerlo en EOF más POSICIÓN, normalmente negativo.
Nota la in bytes: incluso si el identificador de archivo se ha configurado para operar con caracteres (por
ejemplo usando la capa de E/S ":encoding(utf8)"), contar() devolverá compensaciones de bytes,
no compensaciones de caracteres (porque implementar eso haría que sysseek () inaceptablemente
lento).
sysseek () omite la E/S almacenada en búfer normal, por lo que se mezcla con lecturas que no sean "sysread"
(por ejemplo, "<>" o leer()) "imprimir", "escribir", "buscar", "decir" o "eof" pueden causar
Confusión.
Para DÓNDE, también puede usar las constantes "SEEK_SET", "SEEK_CUR" y "SEEK_END".
(inicio del archivo, posición actual, final del archivo) desde el módulo Fcntl. Uso de
las constantes también es más portátil que confiar en 0, 1 y 2. Por ejemplo, para
definir una función "systell":
use Fcntl 'SEEK_CUR';
subsistema { sysseek($_[0], 0, SEEK_CUR) }
Devuelve la nueva posición o el valor indefinido en caso de error. Una posición de cero es
devuelto como la cadena "0 pero verdadero"; por lo tanto, "sysseek" devuelve verdadero en caso de éxito y falso
en caso de falla, aún puede determinar fácilmente la nueva posición.
LISTA del sistema
LISTA DE PROGRAMAS del sistema
Hace exactamente lo mismo que "exec LIST", excepto que primero se hace una bifurcación y el
El proceso principal espera a que el proceso secundario finalice. Tenga en cuenta que el procesamiento de argumentos
varía según el número de argumentos. Si hay más de un argumento en
LISTA, o si LISTA es una matriz con más de un valor, inicia el programa dado por el
primer elemento de la lista con argumentos dados por el resto de la lista. Si hay
solo un argumento escalar, el argumento se verifica en busca de metacaracteres de shell, y si
hay alguno, el argumento completo se pasa al shell de comandos del sistema para su análisis
(este es "/ Bin / sh -c" en plataformas Unix, pero varía en otras plataformas). Si hay
no hay metacaracteres de shell en el argumento, se divide en palabras y se pasa directamente a
"execvp", que es más eficiente. En Windows, solo la sintaxis "LISTA DE PROGRAMAS del sistema"
evitará de manera confiable el uso del caparazón; "LISTA del sistema", incluso con más de un elemento,
retrocederá al caparazón si falla el primer engendro.
Perl intentará vaciar todos los archivos abiertos para la salida antes de cualquier operación que pueda
hacer una bifurcación, pero es posible que esto no sea compatible con algunas plataformas (ver perlport). Ser - estar
seguro, es posible que deba configurar $| ($AUTOFLUSH en inglés) o llamar al método "autoflush()"
de "IO::Handle" en cualquier identificador abierto.
El valor devuelto es el estado de salida del programa tal como lo devuelve la llamada "esperar". Para
obtenga el valor de salida real, desplácese a la derecha en ocho (ver más abajo). Véase también "ejecutivo". Este
is no lo que desea usar para capturar la salida de un comando; para eso deberías
use simplemente acentos graves o "qx//", como se describe en "`STRING`" en perlop. Valor de retorno de
-1 indica un fallo al iniciar el programa o un error del esperar(2) llamada al sistema
(inspeccione $! por la razón).
Si desea hacer que el "sistema" (y muchas otras partes de Perl) mueran por error, eche un vistazo
en el autodie pragma.
Al igual que "ejec", "sistema" le permite mentirle a un programa sobre su nombre si usa el
sintaxis "LISTA DE PROGRAMAS del sistema". De nuevo, vea "ejecutivo".
Dado que "SIGINT" y "SIGQUIT" se ignoran durante la ejecución de "system", si
espera que su programa finalice al recibir estas señales, deberá organizar
hacerlo usted mismo en función del valor de retorno.
@args = ("comando", "arg1", "arg2");
sistema(@argumentos) == 0
o morir "sistema @args falló: $?"
Si desea inspeccionar manualmente la falla del "sistema", puede verificar todas las posibles
modos de falla al inspeccionar $? Me gusta esto:
si ($? == -1) {
imprimir "no se pudo ejecutar: $!\n";
}
elsif ($? & 127) {
printf "niño murió con la señal %d, %s coredump\n",
($? y 127), ($? y 128) ? 'con sin';
}
else {
printf "hijo salió con valor %d\n", $? >> 8;
}
Alternativamente, puede inspeccionar el valor de "${^CHILD_ERROR_NATIVE}" con "W*()"
llamadas desde el módulo POSIX.
Cuando los argumentos del "sistema" son ejecutados indirectamente por el shell, los resultados y el retorno
los códigos están sujetos a sus peculiaridades. Consulte "`STRING`" en perlop y "exec" para obtener más información.
Dado que el "sistema" hace una "bifurcación" y "espera", puede afectar a un controlador "SIGCHLD". Ver
perlipc para más detalles.
Problemas de portabilidad: "sistema" en perlport.
syswrite IDENTIFICADOR DE ARCHIVO, ESCALAR, LONGITUD, DESPLAZAMIENTO
syswrite IDENTIFICADOR DE ARCHIVO, ESCALAR, LONGITUD
syswrite IDENTIFICADOR DE ARCHIVO, ESCALAR
Intenta escribir LENGTH bytes de datos de la variable ESCALAR en el especificado
IDENTIFICADOR DE ARCHIVO, utilizando escribir(2). Si no se especifica LONGITUD, escribe ESCALAR completo. Eso
omite la E/S almacenada en búfer, por lo que se mezcla con lecturas (que no sean sysread()), "imprimir",
"escribir", "buscar", "decir" o "eof" pueden causar confusión porque perlio y stdio
las capas suelen almacenar datos en búfer. Devuelve el número de bytes realmente escritos, o "undef"
si hubo un error (en este caso también se establece la variable errno $!). Si la LONGITUD
es mayor que los datos disponibles en el ESCALAR después de la COMPENSACIÓN, solo la cantidad de datos
según esté disponible se escribirá.
Se puede especificar un OFFSET para escribir los datos de alguna parte de la cadena que no sea
el principio. Un OFFSET negativo especifica que se escriben muchos caracteres contando
hacia atrás desde el final de la cuerda. Si ESCALAR es de longitud cero, solo puede usar
un DESPLAZAMIENTO de 0.
ADVERTENCIA: Si el identificador de archivo está marcado como ":utf8", los caracteres Unicode codificados en UTF-8 son
escrito en lugar de bytes, y la LONGITUD, el DESPLAZAMIENTO y el valor de retorno de syswrite () están
en caracteres (Unicode con codificación UTF8). La capa ":encoding(...)" implícitamente
introduce la capa ":utf8". Alternativamente, si el mango no está marcado con un
codificación pero intenta escribir caracteres con puntos de código de más de 255, genera un
excepción. Consulte "modo bin", "abierto" y el pragma "abierto", abierto.
decir ARCHIVO
tell
Devuelve la posición actual in bytes para FILEHANDLE, o -1 en caso de error. IDENTIFICADOR DE ARCHIVO puede
ser una expresión cuyo valor proporcione el nombre del identificador de archivo real. Si IDENTIFICADOR DE ARCHIVO
se omite, se supone que el archivo se leyó por última vez.
Nota la in bytes: incluso si el identificador de archivo se ha configurado para operar con caracteres (por
ejemplo usando la capa abierta ":encoding(utf8)"), contar() devolverá compensaciones de bytes,
no compensaciones de caracteres (porque eso representaría buscar() y contar() bastante lento).
El valor de retorno de contar() para los flujos estándar como STDIN depende de la
sistema operativo: puede devolver -1 o algo más. contar() en tuberías, fifos y
sockets normalmente devuelve -1.
No hay función "systell". Use "sysseek (FH, 0, 1)" para eso.
No utilice contar() (u otras operaciones de E/S almacenadas en búfer) en un identificador de archivo que ha sido
manipulado por sysread (), syswrite ()o sysseek (). Esas funciones ignoran la
almacenamiento en búfer, mientras contar() no.
Telldir DIRHANDLE
Devuelve la posición actual de las rutinas "readdir" en DIRHANDLE. El valor puede ser
dado a "seekdir" para acceder a una ubicación particular en un directorio. "telldir" tiene el
las mismas advertencias sobre la posible compactación de directorios que la biblioteca del sistema correspondiente
rutina.
empate VARIABLE, CLASSNAME, LIST
Esta función vincula una variable a una clase de paquete que proporcionará la implementación
para la variable. VARIABLE es el nombre de la variable a encantar. NOMBRE DE LA CLASE es
el nombre de una clase que implementa objetos del tipo correcto. Cualquier argumento adicional
se pasan al método constructor apropiado de la clase (que significa "TIESCALAR",
"TIEHANDLE", "TIEARRAY" o "TIEHASH"). Por lo general, estos son argumentos como podría
ser pasado a la función "dbm_open()" de C. El objeto devuelto por el constructor
también es devuelto por la función "empate", que sería útil si desea acceder
otros métodos en CLASSNAME.
Tenga en cuenta que funciones como "claves" y "valores" pueden devolver listas enormes cuando se utilizan en
objetos grandes, como archivos DBM. Es posible que prefiera usar la función "cada" para iterar
sobre tal. Ejemplo:
# imprimir compensaciones de archivos de historial
utilizar NDBM_File;
empate (% HIST, 'NDBM_File', '/ usr / lib / news / history', 1, 0);
while (($ key, $ val) = each% HIST) {
imprimir $ clave, '=', desempaquetar ('L', $ val), "\ n";
}
desatar (% HIST);
Una clase que implemente un hash debe tener los siguientes métodos:
Nombre de clase TIEHASH, LISTA
BUSCA esto, clave
ALMACENAR esto, clave, valor
BORRAR esto, clave
BORRAR esto
EXISTE esto, clave
PRIMERA CLAVE esto
NEXTKEY esta, última tecla
ESCALAR esto
DESTRUYE esto
DESATAR esto
Una clase que implemente una matriz ordinaria debe tener los siguientes métodos:
TIEARRAY nombre de clase, LIST
BUSCA esto, clave
ALMACENAR esto, clave, valor
FETCHSIZE esto
ALMACENAR esto, contar
BORRAR esto
PRESIONE esto, LISTA
POP esto
CAMBIAR esto
DESHIFT esto, LISTA
EMPALME esto, desplazamiento, longitud, LISTA
EXTENDER esto, contar
BORRAR esto, clave
EXISTE esto, clave
DESTRUYE esto
DESATAR esto
Una clase que implemente un identificador de archivo debe tener los siguientes métodos:
Nombre de clase TIEHANDLE, LIST
LEA esto, escalar, longitud, desplazamiento
LEER ESTO
CONSIGUE esto
ESCRIBE esto, escalar, longitud, desplazamiento
IMPRIMA esto, LISTA
IMPRIMIR esto, formato, LISTA
BINMODE esto
EOF esto
ARCHIVO NO esto
BUSCA esta, posición, de donde
CUENTA esto
ABRIR esto, modo, LISTA
Cierra esto
DESTRUYE esto
DESATAR esto
Una clase que implemente un escalar debe tener los siguientes métodos:
TIESCALAR nombre de clase, LISTA
BUSCA esto,
ALMACENAR esto, valor
DESTRUYE esto
DESATAR esto
No es necesario implementar todos los métodos indicados anteriormente. Ver perltie, Corbata::Hash,
Tie::Array, Tie::Scalar y Tie::Handle.
A diferencia de "dbmopen", la función "empatar" no "usará" ni "requerirá" un módulo para usted; usted
necesita hacer eso explícitamente usted mismo. Ver DB_File o el Config módulo para interesante
implementaciones de "empate".
Para más detalles ver perltie, "VARIABLE ligada".
atado VARIABLE
Devuelve una referencia al objeto subyacente VARIABLE (el mismo valor que fue
devuelto originalmente por la llamada "empate" que vinculaba la variable a un paquete). Devuelve
el valor indefinido si VARIABLE no está vinculado a un paquete.
time
Devuelve el número de segundos no bisiestos desde cualquier momento que el sistema considere
la época, apto para alimentar a "gmtime" y "localtime". En la mayoría de los sistemas el
la época es 00:00:00 UTC, 1 de enero de 1970; una excepción destacada es Mac OS Classic
que usa 00:00:00, 1 de enero de 1904 en la zona horaria local actual para su época.
Para medir el tiempo con una granularidad mejor que un segundo, use el módulo Time::HiRes
desde Perl 5.8 en adelante (o desde CPAN antes), o, si tiene obtener la hora del día(2), tu
puede ser capaz de utilizar la interfaz "syscall" de Perl. Ver perlfaq8 para más detalles.
Para el procesamiento de fecha y hora, consulte los muchos módulos relacionados en CPAN. Para
Representación completa de fecha y hora mira el módulo DateTime.
veces
Devuelve una lista de cuatro elementos que proporciona al usuario y al sistema los tiempos en segundos para este
proceso y cualquier hijo salido de este proceso.
($usuario,$sistema,$usuario,$csistema) = veces;
En contexto escalar, "times" devuelve $usuario.
Los tiempos de los hijos solo se incluyen para los hijos despedidos.
Problemas de portabilidad: "tiempos" en perlport.
tr ///
El operador de transliteración. Igual que "s///". Consulte "Operadores similares a comillas" en perlop.
truncar IDENTIFICADOR DE ARCHIVO, LONGITUD
truncar EXPR, LONGITUD
Trunca el archivo abierto en FILEHANDLE, o nombrado por EXPR, a la longitud especificada.
Genera una excepción si truncar no está implementado en su sistema. Devuelve verdadero si
exitoso, "undef" en caso de error.
El comportamiento no está definido si LENGTH es mayor que la longitud del archivo.
La posición en el archivo de FILEHANDLE no se modifica. Es posible que desee llamar a buscar
antes de escribir en el archivo.
Problemas de portabilidad: "truncar" en perlport.
EXPR
uc Devuelve una versión en mayúsculas de EXPR. Esta es la función interna que implementa el
Escape "\U" en cadenas entre comillas dobles. No intenta hacer un mapeo de títulos en
letras iniciales Ver "ucfirst" para eso.
Si se omite EXPR, utiliza $_.
Esta función se comporta de la misma manera bajo varios pragmas, como en un lugar, como "lc"
hace.
ucprimer EXPR
primero
Devuelve el valor de EXPR con el primer carácter en mayúscula (título en
Unicode). Esta es la función interna que implementa el escape "\u" entre comillas dobles
instrumentos de cuerda.
Si se omite EXPR, utiliza $_.
Esta función se comporta de la misma manera bajo varios pragmas, como en un lugar, como "lc"
hace.
EXPR de máscara de usuario
umask
Establece la umask para el proceso en EXPR y devuelve el valor anterior. Si EXPR es
omitido, simplemente devuelve el umask actual.
El permiso de Unix "rwxr-x---" se representa como tres conjuntos de tres bits, o tres
dígitos octales: 0750 (el 0 inicial indica octal y no es uno de los dígitos). Él
El valor "umask" es un número que representa bits de permisos deshabilitados. El permiso
(o "modo") los valores que pasa "mkdir" o "sysopen" son modificados por su umask, por lo que incluso
si le dices a "sysopen" que cree un archivo con permisos 0777, si tu umask es 0022,
entonces el archivo se creará con los permisos 0755. Si su "umask" fuera
0027 (el grupo no puede escribir; otros no pueden leer, escribir o ejecutar), luego pasa "sysopen"
0666 crearía un archivo con el modo 0640 (porque "0666 &~ 027" es 0640).
Aquí hay algunos consejos: proporcione un modo de creación de 0666 para archivos regulares (en "sysopen")
y uno de 0777 para directorios (en "mkdir") y archivos ejecutables. Esto les da a los usuarios
la libertad de elección: si quieren archivos protegidos, pueden elegir procesar umasks
de 022, 027, o incluso la máscara particularmente antisocial de 077. Los programas rara vez deben
si alguna vez se toman decisiones sobre políticas, es mejor dejarlas en manos del usuario. La excepción a esto es cuando
escribir archivos que deben mantenerse privados: archivos de correo, cookies del navegador web, .rhosts
archivos, etc.
If umask(2) no está implementado en su sistema y está tratando de restringir el acceso
for a ti mismo (es decir, "(EXPR & 0700) > 0"), genera una excepción. Si umask(2) no es
implementado y no está tratando de restringir el acceso por sí mismo, devuelve "undef".
Recuerde que un umask es un número, generalmente dado en octal; está no una cadena de octales
dígitos Consulte también "oct", si todo lo que tiene es una cadena.
Problemas de portabilidad: "umask" en perlport.
EXPR undef
undef
Anula la definición del valor de EXPR, que debe ser un valor l. Utilizar sólo en un valor escalar, un
matriz (usando "@"), un hash (usando "%"), una subrutina (usando "&") o un typeglob (usando
"*"). Decir "undef $hash{$key}" probablemente no hará lo que espera en la mayoría
variables predefinidas o valores de lista DBM, así que no haga eso; ver "eliminar". Siempre
devuelve el valor indefinido. Puede omitir la EXPR, en cuyo caso nada es
indefinido, pero aún obtiene un valor indefinido que podría, por ejemplo, devolver
desde una subrutina, asignar a una variable o pasar como parámetro. Ejemplos:
indefinido $foo;
undef $barra{'blurfl'}; # Comparar con: eliminar $bar{'blurfl'};
undef @ario;
undef % hash;
undef &mysub;
undef *xyz; # destruye $xyz, @xyz, %xyz, &xyz, etc.
return (wantarray ? (undef, $errmsg): undef) if $ellos_blew_it;
seleccione undef, undef, undef, 0.25;
($a, $b, undef, $c) = &foo; # Ignorar el tercer valor devuelto
Tenga en cuenta que este es un operador unario, no un operador de lista.
desvincular LISTA
desconectar
Elimina una lista de archivos. En caso de éxito, devuelve el número de archivos que con éxito
eliminado En caso de falla, devuelve falso y establece $! (Error):
my $desvinculado = desvinculado 'a', 'b', 'c';
desvincular @goners;
desvincular global "*.bak";
En caso de error, "desvincular" no le dirá qué archivos no pudo eliminar. Si quieres
sepa qué archivos no pudo eliminar, pruébelos uno a la vez:
foreach mi $archivo ( @goners ) {
desvincular $archivo o advertir "¡No se pudo desvincular $archivo: $!";
}
Nota: "desvincular" no intentará eliminar directorios a menos que sea un superusuario y el
-U la bandera se proporciona a Perl. Incluso si se cumplen estas condiciones, tenga en cuenta que
desvincular un directorio puede dañar su sistema de archivos. Finalmente, usando "desvincular"
en directorios no es compatible con muchos sistemas operativos. Utilice "rmdir" en su lugar.
Si se omite LIST, "desvincular" usa $_.
desempaquetar PLANTILLA, EXPR
desempaquetar PLANTILLA
"desempaquetar" hace lo contrario de "empacar": toma una cadena y la expande en una lista
de valores (En contexto escalar, devuelve simplemente el primer valor producido).
Si se omite EXPR, desempaqueta la cadena $_. Ver perlpacktut para una introducción a
esta función
La cadena se divide en fragmentos descritos por la PLANTILLA. Cada fragmento se convierte
por separado a un valor. Por lo general, la cadena es el resultado de "paquete" o el
los caracteres de la cadena representan una estructura C de algún tipo.
La PLANTILLA tiene el mismo formato que en la función "empaquetar". Aquí hay una subrutina que
hace subcadena:
sub substr {
mi($qué,$dónde,$cuánto) = @_;
unpack("x$donde $cuanto", $que);
}
y luego está
sub ordinal { desempaquetar("W",$_[0]); } # igual que orden()
Además de los campos permitidos en paquete(), puede prefijar un campo con un % para
indica que quieres un suma de comprobación de bits de los elementos en lugar de los elementos
ellos mismos. El valor predeterminado es una suma de comprobación de 16 bits. La suma de comprobación se calcula sumando valores numéricos
valores de valores expandidos (para campos de cadena se toma la suma de "ord($char)"; para bit
campos la suma de ceros y unos).
Por ejemplo, lo siguiente calcula el mismo número que el programa de suma System V:
$suma de comprobación = hacer {
locales $/; # sorber!
desempaquetar("%32W*",<>) % 65535;
};
Lo siguiente cuenta eficientemente el número de bits establecidos en un vector de bits:
$setbits = desempaquetar("%32b*", $selectmask);
Los formatos "p" y "P" deben usarse con cuidado. Dado que Perl no tiene forma de verificar
si el valor pasado a "unpack()" corresponde a una ubicación de memoria válida, pasando
es probable que un valor de puntero que no se sabe que sea válido tenga efectos desastrosos
Consecuencias.
Si hay más códigos de paquete o si el número de repeticiones de un campo o grupo es mayor
de lo que permite el resto de la cadena de entrada, el resultado no está bien definido:
el recuento de repeticiones puede disminuir, o "desempaquetar ()" puede producir cadenas vacías o ceros,
o puede generar una excepción. Si la cadena de entrada es más larga que la descrita por el
PLANTILLA, el resto de esa cadena de entrada se ignora.
Ver "paquete" para más ejemplos y notas.
unshift ARRAY, LIST
cancelar EXPR, LISTA
Hace lo contrario de un "cambio". O lo contrario de un "empuje", dependiendo de cómo
Míralo. Antepone la lista al frente de la matriz y devuelve el nuevo número de
elementos de la matriz.
unshift(@ARGV, '-e') a menos que $ARGV[0] =~ /^-/;
Tenga en cuenta que la LISTA se antepone completa, no un elemento a la vez, por lo que los elementos antepuestos
permanecer en el mismo orden. Use "reverse" para hacer lo contrario.
A partir de Perl 5.14, "unshift" puede tomar un EXPR escalar, que debe contener una referencia
a una matriz no bendecida. El argumento será desreferenciado automáticamente. Este aspecto
de "unshift" se considera altamente experimental. El comportamiento exacto puede cambiar en un
futura versión de Perl.
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.014; # entonces push/pop/etc funciona en escalares (experimental)
desatar VARIABLE
Rompe el enlace entre una variable y un paquete. (Ver empate.) No tiene efecto si el
la variable no está ligada.
utilizar el módulo LISTA DE VERSIONES
use la VERSIÓN del módulo
utilizar LISTA de módulos
Módulo de uso
usar VERSIÓN
Importa algunas semánticas al paquete actual desde el módulo nombrado, generalmente por
alias de ciertas subrutinas o nombres de variables en su paquete. es exactamente
equivalente a
COMENZAR { requiere Módulo; Módulo->importar( LISTA ); }
excepto ese Módulo deben ser una simple palabra. La importación puede condicionarse por
utilizando el módulo if.
En la peculiar forma de "usar VERSIÓN", VERSIÓN puede ser una fracción decimal positiva
como 5.006, que se comparará con $], o una v-string de la forma v5.6.1, que
se comparará con $^V (también conocido como $PERL_VERSION). Se genera una excepción si VERSION es
mayor que la versión del intérprete actual de Perl; Perl no intentará
analizar el resto del archivo. Compare con "requerir", que puede hacer una verificación similar en
tiempo de ejecución Simétricamente, "sin VERSIÓN" le permite especificar que desea una versión
de Perl anterior al especificado.
Por lo general, se debe evitar especificar VERSION como un literal de la forma v5.6.1,
porque conduce a mensajes de error engañosos en versiones anteriores de Perl (es decir,
anteriores a 5.6.0) que no admiten esta sintaxis. La versión numérica equivalente
debe usarse en su lugar.
usar v5.6.1; # Comprobación de la versión en tiempo de compilación
usar 5.6.1; # ídem
usa 5.006_001; # ídem; preferido por compatibilidad con versiones anteriores
Esto suele ser útil si necesita verificar la versión actual de Perl antes de "usar"
módulos de biblioteca que no funcionarán con versiones anteriores de Perl. (Tratamos de no hacer esto
más de lo que tenemos que hacerlo.)
"use VERSION" también habilita léxicamente todas las funciones disponibles en la versión solicitada
como se define en el pragma "característica", deshabilitar cualquier característica que no esté en el pedido
paquete de características de la versión. Ver característica. Del mismo modo, si la versión de Perl especificada es
mayor o igual a 5.12.0, las restricciones se habilitan léxicamente como con "usar
estricto". Cualquier uso explícito de "usar estricto" o "no estricto" anula "usar VERSIÓN",
incluso si viene antes. El uso posterior de "usar VERSIÓN" anulará todo el comportamiento de
una "VERSIÓN de uso" anterior, posiblemente eliminando el "estricto" y la "característica" agregada por "usar
VERSIÓN". "usar VERSIÓN" no carga la característica.pm or estricto.pm archivos.
El "BEGIN" obliga a "requerir" e "importar" a suceder en tiempo de compilación. Él
"requerir" se asegura de que el módulo se cargue en la memoria si aún no lo ha hecho. Él
"importar" no es una función incorporada; es solo una llamada de método estático ordinario al "Módulo"
paquete para decirle al módulo que importe la lista de funciones de nuevo al actual
paquete. El módulo puede implementar su método de "importación" como quiera, aunque la mayoría
los módulos simplemente eligen derivar su método de "importación" a través de la herencia del
Clase "Exportador" que se define en el módulo "Exportador". Ver Exportador. Si no
Se puede encontrar el método de "importación", luego se omite la llamada, incluso si hay una CARGA AUTOMÁTICA
método.
Si no desea llamar al método de "importación" del paquete (por ejemplo, para detener su
el espacio de nombres se modifique), proporcione explícitamente la lista vacía:
usar Módulo ();
Eso es exactamente equivalente a
COMENZAR { requiere Módulo }
Si el argumento VERSIÓN está presente entre Módulo y LISTA, entonces el "uso" llamará
el método VERSION en la clase Módulo con la versión dada como argumento. El valor por defecto
El método VERSION, heredado de la clase UNIVERSAL, croa si la versión dada es
mayor que el valor de la variable $Module::VERSION.
Nuevamente, hay una distinción entre omitir LIST ("importar" llamado sin
argumentos) y una LISTA vacía explícita "()" ("importación" no llamada). Tenga en cuenta que hay
sin coma después de VERSION!
Debido a que esta es una interfaz abierta, los pragmas (directivas del compilador) también son
implementado de esta manera. Los pragmas implementados actualmente son:
uso constante;
usar diagnósticos;
usar entero;
use sigtrap qw (SEGV AUTOBÚS);
use qw estricto (subs vars refs);
usar subs qw(afunc blurfl);
usar advertencias qw(todos);
use sort qw(estable _quicksort _mergesort);
Algunos de estos pseudomódulos importan semántica al alcance del bloque actual (como
"estricto" o "entero", a diferencia de los módulos ordinarios, que importan símbolos en el actual
paquete (que son efectivos hasta el final del archivo).
Debido a que el "uso" surte efecto en tiempo de compilación, no respeta el flujo ordinario
control del código que se está compilando. En particular, poner un "uso" dentro de la falsa
La rama de un condicional no impide que se procese. Si un módulo o
pragma solo necesita cargarse condicionalmente, esto se puede hacer usando if pragma:
usar si $] < 5.008, "utf8";
use if WANT_WARNINGS, advertencias => qw(todas);
Hay una declaración "no" correspondiente que no importa significados importados por "uso",
es decir, llama a "no importar LISTA de módulos" en lugar de "importar". Se comporta igual que
"importar" lo hace con VERSION, una LISTA omitida o vacía, o ningún método de desimportación
Incluso cuando ambos padres biológicos vivían con el niño, los hogares casados eran más pacíficos que los que convivían, descubrió el Sr. Zill.
sin número entero;
no hay "referencias" estrictas;
sin advertencias;
Se debe tener cuidado al usar la forma "no VERSION" de "no". Está only destinado a suceder
utilizado para afirmar que el Perl en ejecución es de una versión anterior a su argumento y no
para deshacer los efectos secundarios de habilitación de funciones de "usar VERSIÓN".
Consulte perlmodlib para obtener una lista de módulos estándar y pragmas. Ver perlrun para el "-M"
y opciones de línea de comandos "-m" para Perl que brindan funcionalidad de "uso" desde el comando-
la línea.
LISTA de tiempo
Cambia los tiempos de acceso y modificación en cada archivo de una lista de archivos. El primero
dos elementos de la lista deben ser los tiempos de acceso y modificación NUMERICOS, en ese
pedido. Devuelve el número de archivos modificados con éxito. El tiempo de cambio de inodo de
cada archivo se establece en la hora actual. Por ejemplo, este código tiene el mismo efecto que
el Unix contacto(1) comando cuando los archivos ya haya utilizado existe y pertenecen al usuario que ejecuta
el programa:
#!/ usr / bin / perl
$ahora = $mhora = hora;
utime $ atime, $ mtime, @ARGV;
Desde Perl 5.8.0, si los dos primeros elementos de la lista son "undef", el tiempo útil(2)
syscall desde su biblioteca C se llama con un segundo argumento nulo. En la mayoría de los sistemas,
esto establecerá las horas de acceso y modificación del archivo a la hora actual (es decir,
equivalente al ejemplo anterior) y funcionará incluso en archivos que no sean de su propiedad siempre
tienes permiso de escritura:
para $archivo (@ARGV) {
utime(undef, undef, $archivo)
|| advertir "no se pudo tocar $archivo: $!";
}
Bajo NFS, esto usará la hora del servidor NFS, no la hora de la máquina local.
Si hay un problema de sincronización de tiempo, el servidor NFS y la máquina local tendrán
tiempos diferentes. El Unix contacto(1) de hecho, el comando normalmente usará este formulario
en lugar del que se muestra en el primer ejemplo.
Pasar solo uno de los dos primeros elementos como "undef" es equivalente a pasar un 0 y
no tendrá el efecto descrito cuando ambos estén "indefinidos". Esto también desencadena una
advertencia no inicializada.
En sistemas que apoyan en el futuro(2), puede pasar identificadores de archivos entre los archivos. Sobre
sistemas que no son compatibles en el futuro(2), pasar identificadores de archivo genera una excepción.
Los identificadores de archivo deben pasarse como referencias globales o globales para ser reconocidos; las palabras desnudas son
considerados nombres de archivo.
Problemas de portabilidad: "utime" en perlport.
valores HASH
matriz de valores
valores EXPR
En el contexto de la lista, devuelve una lista que consta de todos los valores del hash con nombre. En
Solo Perl 5.12 o posterior, también devolverá una lista de los valores de una matriz; Antes de
esa versión, intentar usar un argumento de matriz producirá un error de sintaxis. En
contexto escalar, devuelve el número de valores.
Las entradas hash se devuelven en un orden aparentemente aleatorio. El orden aleatorio real es
específico de un hash dado; la misma serie exacta de operaciones en dos hashes puede resultar
en un orden diferente para cada hash. Cualquier inserción en el hash puede cambiar el orden,
al igual que cualquier eliminación, con la excepción de que la clave más reciente devuelta por "cada"
o las "claves" pueden eliminarse sin cambiar el orden. Siempre que un hash determinado sea
sin modificar, puede confiar en "claves", "valores" y "cada uno" para devolver repetidamente el mismo
orden como el uno al otro. Consulte "Ataques de complejidad algorítmica" en perlsec para obtener detalles sobre
por qué el orden hash es aleatorio. Aparte de las garantías proporcionadas aquí, la exacta
Los detalles del algoritmo hash de Perl y el orden transversal de hash están sujetos a cambios en
cualquier versión de Perl. Los hashes vinculados pueden comportarse de manera diferente a los hashes de Perl con respecto
a los cambios en el orden de inserción y eliminación de artículos.
Como efecto secundario, llamar valores () reinicia el iterador interno de HASH o ARRAY, ver
"cada". (En particular, llamar valores () en contexto vacío restablece el iterador sin
otros gastos generales. Además de restablecer el iterador, "values @array" en el contexto de la lista es
lo mismo que simple @array. (Le recomendamos que utilice el contexto vacío "keys @array" para
esto, pero razonó que eliminar "values @array" requeriría más documentación
que dejarlo adentro.)
Tenga en cuenta que los valores no se copian, lo que significa que modificarlos modificará el
contenido del hash:
for (valores %hash) { s/foo/bar/g } # modifica los valores %hash
para (@hash{teclas %hash}) { s/foo/bar/g } # igual
A partir de Perl 5.14, los "valores" pueden tomar una EXPR escalar, que debe contener una referencia
a un hash o matriz no bendecidos. El argumento será desreferenciado automáticamente. Esta
aspecto de "valores" se considera altamente experimental. El comportamiento exacto puede cambiar
en una versión futura de Perl.
para (valores $hashref) { ... }
for (valores $obj->get_arrayref) { ... }
Para evitar confundir a los posibles usuarios de su código que ejecutan versiones anteriores de
Perl con misteriosos errores de sintaxis, coloque este tipo de cosas en la parte superior de su archivo para
señal de que su código funcionará only en Perls de una cosecha reciente:
usar 5.012; # así que las claves/valores/cada uno funciona en arreglos
usar 5.014; # entonces claves/valores/cada uno trabaja en escalares (experimental)
Consulte también "claves", "cada una" y "ordenar".
vec EXPR, COMPENSACIÓN, BITS
Trata la cadena en EXPR como un vector de bits formado por elementos de ancho BITS y
devuelve el valor del elemento especificado por OFFSET como un entero sin signo. PUNTOS
por lo tanto, especifica el número de bits que están reservados para cada elemento en el bit
vector. Esto debe ser una potencia de dos de 1 a 32 (o 64, si su plataforma admite
ese).
Si BITS es 8, los "elementos" coinciden con los bytes de la cadena de entrada.
Si BITS es 16 o más, los bytes de la cadena de entrada se agrupan en fragmentos de tamaño
BITS/8, y cada grupo se convierte en un número como con paquete()/deshacer() con grande-
formatos endian "n"/"N" (y análogamente para BITS==64). Ver envase para los detalles.
Si los bits son 4 o menos, la cadena se divide en bytes, luego los bits de cada byte se
dividido en grupos 8/BITS. Los bits de un byte se numeran de forma little-endian, como
en 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80. Por ejemplo, romper el single
byte de entrada "chr(0x36)" en dos grupos da una lista "(0x6, 0x3)"; dividiéndola en 4
grupos da "(0x2, 0x1, 0x3, 0x0)".
También se puede asignar "vec", en cuyo caso se necesitan paréntesis para dar el
expresión la precedencia correcta como en
vec($imagen, $max_x * $x + $y, 8) = 3;
Si el elemento seleccionado está fuera de la cadena, se devuelve el valor 0. Si un elemento
fuera del final de la cadena en la que se escribe, Perl primero extenderá la cadena con
suficientes cero bytes. Es un error tratar de cancelar el comienzo de
la cadena (es decir, OFFSET negativo).
Si la cadena está codificada como UTF-8 internamente (y por lo tanto tiene el indicador UTF8
set), esto es ignorado por "vec", y opera en la cadena de bytes interna, no en la
cadena de caracteres conceptuales, incluso si solo tiene caracteres con valores inferiores a
256.
Las cadenas creadas con "vec" también se pueden manipular con los operadores lógicos "|",
"&", "^" y "~". Estos operadores supondrán que se desea una operación de vector de bits cuando
ambos operandos son cadenas. Consulte "Operadores de cadena bit a bit" en perlop.
El siguiente código creará una cadena ASCII que dice 'PerlPerlPerl'. Los comentarios
mostrar la cadena después de cada paso. Tenga en cuenta que este código funciona de la misma manera en big-
máquinas endian o little-endian.
mi $foo = '';
vec($foo, 0, 32) = 0x5065726C; # 'Perla'
# $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits
imprimir vec($foo, 0, 8); # imprime 80 == 0x50 == ord('P')
vec($foo, 2, 16) = 0x5065; # 'PerlPe'
vec($foo, 3, 16) = 0x726C; # 'PerlPerl'
vec($foo, 8, 8) = 0x50; # 'PerlPerlP'
vec($foo, 9, 8) = 0x65; # 'PerlPerlPe'
vec($foo, 20, 4) = 2; # 'PerlPerlPe' . "\x02"
vec($foo, 21, 4) = 7; # 'PerlPerlPer'
# 'r' es "\x72"
vec($foo, 45, 2) = 3; # 'PerlPerlPer' . "\x0c"
vec($foo, 93, 1) = 1; # 'PerlPerlPer' . "\x2c"
vec($foo, 94, 1) = 1; # 'PerlPerlPerl'
# 'l' es "\x6c"
Para transformar un vector de bits en una cadena o lista de 0 y 1, use estos:
$bits = desempaquetar("b*", $vector);
@bits = dividir(//, desempaquetar("b*", $vector));
Si conoce la longitud exacta en bits, se puede utilizar en lugar del "*".
Aquí hay un ejemplo para ilustrar cómo los bits realmente caen en su lugar:
#!/ usr / bin / perl -wl
imprimir <<'FIN';
0 1 2 3
desempaquetar("V",$_) 01234567890123456789012345678901
-------------------------------------------------- ----------------
EOT
para $w (0..3) {
$ancho = 2**$ancho;
for ($shift=0; $shift < $ancho; ++$shift) {
for ($apagado=0; $apagado < 32/$ancho; ++$apagado) {
$cadena = paquete("B*", "0"x32);
$bits = (1<<$cambio);
vec($str, $off, $ancho) = $bits;
$res = desempaquetar("b*",$cadena);
$val = desempaquetar("V", $cadena);
escribir;
}
}
}
formato STDOUT =
vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>
$apagado, $ancho, $bits, $valor, $res.
.
__FIN__
Independientemente de la arquitectura de la máquina en la que se ejecuta, el ejemplo anterior debería
imprima la siguiente tabla:
0 1 2 3
desempaquetar("V",$_) 01234567890123456789012345678901
-------------------------------------------------- ----------------
vec($_, 0, 1) = 1 == 1 10000000000000000000000000000000
vec($_, 1, 1) = 1 == 2 01000000000000000000000000000000
vec($_, 2, 1) = 1 == 4 00100000000000000000000000000000
vec($_, 3, 1) = 1 == 8 00010000000000000000000000000000
vec($_, 4, 1) = 1 == 16 00001000000000000000000000000000
vec($_, 5, 1) = 1 == 32 00000100000000000000000000000000
vec($_, 6, 1) = 1 == 64 00000010000000000000000000000000
vec($_, 7, 1) = 1 == 128 00000001000000000000000000000000
vec($_, 8, 1) = 1 == 256 00000000100000000000000000000000
vec($_, 9, 1) = 1 == 512 00000000010000000000000000000000
vec($_,10, 1) = 1 == 1024 00000000001000000000000000000000
vec($_,11, 1) = 1 == 2048 00000000000100000000000000000000
vec($_,12, 1) = 1 == 4096 00000000000010000000000000000000
vec($_,13, 1) = 1 == 8192 00000000000001000000000000000000
vec($_,14, 1) = 1 == 16384 00000000000000100000000000000000
vec($_,15, 1) = 1 == 32768 00000000000000010000000000000000
vec($_,16, 1) = 1 == 65536 00000000000000001000000000000000
vec($_,17, 1) = 1 == 131072 00000000000000000100000000000000
vec($_,18, 1) = 1 == 262144 00000000000000000010000000000000
vec($_,19, 1) = 1 == 524288 00000000000000000001000000000000
vec($_,20, 1) = 1 == 1048576 00000000000000000000100000000000
vec($_,21, 1) = 1 == 2097152 00000000000000000000010000000000
vec($_,22, 1) = 1 == 4194304 00000000000000000000001000000000
vec($_,23, 1) = 1 == 8388608 00000000000000000000000100000000
vec($_,24, 1) = 1 == 16777216 00000000000000000000000010000000
vec($_,25, 1) = 1 == 33554432 00000000000000000000000001000000
vec($_,26, 1) = 1 == 67108864 00000000000000000000000000100000
vec($_,27, 1) = 1 == 134217728 00000000000000000000000000010000
vec($_,28, 1) = 1 == 268435456 00000000000000000000000000001000
vec($_,29, 1) = 1 == 536870912 00000000000000000000000000000100
vec($_,30, 1) = 1 == 1073741824 00000000000000000000000000000010
vec($_,31, 1) = 1 == 2147483648 00000000000000000000000000000001
vec($_, 0, 2) = 1 == 1 10000000000000000000000000000000
vec($_, 1, 2) = 1 == 4 00100000000000000000000000000000
vec($_, 2, 2) = 1 == 16 00001000000000000000000000000000
vec($_, 3, 2) = 1 == 64 00000010000000000000000000000000
vec($_, 4, 2) = 1 == 256 00000000100000000000000000000000
vec($_, 5, 2) = 1 == 1024 00000000001000000000000000000000
vec($_, 6, 2) = 1 == 4096 00000000000010000000000000000000
vec($_, 7, 2) = 1 == 16384 00000000000000100000000000000000
vec($_, 8, 2) = 1 == 65536 00000000000000001000000000000000
vec($_, 9, 2) = 1 == 262144 00000000000000000010000000000000
vec($_,10, 2) = 1 == 1048576 00000000000000000000100000000000
vec($_,11, 2) = 1 == 4194304 00000000000000000000001000000000
vec($_,12, 2) = 1 == 16777216 00000000000000000000000010000000
vec($_,13, 2) = 1 == 67108864 00000000000000000000000000100000
vec($_,14, 2) = 1 == 268435456 00000000000000000000000000001000
vec($_,15, 2) = 1 == 1073741824 00000000000000000000000000000010
vec($_, 0, 2) = 2 == 2 01000000000000000000000000000000
vec($_, 1, 2) = 2 == 8 00010000000000000000000000000000
vec($_, 2, 2) = 2 == 32 00000100000000000000000000000000
vec($_, 3, 2) = 2 == 128 00000001000000000000000000000000
vec($_, 4, 2) = 2 == 512 00000000010000000000000000000000
vec($_, 5, 2) = 2 == 2048 00000000000100000000000000000000
vec($_, 6, 2) = 2 == 8192 00000000000001000000000000000000
vec($_, 7, 2) = 2 == 32768 00000000000000010000000000000000
vec($_, 8, 2) = 2 == 131072 00000000000000000100000000000000
vec($_, 9, 2) = 2 == 524288 00000000000000000001000000000000
vec($_,10, 2) = 2 == 2097152 00000000000000000000010000000000
vec($_,11, 2) = 2 == 8388608 00000000000000000000000100000000
vec($_,12, 2) = 2 == 33554432 00000000000000000000000001000000
vec($_,13, 2) = 2 == 134217728 00000000000000000000000000010000
vec($_,14, 2) = 2 == 536870912 00000000000000000000000000000100
vec($_,15, 2) = 2 == 2147483648 00000000000000000000000000000001
vec($_, 0, 4) = 1 == 1 10000000000000000000000000000000
vec($_, 1, 4) = 1 == 16 00001000000000000000000000000000
vec($_, 2, 4) = 1 == 256 00000000100000000000000000000000
vec($_, 3, 4) = 1 == 4096 00000000000010000000000000000000
vec($_, 4, 4) = 1 == 65536 00000000000000001000000000000000
vec($_, 5, 4) = 1 == 1048576 00000000000000000000100000000000
vec($_, 6, 4) = 1 == 16777216 00000000000000000000000010000000
vec($_, 7, 4) = 1 == 268435456 00000000000000000000000000001000
vec($_, 0, 4) = 2 == 2 01000000000000000000000000000000
vec($_, 1, 4) = 2 == 32 00000100000000000000000000000000
vec($_, 2, 4) = 2 == 512 00000000010000000000000000000000
vec($_, 3, 4) = 2 == 8192 00000000000001000000000000000000
vec($_, 4, 4) = 2 == 131072 00000000000000000100000000000000
vec($_, 5, 4) = 2 == 2097152 00000000000000000000010000000000
vec($_, 6, 4) = 2 == 33554432 00000000000000000000000001000000
vec($_, 7, 4) = 2 == 536870912 00000000000000000000000000000100
vec($_, 0, 4) = 4 == 4 00100000000000000000000000000000
vec($_, 1, 4) = 4 == 64 00000010000000000000000000000000
vec($_, 2, 4) = 4 == 1024 00000000001000000000000000000000
vec($_, 3, 4) = 4 == 16384 00000000000000100000000000000000
vec($_, 4, 4) = 4 == 262144 00000000000000000010000000000000
vec($_, 5, 4) = 4 == 4194304 00000000000000000000001000000000
vec($_, 6, 4) = 4 == 67108864 00000000000000000000000000100000
vec($_, 7, 4) = 4 == 1073741824 00000000000000000000000000000010
vec($_, 0, 4) = 8 == 8 00010000000000000000000000000000
vec($_, 1, 4) = 8 == 128 00000001000000000000000000000000
vec($_, 2, 4) = 8 == 2048 00000000000100000000000000000000
vec($_, 3, 4) = 8 == 32768 00000000000000010000000000000000
vec($_, 4, 4) = 8 == 524288 00000000000000000001000000000000
vec($_, 5, 4) = 8 == 8388608 00000000000000000000000100000000
vec($_, 6, 4) = 8 == 134217728 00000000000000000000000000010000
vec($_, 7, 4) = 8 == 2147483648 00000000000000000000000000000001
vec($_, 0, 8) = 1 == 1 10000000000000000000000000000000
vec($_, 1, 8) = 1 == 256 00000000100000000000000000000000
vec($_, 2, 8) = 1 == 65536 00000000000000001000000000000000
vec($_, 3, 8) = 1 == 16777216 00000000000000000000000010000000
vec($_, 0, 8) = 2 == 2 01000000000000000000000000000000
vec($_, 1, 8) = 2 == 512 00000000010000000000000000000000
vec($_, 2, 8) = 2 == 131072 00000000000000000100000000000000
vec($_, 3, 8) = 2 == 33554432 00000000000000000000000001000000
vec($_, 0, 8) = 4 == 4 00100000000000000000000000000000
vec($_, 1, 8) = 4 == 1024 00000000001000000000000000000000
vec($_, 2, 8) = 4 == 262144 00000000000000000010000000000000
vec($_, 3, 8) = 4 == 67108864 00000000000000000000000000100000
vec($_, 0, 8) = 8 == 8 00010000000000000000000000000000
vec($_, 1, 8) = 8 == 2048 00000000000100000000000000000000
vec($_, 2, 8) = 8 == 524288 00000000000000000001000000000000
vec($_, 3, 8) = 8 == 134217728 00000000000000000000000000010000
vec($_, 0, 8) = 16 == 16 00001000000000000000000000000000
vec($_, 1, 8) = 16 == 4096 00000000000010000000000000000000
vec($_, 2, 8) = 16 == 1048576 00000000000000000000100000000000
vec($_, 3, 8) = 16 == 268435456 00000000000000000000000000001000
vec($_, 0, 8) = 32 == 32 00000100000000000000000000000000
vec($_, 1, 8) = 32 == 8192 00000000000001000000000000000000
vec($_, 2, 8) = 32 == 2097152 00000000000000000000010000000000
vec($_, 3, 8) = 32 == 536870912 00000000000000000000000000000100
vec($_, 0, 8) = 64 == 64 00000010000000000000000000000000
vec($_, 1, 8) = 64 == 16384 00000000000000100000000000000000
vec($_, 2, 8) = 64 == 4194304 00000000000000000000001000000000
vec($_, 3, 8) = 64 == 1073741824 00000000000000000000000000000010
vec($_, 0, 8) = 128 == 128 00000001000000000000000000000000
vec($_, 1, 8) = 128 == 32768 00000000000000010000000000000000
vec($_, 2, 8) = 128 == 8388608 00000000000000000000000100000000
vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001
esperar
Se comporta como esperar(2) en su sistema: espera a que termine un proceso secundario y
devuelve el pid del proceso fallecido, o "-1" si no hay procesos secundarios. Él
el estado se devuelve en $? y "${^CHILD_ERROR_NATIVE}". Tenga en cuenta que un valor de retorno de
"-1" podría significar que los procesos secundarios se cosechan automáticamente, como se describe en
perlipc.
Si usa "esperar" en su controlador para $SIG{CHLD}, accidentalmente puede esperar por el
niño creado por qx () or sistema(). Ver perlipc para más detalles.
Problemas de portabilidad: "esperar" en perlport.
Waitpid PID, BANDERAS
Espera a que finalice un proceso secundario en particular y devuelve el pid del difunto
proceso, o "-1" si no existe tal proceso hijo. En algunos sistemas, un valor de 0
indica que hay procesos aún en ejecución. El estado se devuelve en $? y
"${^CHILD_ERROR_NATIVE}". Si usted dice
use POSIX ": sys_wait_h";
# ...
hacer {
$niño = waitpid(-1, WNOHANG);
} while $niño > 0;
entonces puede hacer una espera sin bloqueo para todos los procesos zombies pendientes. sin bloqueo
wait está disponible en máquinas que soportan el esperar(2) o espera4(2) llamadas al sistema.
Sin embargo, la espera de un pid en particular con FLAGS de 0 se implementa en todas partes.
(Perl emula la llamada al sistema al recordar los valores de estado de los procesos que tienen
salió pero aún no ha sido recolectado por el script de Perl).
Tenga en cuenta que en algunos sistemas, un valor de retorno de "-1" podría significar que los procesos secundarios están
siendo cosechado automáticamente. Ver perlipc para más detalles y para otros ejemplos.
Problemas de portabilidad: "waitpid" en perlport.
quieroarreglo
Devuelve verdadero si el contexto de la subrutina que se está ejecutando actualmente o "eval" está buscando
para un valor de lista. Devuelve falso si el contexto busca un escalar. Devuelve el
valor indefinido si el contexto no busca ningún valor (contexto vacío).
volver a menos que se defina wantarray; # no te molestes en hacer más
mi @a = cálculo_complejo();
volver wantarray? @a : "@a";
El resultado de "wantarray()" no está especificado en el nivel superior de un archivo, en un "BEGIN",
Bloque "UNITCHECK", "CHECK", "INIT" o "END", o en un método "DESTROY".
Esta función debería haber sido nombrada lista de deseos() preferiblemente.
advertir LISTA
Imprime el valor de LIST en STDERR. Si el último elemento de LIST no termina en un
nueva línea, agrega el mismo texto de archivo/número de línea que "die".
Si la salida está vacía y $ @ ya contiene un valor (generalmente de un
eval) ese valor se usa después de agregar "\t... capturado" a $@. Esto es útil para
permaneciendo casi, pero no del todo similar a "morir".
Si $@ está vacío, se utiliza la cadena "Advertencia: Algo anda mal".
No se imprime ningún mensaje si hay un controlador $SIG{__WARN__} instalado. Es el
responsabilidad del manejador de manejar el mensaje como mejor le parezca (como, por ejemplo,
convirtiéndolo en un "dado"). Por lo tanto, la mayoría de los manipuladores deben hacer arreglos para mostrar realmente
las advertencias que no están preparados para manejar, llamando "advertir" nuevamente en el
manipulador. Tenga en cuenta que esto es bastante seguro y no producirá un ciclo sin fin, ya que
Los ganchos "__WARN__" no se llaman desde el interior de uno.
Encontrará que este comportamiento es ligeramente diferente al de los controladores $SIG{__DIE__}
(que no suprime el texto de error, sino que puede volver a llamar a "morir" para cambiarlo).
El uso de un controlador "__WARN__" proporciona una forma poderosa de silenciar todas las advertencias (incluso las
los llamados obligatorios). Un ejemplo:
# eliminar *todas* las advertencias en tiempo de compilación
COMENZAR { $SIG{'__WARN__'} = sub { advertir $_[0] si $DOWARN } }
my $ foo = 10;
mi $foo = 20; # no hay advertencia sobre duplicar mi $foo,
# pero bueno, ¡tú lo pediste!
# no hay advertencias de tiempo de compilación o tiempo de ejecución antes de aquí
$ADVERTENCIA = 1;
# advertencias en tiempo de ejecución habilitadas después de aquí
advertir "\$foo está vivo y $foo!"; # aparece
Consulte perlvar para obtener detalles sobre la configuración de entradas %SIG y para obtener más ejemplos. ver la carpa
módulo para otro tipo de advertencias usando su carpa() y cloqueo() funciones.
escriba IDENTIFICADOR DE ARCHIVO
escribir EXPR
escribir
Escribe un registro formateado (posiblemente de varias líneas) en el IDENTIFICADOR DE ARCHIVO especificado, utilizando el
formato asociado con ese archivo. Por defecto, el formato de un archivo es el que tiene
el mismo nombre que el identificador de archivo, pero el formato para el canal de salida actual (ver
la función "seleccionar") se puede configurar explícitamente asignando el nombre del formato a
la variable $~.
El procesamiento de la parte superior del formulario se maneja automáticamente: si no hay suficiente espacio en el
página actual para el registro formateado, la página avanza escribiendo un feed de formulario y
se utiliza un formato especial de inicio de página para formatear el nuevo encabezado de página antes del registro
está escrito. De forma predeterminada, el formato de la parte superior de la página es el nombre del identificador de archivo con
Se agregó "_TOP" o "top" en el paquete actual si el primero no existe. Este
sería un problema con los identificadores de archivos autovivificados, pero puede establecerse dinámicamente en el
formato de su elección asignando el nombre a la variable $^ mientras ese identificador de archivo
es seleccionado. El número de líneas restantes en la página actual está en la variable "$-",
que se puede establecer en 0 para forzar una nueva página.
Si no se especifica FILEHANDLE, la salida va al canal de salida predeterminado actual, que
comienza como STDOUT pero puede ser cambiado por el operador "seleccionar". Si el IDENTIFICADOR DE ARCHIVO
es un EXPR, luego se evalúa la expresión y la cadena resultante se usa para buscar
el nombre del IDENTIFICADOR DE ARCHIVO en tiempo de ejecución. Para obtener más información sobre formatos, consulte performan.
Tenga en cuenta que escribir es no lo contrario de "leer". Desafortunadamente.
y ///
El operador de transliteración. Igual que "tr///". Consulte "Operadores similares a comillas" en perlop.
No funciona PALABRAS CLAVE by Referencia cruzada
perldatos
__DATOS__
__FIN__
Estas palabras clave están documentadas en "Literales especiales" en perldata.
perlmod
EMPEZAR
CHEQUEAR
FIN
INIT
COMPROBACIÓN DE LA UNIDAD
Estas palabras clave de fase de compilación están documentadas en "BEGIN, UNITCHECK, CHECK, INIT y END"
en perlmod.
perlobj
DESTRUIR
Esta palabra clave de método está documentada en "Destructores" en perlobj.
perplejo
y
cmp
eq
ge
gt
le
lt
ne
no
or
x
xor Estos operadores están documentados en perlop.
perlsub
CARGA AUTOMÁTICA
Esta palabra clave está documentada en "Carga automática" en perlsub.
Perlsyn
más
elsi
for
foreach
if
a menos que
hasta
mientras
Estas palabras clave de control de flujo están documentadas en "Declaraciones compuestas" en perlsyn.
de lo contrario
La palabra clave "else if" se escribe "elsif" en Perl. No hay "elif" o "else if"
o. Analiza "elseif", pero solo para advertirle que no lo use.
Consulte la documentación de las palabras clave de control de flujo en "Declaraciones compuestas" en perlsyn.
tu préstamo estudiantil
given
when
Estas palabras clave de control de flujo relacionadas con la función de cambio experimental están documentadas
en "Sentencias de cambio" en perlsyn.
Use perlfunc en línea usando los servicios de onworks.net