++ed by:
MISHIN SALVA

2 PAUSE users
4 non-PAUSE users.

Enrique Nell
and 1 contributors

NAME

perlfunc - Funciones predefinidas en Perl *** DOCUMENTO SIN REVISAR ***

DESCRIPCIÓN

Las funciones de esta sección pueden servir como términos en una expresión. Se agrupan en dos categorías principales: operadores de listas y operadores unarios con nombre. Difieren en su relación de precedencia cuando son seguidos por una coma. (Vea la tabla de precedencia, en perlop). Los operadores de lista toman más de un argumento, mientras que los operadores unarios nunca toman más de un argumento. Así, una coma determina al argumento de un operador unario, pero sólo sirve de separación entre argumentos en un operador de listas. Un operador unario generalmente proveé de un contexto escalar a su argumento, mientras que un operador de listas puede proveer tanto de un contexto escalar o de un contexto de lista, a sus argumentos. Si aparecen ambos, los argumentos escalares van antes que el argumento de lista, y a continuación solo puede existir un argumento de lista. Por ejemplo, splice tiene tres argumentos escalares seguidos por una lista, mientras que gethostbyname tiene cuatro argumentos escalares.

En las descripciones sintácticas que siguen a continuación, los operadores de listas que esperan una lista (y proveen de un contexto lista para los elementos de la lista) se muestran con un argumento así: LISTA. Tal lista puede consistir en cualquier combinación de argumentos escalares o valores de lista; los valores de lista serán incluidos en la lista como si cada elemento individual fuera interpolado en ese punto en la lista, formando un largo y unidimensional valor de lista. Las comas deberían separar elementos literales de la LISTA.

Cualquier función en la lista de abajo se puede usar tanto con paréntesis como sin ellos, rodeando sus argumentos. (Las descripciones sintácticas omiten los paréntesis). Si usa los paréntesis, la simple pero ocasionalmente sorprendente regla es esta: Si se parece a una función, es una función y la precedencia no importará. De lo contrario es un operador de lista u operador unario, y la precedencia sí importa. El espacio en blanco entre la función y el paréntesis izquierdo no cuenta, por lo que deberá tener cuidado en algunas ocasiones:

    print 1+2+4;        # Imprime 7.
    print(1+2) + 4;     # Imprime 3.
    print (1+2)+4;      # ¡También imprime 3!
    print +(1+2)+4;     # Imprime 7.
    print ((1+2)+4);    # Imprime 7.

Si ejecuta Perl con el pragma use warnings, le avisará sobre todo esto. Por ejemplo, la tercera línea de arriba produce:

    print (...) interpretado como función en la línea 1.
    Useless use of integer addition in void context at - line 1.
(Inútil uso de suma de enteros en contexto void en línea 1)

Unas pocas funciones no toman ningún argumento, por lo que funcionan tanto como operadores unarios como operadores de lista. Estas incluyen funciones tales como time y endpwent. Por ejemplo, time+86_400 siempre significa time() + 86_400.

Para funciones que pueden ser usadas tanto en contexto escalar como en contexto de lista, un error no abortivo es indicado, generalmente, por un valor indefinido en el contexto escalar, y en contexto lista por una lista vacía.

Recuerde la siguiente regla importante: No hay regla que relacione el comportamiento de una expresión en contexto lista a su comportamiento en contexto escalar, o viceversa. Puede hacer dos cosas totalmente diferentes. Cada operador y función decide qué clase de valor será más apropiado para devolver en contexto escalar. Algunos operadores devuelven la longitud de la lista que se hubiera devuelto en contexto lista. Algunos operadores devuelven el primer valor de la lista. Algunos operadores devuelven el último valor de la lista. Algunos operadores devuelven una cuenta del número de operaciones exitosas. En general, ellos hacen lo que usted quiere, siempre que quiera coherencia.

Un array con nombre, en contexto escalar, es muy diferente de lo que en un primer vistazo pudiera ser una lista en contexto escalar. No puede conseguir que una lista como (1,2,3) se convierta en contexto escalar porque el compilador conoce el contexto en tiempo de compilación. Se generará aquí el operador coma, no la versión de concatenación de listas de la propia coma. Esto significa que nunca será una lista.

En general, funciones en Perl que sirven como envoltorios para llamadas al sistema ("syscalls") del mismo nombre (como chown(2), fork(2), closedir(2), etc.) devuelven verdadero cuando tienen éxito, y undef en otro caso, como se menciona en las siguientes descripciones. Esto es diferente de las interfaces en C, que devuelven -1 en caso de error. Excepciones a esta regla incluyen a wait, waitpid y syscall. Llamadas al sistema también actualizan la variable especial $! en caso de error. Otras funciones no, excepto accidentalmente.

Hay módulos con expansiones que también pueden engancharse en el intérprete Perl para definir nuevas clases de expresiones basadas en palabras clave. Pueden parecerse a funciones, pero también pueden ser complementamente diferentes. La sintaxis que sigue al identificador se define enteramente por la expansión. Si es usted un implantador, mire "PL_keyword_plugin" in perlapi para informarse sobre este mecanismo. Si está usando un módulo así, mire la documentación del módulo para ver los detalles de la sintaxis que define.

Funciones Perl por categoría

Aquí están las funciones Perl (incluyen cosas que parecen funciones, como algunas palabras clave y operadores con nombre) agrupados por categoría. Algunas funciones aparecen en más de un lugar.

Functiones para ESCALARES 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 sólo está disponible si la característica "fc" está habilitada o si está prefijada con CORE::. La característica "fc" se activa automáticamente con una declaración use v5.16 (o superior) en el ámbito actual.

Expresiones regulares y coincidencia de patrones

m//, pos, qr//, quotemeta, s///, split, study

Funciones numéricas

abs, atan2, cos, exp, hex, int, log, oct, rand, sin, sqrt, srand

Funciones para @ARRAY reales

each, keys, pop, push, shift, splice, unshift, values

Funciones para lista de datos

grep, join, map, qw//, reverse, sort, unpack

Funciones %HASH reales

delete, each, exists, keys, values

Funciones de Entrada y Salida

binmode, close, closedir, dbmclose, dbmopen, die, eof, fileno, flock, format, getc, print, printf, read, readdir, readline, rewinddir, say, seek, seekdir, select, syscall, sysread, sysseek, syswrite, tell, telldir, truncate, warn, write

say sólo está disponible si la característica "say" está habilitada o si está prefijada con CORE::. La característica "say" se activa automáticamente con una declaración use v5.10 (o superior) en el ámbito actual.

Funciones para registros o datos de longitud fija

pack, read, syscall, sysread, sysseek, syswrite, unpack, vec

Funciones para identificadores de archivo, archivos y directorios

-X, chdir, chmod, chown, chroot, fcntl, glob, ioctl, link, lstat, mkdir, open, opendir, readlink, rename, rmdir, select, stat, symlink, sysopen, umask, unlink, utime

Palabras clave relativas al control de flujo de su programa Perl

break, caller, continue, die, do, dump, eval, evalbytes exit, __FILE__, goto, last, __LINE__, next, __PACKAGE__, redo, return, sub, __SUB__, wantarray

break sólo está disponible si se activa la característica experimental "switch" o usando el prefijo CORE::. La característica "switch" feature también habilita las sentencias default, given y when, que están documentadas en "Sentencias Switch" in perlsyn. La característica "switch" feature se activa automáticamente con una declaración use v5.10 (o superior) en el ámbito actual. En Perl v5.14 y anteriores, continue requería de la característica "switch" feature, al igual que las otras palabras clave.

evalbytes sólo está disponible con la característica "evalbytes" feature (vea feature) o si está prefijada con CORE::. __SUB__ sólo está disponible con la característica "current_sub" o si está prefijada con CORE::. Tanto la característica "evalbytes" como la "current_sub" se activan de forma automática con una declaración use v5.16 (o superior) en el ámbito actual.

Palabras clave relacionadas con el ámbito

caller, import, local, my, our, package, state, use

state sólo está disponible si la característica "state" feature está habilitada o si está prefijada con CORE::. La característica "state" feature se activa automáticamente con una declaración use v5.10 (o superior) en el ámbito actual.

Funciones varias

defined, formline, lock, prototype, reset, scalar, undef

Funciones para procesos y grupos de procesos

alarm, exec, fork, getpgrp, getppid, getpriority, kill, pipe, qx//, readpipe, setpgrp, setpriority, sleep, system, times, wait, waitpid

Palabras clave relativas a los módulos Perl

do, import, no, package, require, use

Palabras clave relativas a las clases y orientación a objetos

bless, dbmclose, dbmopen, package, ref, tie, tied, untie, use

Funciones de bajo nivel de sockets

accept, bind, connect, getpeername, getsockname, getsockopt, listen, recv, send, setsockopt, shutdown, socket, socketpair

Funciones de comunicación interprocesos System V

msgctl, msgget, msgrcv, msgsnd, semctl, semget, semop, shmctl, shmget, shmread, shmwrite

Obtener información de usuarios y grupos

endgrent, endhostent, endnetent, endpwent, getgrent, getgrgid, getgrnam, getlogin, getpwent, getpwnam, getpwuid, setgrent, setpwent

Obtener información de la red

endprotoent, endservent, gethostbyaddr, gethostbyname, gethostent, getnetbyaddr, getnetbyname, getnetent, getprotobyname, getprotobynumber, getprotoent, getservbyname, getservbyport, getservent, sethostent, setnetent, setprotoent, setservent

Funciones relacionadas con el tiempo

gmtime, localtime, time, times

Palabras clave que no son funciones

and, AUTOLOAD, BEGIN, CHECK, cmp, CORE, __DATA__, default, DESTROY, else, elseif, elsif, END, __END__, eq, for, foreach, ge, given, gt, if, INIT, le, lt, ne, not, or, UNITCHECK, unless, until, when, while, x, xor

Portabilidad

Perl nació en Unix y por eso puede acceder a todas las llamadas normales del sistema Unix. En entornos no Unix, la funcionalidad de algunas llamadas del sistema Unix pueden no estar disponibles, o los detalles de la funcionalidad disponible pueden diferir ligeramente. Las funciones Perl afectadas por esto son:

-X, binmode, chmod, chown, chroot, crypt, dbmclose, dbmopen, dump, endgrent, endhostent, endnetent, endprotoent, endpwent, endservent, exec, fcntl, flock, 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, open, pipe, readlink, rename, select, semctl, semget, semop, setgrent, sethostent, setnetent, setpgrp, setpriority, setprotoent, setpwent, setservent, setsockopt, shmctl, shmget, shmread, shmwrite, socket, socketpair, stat, symlink, syscall, sysopen, system, times, truncate, umask, unlink, utime, wait, waitpid

Para más información sobre la portabilidad de estas funciones, ver perlport y cualquier otra documentación específica de la plataforma que esté disponible.

Lista de funciones de Perl en orden alfabético

-X IDENTIFICADOR_ARCHIVO
-X EXPR
-X IDENTIFICADOR_DIR
-X

Un test de archivo, donde X es una de las letras listadas abajo. Este operador unario toma un argumento, bien sea un nombre de archivo o un identificador de archivo o de directorio, y comprueba si hay algo de cierto en el archivo asociado. Si el argumento se omite, se prueba $_, excepto para -t, que prueba STDIN. Mientras no se diga lo contrario, se devuelve 1 para verdadero y '' para falso. Si el archivo no existe o no se puede examinar, devuelve undef y actualiza undef and sets $! (errno). A pesar de los nombres graciosos, la precedencia es la misma que cualquier otro operador unario con nombre. El operador puede ser cualquiera de estos:

    -r  Archivo es legible por el uid/gid en vigor.
    -w  Archivo es escribible por el uid/gid en vigor.
    -x  Archivo es ejecutable por el uid/gid en vigor.
    -o  Archivo es propiedad del uid en vigor.

    -R  Archivo es legible por el uid/gid real.
    -W  Archivo es escribible por el uid/gid real.
    -X  Archivo es ejecutable por el uid/gid real.
    -O  Archivo es propiedad del uid real.

    -e  Archivo existe.
    -z  Archivo tiene tamaño cero (está vacío).
    -s  Archivo no tiene tamaño cero (devuelve el tamaño en bytes).

    -f  Archivo es un archivo normal.
    -d  Archivo es un directorio.
    -l  Archivo es un enlace simbólico (falso si los enlaces simbólicos no están
        soportados por el sistema de archivos).
    -p  Archivo es una tubería con nombre (FIFO), o el identificador de archivo es una tubería.
    -S  Archivo es un socket.
    -b  Archivo es un archivo especial por bloques.
    -c  Archivo es un archivo especial de caracteres.
    -t  El identificador está abierto a una tty.

    -u  Archivo tiene puesto el bit setuid.
    -g  Archivo tiene puesto el bit setgid.
    -k  Archivo tiene puesto el bit sticky.

    -T  Archivo es un archivo de texto ASCII o UTF-8 (por una suposición heurística).
    -B  archivo es un archivo "binario" (opuesto de -T).

    -M  Tiempo de arranque del script menos el tiempo de modificación del archivo, en días.
    -A  Lo mismo, para el tiempo de acceso.
    -C  Lo mismo, para el cambio de la fecha del inodo (en Unix, puede diferir en otras
        plataformas)

Ejemplo:

    while (<>) {
        chomp;
        next unless -f $_;  # ignora especiales
        #...
    }

Note que -s/a/b/ no realiza una substitución negada. Al decir -exp($foo), se sigue funcionando como se espera que lo haga: sólo letras sueltas, por detrás de un menos, interpretadas como pruebas de archivos.

Estos operadores están exentos de la regla "se parece a una función" descrita anteriormente. Es decir, un paréntesis de apertura después del operador no influye en que el código que sigue se constituya como el argumento. Poner el paréntesis de apertura antes del operador para separarlo del código que le sigue (esto se aplica únicamente a los operadores con mayor precedencia que los operadores unarios, por supuesto):

    -s($archivo) + 1024   # probablemente mal; lo mismo que -s($archivo + 1024)
    (-s $archivo) + 1024  # correcto

La interpretación de los operadores de permisos de archivo -r, -R, -w, -W, -x y -X es por defecto basado solamente en el modo del archivo y en los uid y gid del usuario. Puede haber otras razones por las que realmente no pueda leer, escribir o ejecutar un archivo: por ejemplo, controles de acceso a sistemas de archivos en red, ACL (listas de control de acceso), sistemas de archivos de solo lectura, y formatos irreconocibles de ejecutables. Note que el uso de seis operadores específicos para verificar si cierta operación es posible, es usualmente una equivocación, porque puede ser el inicio de bloqueos de carrera.

También note que, para el superusuario en el sistema de archivos local, los test -r, -R, -w y -W siempre devuelven 1, y -x y -X devuelven 1 si cualquier bit de ejecución está puesto en el modo del archivo. Los scripts que ejecuta el superusuario pueden necesitar hacer un stat para determinar el modo real del archivo, o temporalmente poner su uid efectivo a otro valor.

Si está usando ACL, hay un pragma que se llama filetest que puede producir resultados más precisos que los simples bits de modo de stat. Cuando esté bajo use filetest 'access', las comprobaciones de archivo mencionadas antes comprobarán cuándo los permisos pueden (o no) ser concedidos usando la familia de llamadas del sistema access(2). Note también que las pruebas -x y -X pueden, bajo este pragma, devolver valores verdaderos incluso si los bits de permiso de ejecución no están puestos (ni cualquier permiso ACL extra de ejecución). Este comportamiento tan extraño es debido a las definiciones subyacentes de las llamadas del sistema. Note también que, debido a la implementación de use filetest 'access', el identificador de archivo especial _ no almacenará los resultados de los test de archivo mientras este pragma esté activo. Para más información, lea la documentación del pragma filetest.

Las pruebas -T y -B funcionan como se explica a continuación. El primer bloque o así del archivo, se examina para ver si es UTF-8 válido, por lo que incluye caracteres no ASCII. Si lo es, es un archivo -T. Se examina el primer bloque (aprox.) del archivo, para buscar caracteres extraños como códigos de control o caracteres con el bit alto activo. Si más de un tercio de los caracteres son extraños, es un archivo -B; de lo contrario es un archivo -T. También, cualquier archivo que contenga un byte cero en la porción examinada se considera que es un archivo binario. (Si se ejecuta dentro del ámbito de un use locale, que incluye LC_CTYPE, caracteres extraños son cualquiera que no sean imprimibles ni espacios en la configuración regional actual). Si -T o -B se usan con un identificador de archivo, la memoria intermedia actual de IO es examinada en vez del primer bloque. Ambos, -T y -B, devuelven verdadero en un archivo vacío o en un archivo en el EOF (marca de fin de archivo) cuando se analiza un identificador de archivo. Debido a que tiene que leer el archivo para hacer el test -T, en la mayoría de las ocasiones querrá usar primero -f, como en next unless -f $archivo && -T $archivo.

Si a cualquiera de los test de archivo (o cualquiera de los operadores stat o lstat) se les da el identificador de archivo especial consistente en un solitario guión bajo, entonces se usa la estructura stat del archivo del test anterior (o el operador stat), ahorrando una llamada del sistema. (Esto no funciona con -t, y necesita recordar que lstat() y -l dejarán valores en la estructura stat del enlace simbólico, no del archivo real). (También, si la memoria intermedia de stat se rellenó con una llamada lstat, -T y -B se reinicializarán con los resultados de stat _). Ejemplo:

    print "Puedo hacerlo.\n" if -r $a || -w _ || -x _;

    stat($nombre_de_archivo);
    print "Leíble\n" if -r _;
    print "Escribible\n" if -w _;
    print "Ejecutable\n" if -x _;
    print "Setuid\n" if -u _;
    print "Setgid\n" if -g _;
    print "Sticky\n" if -k _;
    print "Texto\n" if -T _;
    print "Binario\n" if -B _;

Como en Perl 5.10.0, una dulce forma, puramente sintáctica, puede apilar operadores de test de archivo, de forma que -f -w -x $archivo es equivalente a -x $archivo && -w _ && -f _. (Esto solo es fascinantemente elegante: si usa el valor devuelto de -f $archivo como un argumento para otro operador de test de archivo, no ocurrirá ninguna magia especial)

Cuestiones de portabilidad: "-X" in perlport.

Para no confundir a los posibles usuarios de su código con errores de sintaxis misteriosos, ponga algo como esto en la parte superior de su script:

    use 5.010;  # así, los test de archivo pueden apilarse
abs VALOR
abs

Devuelve el valor absoluto del argumento. Si se omite VALOR, se usa $_.

accept NUEVOSOCKET,SOCKETGENÉRICO

Acepta una conexión socket entrante, como lo hace la llamada del sistema accept(2). Devuelve la dirección empaquetada si ha tenido éxito, de lo contrario, falso. Ver el ejemplo en "Sockets: Comunicación Cliente/Servidor" in perlipc.

En sistemas que soportan el indicador close-on-exec (cerrar en ejecución) en archivos, este indicador se establecerá para el descriptor de archivo abierto más recientemente según lo determinado por el valor de $^F. Ver "$^F" in perlvar.

alarm SEGUNDOS
alarm

Ordena mandar una señal SIGALRM al proceso actual después de que haya pasado el número de segundos especificados. Si no se ha especificado SEGUNDOS, se usará el valor almacenado en $_. (En algunas máquinas, desafortunadamente, el tiempo transcurrido puede ser hasta un segundo más o menos del especificado debido a cómo se cuentan los segundos, y la planificación de procesos puede retrasar incluso más la entrega de la señal).

Sólo un temporizador puede estar contando cada vez. Cada llamada desactiva el temporizador anterior, y se puede indicar un argumento 0 para cancelar el temporizador anterior sin empezar uno nuevo. El valor devuelto es la cantidad de tiempo restante del temporizador anterior.

Para lapsos de tiempo inferiores a un segundo, el módulo Time::HiRes (en CPAN, y a partir de Perl 5.8 como parte de la distribución estándar) ofrece ualarm. Puede también usar la versión de select de cuatro argumentos, dejando los tres primeros indefinidos, o puede usar la interfaz syscall para acceder a setitimer(2) si su sistema lo soporta. Vea perlfaq8 para más detalles.

Normalmente, es un error entremezclar llamadas a alarm y sleep, porque sleep se puede, internamente, implementar en su sistema con alarm.

Si quiere usar alarm para controlar la duración de una llamada del sistema necesita una pareja eval/die. No puede confiar en que la alarma que llama a la llamada del sistema falle y establezca $! a EINTR porque Perl activa controladores de señal para reiniciar llamadas al sistema, en algunos sistemas. Usar eval/die siempre funciona, teniendo en cuenta las advertencias dadas en "Señales" in perlipc.

    eval {
        local $SIG{ALRM} = sub { die "alarma\n" }; # NB: \n necesario
        alarm $timeout;
        my $nread = sysread $socket, $bufer, $largo;
        alarm 0;
    };
    if ($@) {
        die unless $@ eq "alarma\n";   # propagar errores inesperados
        # fin de temporización
    }
    else {
        # no hacer nada
    }

Para más información ver perlipc.

Cuestiones de portabilidad: "alarm" in 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 conocida relación

    sub tan { sin($_[0]) / cos($_[0])  }

El valor de retorno para atan2(0,0) depende de la implementación; consulte su página de manual de atan2(3) para más información.

Cuestiones de portabilidad: "atan2" in perlport.

bind SOCKET,NOMBRE

Enlaza una dirección de red a un socket, como lo hace bind(2). Devuelve verdadero si tiene éxito; de lo contrario, falso. NOMBRE debe ser una dirección empaquetada del tipo apropiado para el socket. Ver los ejemplos en "Sockets: Comunicación Cliente/Servidor" in perlipc.

binmode IDENTIFICADOR_ARCHIVO, CAPA
binmode IDENTIFICADOR_ARCHIVO

Ordena que el modo de lectura o escritura para el IDENTIFICADOR_ARCHIVO sea en "binario" o "texto" en sistemas donde las bibliotecas en tiempo de ejecución distingan entre archivos binarios y de texto. Si IDENTIFICADOR_ARCHIVO es una expresión, el valor es tomado como el nombre del identificador. Devuelve verdadero en caso de éxito; de lo contrario devuelve undef y establece $! (errno).

En algunos sistemas (en general, sistemas basados en DOS y Windows) es necesario usar binmode cuando no esté trabajando con un archivo de texto. Para una mejor portabilidad es siempre una buena idea usarlo cuando sea apropiado, y nunca usarlo cuando no sea apropiado. También, la gente puede establecer su E/S para que esté codificado, por defecto, en Unicode UTF-8, y no en bytes.

En otras palabras: indiferentemente de la plataforma, use binmode en datos binarios, como imágenes, por ejemplo.

Si CAPA está presente es un único string, pero puede contener múltiples directivas. Las directivas alteran el comportamiento del identificador del archivo. Tiene sentido que CAPA esté presente, al usar binmode sobre un archivo de texto.

Si se omite CAPA o se especifica como :raw el identificador se prepara para pasar datos binarios. Esto incluye desactivar posibles traducciones CRLF y marcarlas como bytes (como opuesto a los caracteres Unicode). Note que, a pesar de estar implícito en "Programming Perl" (el dromedario, 3.ª edición) o en otro lugar, :raw no es el simplemente el inverso de :crlf -- otras capas que pudieran afectar la naturaleza binaria del flujo son también desactivadas. Ver PerlIO, perlrun y la discusión sobre la variable de entorno PERLIO.

:bytes, :crlf, :utf8, y cualquier otra directiva de la forma :..., se llaman capas I/O. El pragma open se puede usar para establecer las capas E/S por defecto.

El parámetro CAPA de la función binmode se describe como "DISCIPLINA" en "Programming Perl, 3rd Edition". Sin embargo, desde la publicación de ese libro, conocido por muchos como "Camel III", el consenso sobre el nombre de esta funcionalidad ha cambiado desde "disciplina" a "capa". Toda documentación desde esta versión de Perl se refiere a "capas" en vez de a "disciplinas". Ahora volvamos a la documentación normal...

Para indicar IDENTIFICADOR_ARCHIVO como UTF-8, use :utf8 o :encoding(UTF-8). :utf8 solo marca los datos como UTF-8 sin más comprobaciones ulteriores, mientras que :encoding(UTF-8) comprueba que los datos sean realmente UTF-8 válidos. Más detalles se pueden encontrar en PerlIO::encoding.

En general, binmode se debe llamar después de open pero antes de que cualquier E/S se realice sobre el identificador de archivo. Llamando a binmode, normalmente vaciará cualquier dato pendiente que esté almacenado en la salida (y quizás datos pendientes a la entrada) del identificador de archivo. Una excepción a esto es la capa :encoding que cambia la codificación por defecto del identificador de archivo. La capa :encoding algunas veces necesita ser llamada en mitad del flujo de datos y no lo vacía. :encoding también se coloca, implícitamente, por encima de la capa :utf8 porque Perl, internamente, opera con caracteres Unicode codificados en UTF-8.

El sistema operativo, controladores de dispositivos, bibliotecas C y Perl en tiempo de ejecución conspiran al unísono para permitirle al programador tratar un simple carácter (\n) como el final de línea, independientemente de su representación externa. En muchos sistemas operativos, la representación nativa de un archivo texto coincide con su representación interna, pero en algunas plataformas la representación externa de \n se realiza con más de un carácter.

Todas las variantes de Unix, Mac OS (viejo y nuevo) y los archivos Stream_LF sobre VMS usan un único carácter al final de cada línea en la representación externa del texto (incluso si el carácter único es un RETORNO DE CARRO en el antiguo, pre-Darwin sabor de Mac OS, y un AVANCE DE LÍNEA en los Unix y la mayor parte de los archivos VMS). En otros sistemas como OS/2, DOS y los distintos sabores de MS-Windows, tu programa ve un \n como un simple \cJ, pero es almacenado en los archivos de texto como los dos caracteres \cM\cJ. Esto significa que, si no usa binmode en estos sistemas, las secuencias \cM\cJ en disco se convertirán a \n en la entrada y cualquier \n en tu programa se convertirá de nuevo en \cM\cJ en la salida. Esto es lo que usted quiere hacer para los archivos de texto, pero puede ser desastroso para archivos binarios.

Otra consecuencia de usar binmode (en algunos sistemas) es que las marcas especiales de fin-de-archivo se verán como parte del flujo de datos. Para los sistemas de la familia Microsoft esto significa que si sus datos binarios contienen \cZ, el subsistema de E/S lo considerará como el fin del archivo, a menos que use binmode.

binmode es importante no solo para las operaciones readline y print, sino también cuando se usa read, seek, sysread, syswrite y tell (vea perlport para más detalles). Consulte las variables $/ y $\ en perlvar para ver cómo establecer manualmente sus secuencias de fin de línea en su entrada y salida.

Cuestiones de portabilidad: "binmode" in perlport.

bless REF,NOMBRE_CLASE
bless REF

Esta función dice que la cosa referenciada por REF es ahora un objeto del paquete NOMBRE_CLASE (bless es bendición en inglés, que se podría traducir mejor por bautizar, en el sentido de 'dar un nombre' al objeto). Si se omite NOMBRE_CLASE, se usa el paquete actual. Como un bless a menudo es la última cosa que hace un constructor, devuelve la referencia por conveniencia. Siempre use la versión de dos argumentos si una clase derivada puede heredar el método con una nueva bendición. Vea perlobj para más información sobre la bendición (y las bendiciones) de los objetos.

Considerar siempre bautizar objetos de NOMBRE_CLASE que mezcle mayúsculas y minúsculas. El espacio de nombres en minúsculas se considera reservado para los pragmas de Perl. Los tipos predefinidos tienen todos sus nombres en mayúscula. Para evitar confusiones, evite nombres de paquete también de esta manera. Asegúrese de que NOMBRE_CLASE es un valor verdadero.

Ver "Módulos Perl" in perlmod.

break

Sale de un bloque given.

break solo está disponible si la característica "switch" está activada o si está prefijada con CORE::. La característica "switch" se activa automáticamente con una declaración use v5.10 (o superior) en el ámbito actual.

caller EXPR
caller

Devuelve el contexto de la llamada a la subrutina actual. En contexto escalar, devuelve el nombre del paquete del llamante si aquel es un llamante, es decir, si estamos en una subrutina, eval o require, y el valor indefinido en otro caso. caller nunca devuelve subrutinas XS, y son obviadas. La próxima sub escrita en perl aparecerá en lugar de la sub XS en los valores devueltos por caller. En contexto de lista, devuelve

       # 0         1         2
    my ($paquete, $nombre_archivo, $linea) = caller;

Con EXPR, devuelve alguna información extra que el depurador usa para imprimir un rastreo de la pila. El valor de EXPR indica cuántos marcos de llamada se ha de retroceder antes del actual.

    # 0         1         2       3           4
 my ($paquete, $archivo, $linea, $subrutina, $hasargs,

    #  5          6          7            8       9         10
    $wantarray, $evaltext, $is_require, $hints, $bitmask, $hinthash)
  = caller($i);

Aquí, $subrutina es la función que caller llamó (en lugar de la función que contiene a caller). Note que la $subrutina puede ser (eval) si el marco de llamada no es una llamada a una subrutina, sino un eval. En tal caso, se añaden los nuevos elementos $evaltext y $is_require: $is_require es verdadero si el marco se crea con una sentencia require o use; $evaltext contiene el texto de la sentencia eval EXPR. En particular, para una sentencia eval BLOQUE, $subrutina es (eval), pero $evaltext es indefinido. (Note también que cada instrucción use crea un marco require dentro de un marco eval EXPR). $subrutina puede ser también (unknown) (desconocida) si esta subrutina en particular parece haberse borrado de la tabla de símbolos. $hasargs es verdadero si una nueva instancia de @_ se creó para este marco. $hints y $bitmask contienen detalles para los cuales caller fue compilado. $hints corresponde a $^H, y $bitmask corresponde a ${^WARNING_BITS}. Los valores $hints y $bitmask están sujetos a cambios entre versiones de Perl y no se espera que se utilicen para uso externo.

$hinthash es una referencia a un hash conteniendo el valor de %^H cuando el llamante se ha compilado, o undef si %^H estaba vacío. No modifique los valores de este hash, ya que son los valores reales almacenados en el árbol de operaciones internas.

Además, cuando se le llama desde el interior de un paquete DB en contexto de lista, caller devuelve información más detallada: actualiza la variable @DB::args con los argumentos con los que la subrutina fue invocada.

Cuidado con el optimizador, que puede optimizar marcos de llamada antes de que caller tenga la oportunidad de obtener la información. Eso significa que caller(N) quizás no devuelva información sobre el marco de llamada que espera, para N > 1. En particular, @DB::args podría tener información de la llamada a la anterior llamada a caller.

Tenga en cuenta que fijar @DB::args es el mejor esfuerzo, destinado a la depuración o la generación de seguimientos, y no debería ser invocado. En particular, como @_ contiene los alias de los argumentos de la función llamante, Perl no toma una copia de @_, así que @DB::args contendrá modificaciones que la subrutina hace a @_ o de sus contenidos, no los valores originales a la hora de hacer la llamada. @DB::args, como @_, no incluye referencias explícitas a sus elementos, por lo que en algunos casos sus elementos pueden haberse liberado y reasignado a otras variables o valores temporales. Por último, un efecto secundario de la implementación actual es que los efectos de shift @_ puede, normalmente, deshacerse (pero no pop @_ u otras operaciones de troceado, y tampoco si se ha tomado una referencia a @_, y con la salvedad sobre los elementos reasignados), por lo que @DB::args es realmente un híbrido del estado actual e inicial de @_. Los compradores quedan advertidos.

chdir EXPR
chdir IDENTIFICADOR_ARCHIVO
chdir IDENTIFICADOR_DIR
chdir

Cambia el directorio de trabajo a EXPR, si es posible. Si se omite EXPR, cambia al directorio especificado por $ENV{HOME}, si está puesto; si no, cambia al directorio especificado por $ENV{LOGDIR}. (Bajo VMS, la variable $ENV{'SYS$LOGIN'} también se comprueba y se usa si está inicializada). Si ninguna está puesta, chdir no hace nada, y falla. Devuelve verdadero si tuvo éxito, sino, falso. Vea el ejemplo que está en die.

En sistemas que soportan fchdir(2), puede pasarle un identificador de archivo o un identificador de directorio como argumento. En sistemas que no admiten fchdir(2), pasarle un identificador de archivo lanza una excepción.

chmod LISTA

Cambia los permisos de una lista de archivos. El primer elemento de la lista debe ser un modo numérico, que normalmente estará en octal, y que, definitivamente, no debe ser una cadena de dígitos en octal: 0644 es correcto, "0644" no lo es. Devuelve el número de archivos cambiados con éxito. Vea también /oct si todo lo que tiene es una cadena.

    my $cnt = chmod 0755, "foo", "bar";
    chmod 0755, @ejecutables;
    my $mode = "0644"; chmod $mode, "foo";      # !!! establece modo a
                                                # --w----r-T
    my $modo = "0644"; chmod oct($modo), "foo"; # este es el mejor
    my $mode = 0644;   chmod $mode, "foo";      # este es mejor

En sistemas que soporten fchmod(2), puede pasar identificadores de archivo entre los archivos. En sistemas que no admiten fchmod(2), pasar un identificador de archivo lanza una excepción. Identificadores de archivo se deben pasar como comodines o referencias a comodines para que sean reconocidos; las palabras sueltas se consideran como nombres de archivo.

    open(my $fh, "<", "foo");
    my $permisos = (stat $fh)[2] & 07777;
    chmod($permisos | 0600, $fh);

También puede importar las constantes simbólicas S_I* desde el módulo Fcntl:

    use Fcntl qw( :mode );
    chmod S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH, @ejecutables;
    # Idéntico a chmod 0755 del ejemplo anterior.

Cuestiones de portabilidad: "chmod" in perlport.

chomp VARIABLE
chomp( LISTA )
chomp

Esta versión segura de chop, quita cualquier cadena restante que corresponda al valor actual de $/ (también conocido como $INPUT_RECORD_SEPARATOR -separador de registros en entrada- en el módulo English). Devuelve el número total de caracteres eliminados de todos sus argumentos. Se utiliza a menudo para eliminar el carácter de nueva línea del final de un registro de entrada cuando es importante que el registro al final le pueda faltar ese carácter. En modo párrafo ($/ = ''), elimina todos los caracteres de nueva línea de la cadena. En modo chupón ($/ = undef) o en modo de registros de longitud fija ($/ es una referencia a un entero o algo parecido; ver perlvar), chomp no elimina nada. Si se omite VARIABLE, usa $_. Ejemplo:

    while (<>) {
        chomp;  # evitar \n en el último campo
        my @array = split(/:/);
        # ...
    }

Si VARIABLE es un hash, recorta los valores del hash, pero no sus claves, reiniciando el iterador each durante el proceso.

Puede realmente recortar cualquier cosa que sea un valor-izquierda, incluyendo una asignación:

    chomp(my $cwd = `pwd`);
    chomp(my $respuesta = <STDIN>);

Si recorta una lista, cada elemento es recortado y se devuelve el número total de caracteres eliminados.

Nota que los paréntesis son necesarios cuando esté recortando cualquier cosa que no sea una simple variable. Esto es porque chomp $cwd = `pwd`; es interpretado como (chomp $cwd) = `pwd`;, en vez de un chomp( $cwd = `pwd` ) que es lo que se esperaba. Similarmente, chomp $a, $b es interpretado como chomp($a), $b en vez de un chomp($a, $b).

chop VARIABLE
chop( LISTA )
chop

Recorta el último carácter de un string y devuelve el carácter recortado. Es más eficiente que s/.$//s porque ni escanea ni copia el string. Si se omite VARIABLE, recorta $_. Si VARIABLE es un hash, recorta los valores del hash, pero no sus claves, reiniciando el iterador each durante el proceso.

Puede realmente recortar cualquier cosa que sea un valor-izquierda, incluyendo una asignación.

Si recorta una lista, cada elemento es recortado. Solo se devuelve el valor del último chop.

Note que chop devuelve el último carácter. Para devolver todos menos el último carácter, use substr($string, 0, -1).

Vea también chomp.

chown LISTA

Cambia el propietario (y grupo) de una lista de archivos. Los primeros dos elementos de la lista deben ser el valor numérico del uid y gid, en este orden. Un valor de -1 en cualquier posición es interpretado en la mayoría de los sistemas como que se deja el actual valor sin cambiar. Devuelve el número de archivos cambiados con éxito.

    my $cnt = chown $uid, $gid, 'foo', 'bar';
    chown $uid, $gid, @archivos;

En sistemas que soporten fchown(2), puede pasar identificadores de archivo entre los archivos. En sistemas que no admiten fchown(2), pasar un identificador de archivo lanza una excepción. Identificadores de archivo se deben pasar como comodines o referencias a comodines para que sean reconocidos; las palabras sueltas se consideran como nombres de archivo.

Aquí hay un ejemplo que obtiene el uid numérico a partir del archivo de contraseñas:

    print "Usuario: ";
    chomp(my $usuario = <STDIN>);
    print "Archivos: ";
    chomp(my $patron = <STDIN>);

    my ($login,$pass,$uid,$gid) = getpwnam($usuario)
        or die "$usuario no está en archivo de contraseñas";

    my @ary = glob($patron);   # expande los nombres de los archivos
    chown $uid, $gid, @ary;

En la mayoría de los sistemas, no se le permite cambiar la propiedad del archivo a menos que sea el superusuario, aunque sí pueda cambiar el grupo a cualquiera de sus grupos secundarios. En sistemas inseguros, estas restricciones pueden estar más relajadas, pero no es una suposición normal. En sistemas POSIX, puede detectar esta condición de esta manera:

    use POSIX qw(sysconf _PC_CHOWN_RESTRICTED);
    my $puede_hacer_chown = ! sysconf(_PC_CHOWN_RESTRICTED);

Cuestiones de portabilidad: "chown" in perlport.

chr NÚMERO
chr

Devuelve el carácter representado por NÚMERO en el conjunto de caracteres. Por ejemplo, chr(65) es "A" tanto en ASCII como en Unicode, y chr(0x263a) es una cara sonriente en Unicode.

Valores negativos dan el carácter de reemplazo Unicode (chr(0xfffd)), salvo bajo el pragma bytes, donde se utilizan los ocho bits más bajos del valor (truncado a un entero).

Si se omite NÚMERO, se usa $_.

Para lo contrario, use ord.

Tenga en cuenta que los caracteres de 128 a 255 (inclusive) son, por defecto, internamente no codificados como UTF-8, por razones de compatibilidad hacia atrás.

Vea perlunicode para más información acerca de Unicode.

chroot NOMBRE_ARCHIVO
chroot

Esta funcion trabaja como la llamada del sistema del mismo nombre: hace que el directorio indicado sea el directorio raíz de los siguientes caminos que comiencen por un / en su proceso y todos sus hijos. (No cambia su actual directorio de trabajo actual, que no queda afectado). Por razones de seguridad, esta llamada está reservada al superusuario. Si se omite ARCHIVO, hace un chroot a $_.

NOTA: Es una buena práctica de seguridad hacer chdir("/") (chdir a la raíz del directorio) inmediatamente después de un chroot.

Cuestiones de portabilidad: "chroot" in perlport.

close IDENTIFICADOR_ARCHIVO
close

Cierra el archivo o tubería asociada con el identificador de archivo, limpiando los búfer de E/S, y cierra el descriptor del archivo en el sistema. Devuelve verdadero si las operaciones han tenido éxito y si ningún error fue reportado por alguna capa PerlIO. Cierra el identificador de archivo actualmente seleccionado si se omite el argumento.

No tiene por qué cerrar el IDENTIFICADOR_ARCHIVO si inmediatamente va a hacer otro open sobre él mismo, porque open lo cierra por usted. (Vea open). Sin embargo, un close explícito en un archivo de entrada reinicia el contador de líneas ($.), mientras que un cierre implícito hecho por open, no.

Si el identificador de archivo proviene de una tubería abierta, close adicionalmente devolverá falso si alguna de las otras llamadas del sistema implicadas falla, o si el programa termina con un valor de estado distinto de cero. Si el único problema fue que el programa salió con un valor distinto de cero, $! se establecerá a 0. El proceso de cierre de una tubería también espera por el proceso de ejecución en la tubería antes de salir -en caso de que desee ver después la salida de la tubería- e, implícitamente, pone el valor de estado de salida de ese comando en $? y en ${^CHILD_ERROR_NATIVE}.

Si existen múltiples hilos en ejecución, close sobre un identificador de archivo desde un open entubado, devuelve verdadero sin esperar a que el proceso hijo termine, si el identificador de archivo sigue abierto en otro hilo.

Cerrar la lectura final de una tubería antes de que el proceso de escritura en el otro extremo termine resulta en que el escritor recibe un SIGPIPE. Si en el otro extremo no puede gestionar esto, asegúrese de leer todos los datos antes de cerrar la tubería.

Ejemplo:

    open(OUTPUT, '|sort >foo')  # tubería a sort
        or die "No puedo iniciar sort: $!";
    #...                        # imprimir a la salida
    close OUTPUT                # esperar que sort termine
        or warn $! ? "Error cerrando la tubería sort: $!"
                   : "Estado de salida $? desde sort";
    open(INPUT, 'foo')          # obtener los resultado de sort
        or die "No puedo abrir 'foo' para entrada: $!";

IDENTIFICADOR_ARCHIVO puede ser una expresión cuyo valor se puede usar como un identificador de archivo indirecto, normalmente el nombre real del identificador de archivo o un identificador autovivificado.

closedir IDENTIFICADOR_DIR

Cierra un directorio abierto por opendir y devuelve el éxito de la llamada del sistema.

connect SOCKET,NOMBRE

Intenta conectarse a un socket remoto, al igual que connect(2). Devuelve verdadero si tiene éxito; de lo contrario, falso. NOMBRE debe ser una dirección empaquetada del tipo apropiado para el socket. Ver los ejemplos en "Sockets: Comunicación Cliente/Servidor" in perlipc.

continue BLOQUE
continue

Cuando se sigue por un BLOQUE, continue es realmente una instrucción de control de flujo en lugar de una función. Si existe un BLOQUE continue adjunto a un BLOQUE (típicamente en un while o foreach), siempre se ejecuta justo antes de que la condicional sea de nuevo evaluada, igual que la tercera parte de un bucle for en C. Esto se puede utilizar para incrementar una variable de bucle, incluso cuando el bucle se ha interrumpido por la instrucción next (que es similar a la instrucción continue del C).

last, next o redo pueden aparecer dentro de un bloque continue; last y redo se comporta como si se hubiera ejecutado dentro del bloque principal. También next, pero como ejecutará un bloque continue, quizás se convierta en algo divertido.

    while (EXPR) {
        ### redo siempre viene aquí
        hacer_algo;
    } continue {
        ### next siempre viene aquí
        hacer_algo_despues;
        # entonces regresa arriba a recomprobar la EXPR
    }
    ### last siempre viene aquí

Omitir la sección continue es equivalente a usar un bloque vacío, como es lógico, por lo que next va directamente a comprobar la condición en la parte superior del bucle.

Cuando no hay un BLOQUE, continue es una función que termina el actual bloque when o default en lugar de realizar una iteración del foreach o salir de un given que lo albergue léxicamente. En Perl v5.14 y anteriores, esta forma de continue solo estaba disponible con la característica "switch" feature activada. Vea feature y "Instrucciones switch" in perlsyn para más información.

cos EXPR
cos

Devuelve el coseno de EXPR (expresado en radianes). Si EXPR se omite, devuelve el coseno de $_.

Para la inversa de la operación coseno, puede usar la función Math::Trig::acos, o usar esta relación:

    sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) }
crypt TEXTOPLANO,SALTO

Crea una cadena resumen exactamente igual que la función crypt(3) de la biblioteca C (asumiendo que realmente tenga una versión de la que no haya sido extirpada por ser considerada un arma potencial).

crypt es una función hash de un solo sentido. El TEXTOPLANO y el SALTO se convierten en una pequeña cadena, llamada digest (compendio, resumen), que de devuelve. Los mismos TEXTOPLANO y SALTO siempre devolverán el mismo string, pero no hay una forma (conocida) de obtener el TEXTOPLANO original desde el hash. Pequeños cambios en TEXTPLANO o SALTO resultarán en grandes cambios en el digest.

No existe la función decrypt. Esta función no es muy útil para criptografía (para esto, mire en los módulos Crypt en su espejo CPAN más cercano) y el nombre "crypt" es un poco equívoco. En cambio se usa principalmente para comprobar si dos trozos de textos son el mismo sin tener que transmitirlo o almacenarlo. Un ejemplo es comprobando si se ha dado una contraseña correcta. El digest de una contraseña se almacena, no la propia contraseña. El usuario escribe la contraseña que es en-crypt-tada con el mismo salto con el que se almacenó el digest. Si los dos digest coinciden, la contraseña es correcta.

Cuando verifique una cadena digest debe usar el propio digest como salto (como crypt($plano, $digest) eq $digest). El SALTO usado para crear el digest es visible como parte del digest. Esto asegura que crypt creará el hash de la nueva cadena con el mismo salto que el digest. Esto permite a su código trabajar con el estándar crypt y con implementaciones más exóticas. En otras palabras, no asuma nada sobre la cadena devuelta, ni sobre la cantidad de bytes de SALTO pueden importar.

Tradicionalmente, el resultado es una cadena de 13 bytes: los dos primeros son el salto, seguido de 11 bytes del conjunto [./0-9A-Za-z], y sólo los primeros ocho bytes del digest interesan. Pero esquemas alternativos de cálculo de hash (como MD5), esquemas de seguridad de alto nivel (como C2) e implementaciones en plataformas no UNIX pueden producir cadenas diferentes.

Cuando escoja un nuevo salto cree un string de dos caracteres elegidos aleatoriamente del conjunto [./0-9A-Za-z] (como por ejemplo join '', ('.', '/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]). Este conjunto de caracteres es sólo una recomendación; los caracteres permitidos en el salto dependen solamente de la función crypt del sistema y Perl no puede restringir el salto que crypt acepte.

Aquí hay un ejemplo que se asegura que quien corra el programa conoce su contraseña:

    my $pwd = (getpwuid($<))[1];

    system "stty -echo";
    print "Contraseña: ";
    chomp(my $palabra = <STDIN>);
    print "\n";
    system "stty echo";

    if (crypt($palabra, $pwd) ne $pwd) {
        die "Lo siento...\n";
    } else {
        print "correcto\n";
    }

Naturalmente es muy imprudente dar la propia contraseña a cualquiera que lo pregunte.

La función crypt no es apropiada para calcular el hash de grandes volúmenes de información, teniendo en cuenta que no es posible luego volver a obtener la misma información. Mire en el módulo Digest por algoritmos más robustos.

Si usa crypt en una cadena Unicode (que potencialmente tiene caracteres con códigos de carácter superiores al 255), Perl intenta darle sentido a la situación intentando hacer una degradación (una copia) de la cadena a una cadena de bytes antes de llamar a crypt (sobre esa copia). Si esto funciona, bien. Si no, crypt muere con el mensaje Wide character in crypt.

Cuestiones de portabilidad: "crypt" in perlport.

dbmclose HASH

[Esta función ha sido largamente supeditada por la función untie].

Rompe la ligadura entre un archivo DBM y un hash.

Cuestiones de portabilidad: "dbmclose" in perlport.

dbmopen HASH,NOMBRE_BASE_DATOS,MÁSCARA

[Esta función se ha superado de largo por la función tie].

Liga un archivo dbm(3), ndbm(3), sdbm(3), gdbm(3) o Berkeley DB a un hash. HASH es el nombre del hash. (A diferencia de un open normal, el primer argumento no es un identificador de archivo, aunque lo parezca). NOMBREDB es el nombre de la base de datos (sin la extensión .dir o .pag si las tuviera). Si la base de datos no existe, se crea con la protección especificada por MÁSCARA (y modificada por umask). Para evitar la creación de la base de datos en caso de que no existiera, es posible especificar MODO 0, y la función devolverá un valor falso si no puede encontrar una base de datos existente. Si su sistema sólo soporta las viejas funciones DBM, sólo puede realizar una llamada dbmopen en su programa. En las versiones anteriores de Perl, si su sistema no tiene ni DBM ni ndbm, llamar a dbmopen produce un error fatal; ahora lo reintentará con sdbm(3).

Si no tiene permiso de escritura al archivo DBM, sólo podrá leer las variables hash, pero no asignarlas. Si quiere comprobar si puede escribir, use pruebas de archivo o intente asignar una entrada hash ficticia dentro de un eval para atrapar el error.

Note que las funciones como keys y values pueden devolver listas largas cuando se usan con archivos DBM grandes. Puede preferir usar la función each para iterar sobre archivos DBM grandes. Ejemplo:

    # imprime los desplazamientos en el archivo histórico
    dbmopen(%HIST,'/usr/lib/news/history',0666);
    while (($key,$val) = each %HIST) {
        print $clave, ' = ', unpack('L',$valor), "\n";
    }
    dbmclose(%HIST);

Ver también AnyDBM_File para una descripción más general de los pros y contras de las distintas formas dbm, así como DB_File para ver una implementación particularmente rica.

Puede controlar qué biblioteca DBM usará cargando la biblioteca antes de llamar a dbmopen:

    use DB_File;
    dbmopen(%NS_Hist, "$ENV{HOME}/.netscape/history.db")
        or die "No puedo abrir el archivo histórico del netscape: $!";

Cuestiones de portabilidad: "dbmopen" in perlport.

defined EXPR
defined

Devuelve un valor booleano indicando si EXPR tiene un valor que no sea el valor indefinido undef. Si EXPR no está presente, se comprobará $_.

Muchas operaciones devuelven undef para indicar un error, fin de archivo, error del sistema, variable no inicializada u otras condiciones excepcionales. Esta función le permite distinguir undef de otros valores. (Un simple test booleano no distinguirá entre undef, cero, la cadena vacía y "0", que son todos iguales a falso). Note que como undef es un escalar válido, su presencia no indica necesariamente una condición excepcional: pop devuelve undef cuando su argumento es un array vacío, o cuando el elemento a devolver sea un undef.

Puede usar también defined(&func) para comprobar si la subrutina func se ha definido. No se afecta el valor devuelto debido a ninguna declaración posterior de func. Una subrutina que no se ha definido puede aún así ejecutarse: su paquete puede tener un método AUTOLOAD que la hace aparecer la primera vez que es llamada; ver perlsub.

Se desaconseja el uso de defined sobre datos agregados (hashes y arrays). Se usó para informar si la memoria para los datos agregados se había reservado. Este comportamiento puede desaparecer en futuras versiones de Perl. Utilize en su lugar una comprobación de tamaño:

    if (@un_array) { print "tiene elementos array\n"  }
    if (%a_hash)   { print "el hash tiene miembros\n" }

Cuando se usa con un elemento de un hash, le indica si el valor está definido, no si la clave existe en el hash. Use exists para este propósito.

Ejemplos:

    print if defined $switch{D};
    print "$valor\n" while defined($valor = pop(@ary));
    die "No puedo enlazar simbólicamente con $sym: $!"
        unless defined($valor = readlink $sym);
    sub foo { defined &$bar ? $bar->(@_) : die "No bar"; }
    $debugging = 0 unless defined $debugging;

Nota: mucha gente tiende a sobrevalorar defined y, para su sorpresa, descubren que el número 0 y "" (la cadena de longitud cero) son, de hecho, valores definidos. Por ejemplo, si escribe

    "ab" =~ /a(.*)b/;

El patrón de búsqueda tiene éxito y $1 está definida, aunque no ha correspondido con "nada". No ha fallado al corresponder con cualquier cosa. Más bien, ha coincidido con algo que parece tener cero caracteres de longitud. Todo esto trata sobre la honradez. Cuando una función devuelve un valor indefinido, se asume que no puede dar una respuesta honrada. Así que puede usar defined sólo cuando está cuestionando la integridad de lo que está intentando hacer. En otras ocasiones, una simple comparación con 0 o "" es lo que necesita.

Vea también undef, exists, ref.

delete EXPR

Dada una expresión que especifica un elemento o una porción de un hash, delete elimina los elementos especificados de este hash de tal forma que exists en ese elemento ya no devuelve verdadero. Poner un elemento hash al valor indefinido no elimina su clave, pero eliminándolo sí que lo hace; vea exists.

En contexto de lista, devuelve el valor o los valores borrados, o el último elemento de este tipo en contexto escalar. La longitud de la lista devuelta siempre coincide con el de la lista de argumentos: eliminar elementos no existentes devuelve el valor indefinido en sus posiciones correspondientes.

delete se puede usarse también en array y porciones de array, pero su comportamiento es menos claro. Aunque exists devolverá falso para entradas eliminadas, eliminar elementos del array nunca cambia los índices de los valores existentes; use en su lugar shift o splice. Sin embargo, si cualquiera de los elementos eliminados están al final de un array, el tamaño del array se reduce al de la posición del elemento más alto que aún devuelva verdadero para exists, o 0 si no hay ninguno. En otras palabras, un array no tendrá elementos inexistentes al final, después de un delete.

AVISO: Se desaconseja fuertemente llamar a delete en valores de array. La noción de borrar o comprobar la existencia de elementos de arrays de Perl no es conceptualmente coherente, y puede llevar a un comportamiento sorprendente.

Borrar elementos de %ENV modifica el entorno. Borrando de un hash atado a un archivo DBM, borra esa entrada del archivo DBM. Borrando de un hash o array tied (atado) no necesariamente devolverá algo; depende de la implementación del método DELETE en el paquete tied, que puede hacer lo que quiera.

La construcción delete local EXPR localiza la eliminación al actual bloque en tiempo de ejecución. Hasta que un bloque termine, los elementos locales suprimidos, temporalmente, ya no existen. Ver "Eliminación local de elementos de tipos compuestos" in perlsub.

    my %hash    = (foo => 11, bar => 22, baz => 33);
    my $escalar = delete $hash{foo};        # $escalar es 11
    $escalar = delete @hash{qw(foo bar)};     # $escalar es 22
    my @array   = delete @hash{qw(foo baz)};  # @array es (undef,33)

Lo siguiente borra (ineficientemente) todos los valores de %HASH y @ARRAY:

    foreach my $clave (keys %HASH) {
        delete $HASH{$clave};
    }

    foreach my $indice (0 .. $#ARRAY) {
        delete $ARRAY[$indice];
    }

Así como estos:

    delete @HASH{keys %HASH};

    delete @ARRAY[0 .. $#ARRAY];

Pero estos métodos son más lentos que simplemente asignar una lista vacía o indefinir %HASH o @ARRAY, que es la forma normal de vaciar un agregado:

    %HASH = ();     # vaciar completamente %HASH
    undef %HASH;    # hacer que %HASH nunca existió

    @ARRAY = ();    # vaciar completamente @ARRAY
    undef @ARRAY;   # hacer que @ARRAY nunca existió

La EXPR puede ser tan arbitrariamente complicada con tal de que el final de la operación sea un elemento o una porción de un agregado:

    delete $ref->[$x][$y]{$clave};
    delete @{$ref->[$x][$y]}{$clave1, $clave2, @masclaves};

    delete $ref->[$x][$y][$indice];
    delete @{$ref->[$x][$y]}[$indice1, $indice2, @masindices];
die LISTA

die lanza una excepción. Dentro de un eval, el mensaje de error se coloca en $@ y el eval termina con el valor undef (indefinido). Si la excepción está fuera de un eval, entonces la excepción no capturada imprime LISTA al STDERR y sale con un valor no nulo. Si necesita terminar el proceso con un valor de salida específico, vea exit.

Ejemplos equivalentes:

    die "No puedo cd a spool: $!\n" unless chdir '/usr/spool/news';
    chdir '/usr/spool/news' or die "No puedo entrar en spool/: $!\n"

Si el último elemento de LISTA no acaba en el carácter de nueva línea, se imprimen también el valor actual del número de línea y el actual número de línea de entrada (si existe), junto con un carácter de nueva línea. Note que el "número de línea de entrada" (también conocido como "chunk" -tarugo-) está sujeto a cualquier noción de "línea" que sea efectiva en ese momento, y también está disponible en la variable especial $.. Ver "$/" in perlvar y "$." in perlvar.

Consejo: algunas veces añadir ", parado" a tu mensaje hará aparecerle con un sentido mejor cuando se le añada la cadena "at foo line 123". Suponga que está corriendo el script "canasta".

    die "/etc/games no está bien";
    die "/etc/games no está bien, parado";

produce, respectivamente

    /etc/games no está bien at canasta line 123.
    /etc/games no está bien, parado at canasta line 123.

Si la salida está vacía y $@ ya contiene un valor (típicamente de un eval() anterior) este valor se utiliza después de añadirle "\t...propagated". Esto es útil para propagar excepciones:

    eval { ... };
    die unless $@ =~ /Expected exception/;

Si la salida está vacía y $@ contiene una referencia a un objeto que tiene un método PROPAGATE, éste método se llamará con los parámetros adicionales del archivo y número de línea. El valor de retorno reemplaza el valor en $@; es decir, como si se ejecutara $@ = eval { $@->PROPAGATE(__FILE__, __LINE__) };.

Si $@ está vacío entonces se usa la cadena "Died".

Si se produce una excepción no detectada en la salida del intérprete, el código de salida se determina a partir de los valores de $! y $? con este pseudocódigo:

    exit $! if $!;              # errno
    exit $? >> 8 if $? >> 8;    # estado de salida del hijo
    exit 255;                   # último recurso

Cuando se llega a exit, se establece $? antes de que se desmantele la pila de llamadas; cualquier gestor DESTROY o END puede entonces alterar este valor, y así, el código de salida de Perl.

La intención es comprimir la mayor información posible sobre la causa probable en el limitado espacio del código de salida del sistema. Sin embargo, como $! es el valor de C de errno, que se puede establecer por cualquier llamada al sistema, esto significa que el valor del código de salida utilizada por die puede no ser predecible, por lo que no debe confiarse en él, aparte de cuando sea distinto de cero.

También puede llamar a die con una referencia como argumento, y si éste queda atrapado en un eval, $@ contiene esa referencia. Esto permite un manejo de las excepciones más elaborado que usando objetos que mantengan un estado arbitrario sobre la naturaleza de la excepción. Tal esquema es algunas veces preferible a emparejar ciertas cadenas de valores de $@ usando expresiones regulares. Dado que $@ es una variable global y eval se puede usar dentro de las implementaciones de objetos, tenga el cuidado que al analizar el objeto error no sustituya la referencia en la variable global. Es más fácil hacer una copia local de la referencia antes de cualquier manipulación. Aquí hay un ejemplo:

    use Scalar::Util "blessed";

    eval { ... ; die Some::Module::Exception->new( FOO => "bar" ) };
    if (my $ev_err = $@) {
        if (blessed($ev_err)
            && $ev_err->isa("Algún::Módulo::Excepción")) {
            # gestionar Algún::Módulo::Excepción
        }
        else {
            # gestionar todas las otras posibles excepciones
        }
    }

Como Perl convertirá en cadena de caracteres los mensajes de excepción no capturados antes de mostrarlos, quizás quiera sobrecargar las operaciones de conversión a cadena en objetos de excepción. Ver overload para los detalles sobre esto.

Puede disponer que una retrollamada se ejecute antes de que die haga sus funciones, actualizando el enganche $SIG{__DIE__}. El identificador de archivo asociado es llamado con el texto del error y puede cambiar el mensaje de error, si le parece, llamando de nuevo a die. Ver "%SIG" in perlvar para los detalles sobre cómo colocar entradas %SIG y eval para algunos ejemplos. Aunque esta característica está preparada para ser ejecutada sólo antes de que el programa termine, así no es cómo se hace ahora: el enganche $SIG{__DIE__}, ¡se llama incluso desde dentro de cadenas y bloques evaluados! Si uno quiere que el enganche no haga nada en estas situaciones, ponga

    die @_ if $^S;

como primera línea del controlador (ver "$^S" in perlvar). Debido a que provoca una acción extraña a gran distancia, este comportamiento no intuitivo se puede arreglar en una distribución futura.

Ver también exit, warn y el módulo Carp.

do BLOQUE

No es realmente una función. Devuelve el valor del último comando en la secuencia de comandos indicada por BLOQUE. Cuando se encuentra acompañado por los modificadores de bucle while o until, ejecuta el BLOQUE una vez antes de comprobar la condición del bucle. (En otras instrucciones los modificadores de bucle comprueban primero la condición).

do BLOQUE no cuenta como un bucle, así que las instrucciones de control de bucle next, last, o redo no se pueden usar para dejar o reiniciar el bloque. Ver perlsyn para estrategias alternativas.

do EXPR

Usa el valor de EXPR como el nombre de un archivo y ejecuta los contenidos del archivo como un script Perl.

    do 'stat.pl';

es mayormente como

    eval `cat stat.pl`;

excepto que es más conciso, no ejecuta procesos externos, mantiene el seguimiento del nombre del archivo actual en los mensajes de error, busca en los directorios @INC y actualiza %INC si se encuentra al archivo. Vea "@INC" in perlvar y "%INC" in perlvar para encontrar información sobre estas variables. También difiere en que el código evaluado con do ARCHIVO no puede ver a las variables léxicas en el ámbito en que se ejecuta; eval STRING sí. Es lo mismo, sin embargo, en que vuelve a interpretar el archivo cada vez que lo llama, así que, probablemente, no querrá hacer esto dentro de un bucle.

Si do puede leer el archivo pero no puede compilarlo, devuelve undef y pone un mensaje de error en $@. Si do no puede leer el archivo, devuelve undef y pone $! al valor del error. Siempre revise $@ en primer lugar, la compilación puede fallar de una manera que también se establezca $!. Si el archivo se compila bien, do devuelve el valor de la última expresión evaluada.

La inclusión de bibliotecas de módulos es mejor hacerla con los operadores use y require, que también hacen una comprobación automática de errores y generan una excepción si existe algún problema.

Puede usar do para leer en un programa un archivo de configuración. Comprobación manual de errores se puede hacer así:

    # leer en archivos de configuración: primero el sistema, luego el usuario
    for $archivo ("/share/prog/defaults.rc",
               "$ENV{HOME}/.algunprogramarc")
    {
        unless ($devuelve = do $archivo) {
            warn "no puedo interpretar $archivo: $@" if $@;
            warn "no puedo ejecutar $archivo: $!"    unless defined $devuelve;
            warn "no puedo ejecutar $archivo"        unless $devuelve;
        }
    }
dump ETIQUETA
dump EXPR
dump

Esta función provoca un volcado inmediato del núcleo de ejecución. Ver también la opción de línea de comando -u en perlrun, que hace lo mismo. Principalmente esto se utiliza en conjunción con el programa undump (no suministrado) para convertir tu volcado del núcleo en un binario ejecutable después de haber inicializado todas las variables al comienzo del programa. Cuando se ejecuta el nuevo binario, comenzará ejecutando un goto ETIQUETA (con todas las restricciones que goto padece). Piense en él como un goto entre un volcado del núcleo y una reencarnación. Si se omite ETIQUETA, reinicia el programa desde el principio. La forma dump EXPR, disponible a partir de Perl 5.18.0, permite que un nombre sea computado en tiempo de ejecución o, de lo contrario, es idéntico a dump LABEL.

ATENCIÓN: Cualquier archivo abierto en el momento del volcado no será abierto mas que cuando el programa sea reencarnado, con una muy posible confusión por parte de Perl.

Esta función es obsoleta desde hace mucho tiempo, en parte porque es muy difícil convertir un volcado del núcleo en un ejecutable. Y es por esto que debe invocarlo como CORE::dump(), si no quiere recibir un aviso de que posiblemente ha cometido una falta ortográfica.

A diferencia de otros operadores con nombre, tiene la misma precedencia que una asignación. También está exenta de la regla se-parece-a-una-función, así que dump ("foo")."bar" hará que "bar" sea parte del argumento a dump.

Cuestiones de portabilidad: "dump" in perlport.

each HASH
each ARRAY

Cuando se llama en un hash en contexto de lista, devuelve una lista de dos elementos consistentes en la clave y el valor del siguiente elementos del hash. En Perl 5.12 y superiores, también devolverá el índice y el valor del siguiente elemento de un array, de modo que puede iterar sobre él; Perl más antiguos consideran esto como un error de sintaxis. Cuando se le llama en contexto escalar, sólo devuelve la clave (no el valor) del hash, o el índice del array.

Las entradas de un hash son devueltas en un aparente orden aleatorio. El orden aleatorio real es específico a un hash dado; las mismas series de operaciones en dos hashes pueden resultar en diferentes órdenes para cada hash. Cualquier inserción en el hash puede cambiar el orden, así como cualquier eliminación, con la excepción de que la clave más reciente devuelta por each o keys se puede borrar sin que cambie el orden. Siempre y cuando no se modifique un determinado hash puede confiar en que keys, values y each devuelvan repetidamente lo mismo en el mismo orden. Vea "Ataques de complejidad algorítmica" in perlsec para los detalles de por qué el orden en un hash se aleatoriza. Aparte de las garantías proporcionadas aquí los detalles exactos de algoritmo que usa Perl para recorrer un hash está sujeto a cambio en cualquier lanzamiento de Perl.

Después de que each haya devuelto todas las entradas del hash o del array, la siguiente llamada a each devuelve la lista vacía, en contexto lista, y undef en contexto escalar; la siguiente llamada a ésa reiniciará la iteración. Cada hash o array tiene su propio iterador interno, accedido por each, keys, y values. El iterador es implícitamente restablecido cuando each ha llegado al final como se acaba de describir; puede ser explícitamente restablecido llamando a keys o values sobre el hash o array. Si añade o borra un elemento de un hash mientras está iterando sobre él, el efecto sobre el iterador no está especificado; por ejemplo, puede encontrarse con entradas desaparecidas o duplicadas, así que, es mejor que no lo haga. Excepción: siempre es seguro borrar el último elemento devuelto por each, por lo que entonces el siguiente código funcionará correctamente:

    while (my ($clave, $valor) = each %hash) {
        print $clave, "\n";
        delete $hash{$clave};   # Esto es seguro hacerlo
    }

Hash enlazados pueden tener un comportamiento de ordenación diferente a la implementación de los hashes de perl.

Esto imprime su entorno como el programa printenv(1), sólo que en un orden diferente:

    while (my ($clave,$valor) = each %ENV) {
        print "$clave=$valor\n";
    }

A partir de 5.14, una característica experimental permitía a each tomar una espresión escalar. Se ha considerado que este experimento no ha funcionado, y se eliminó a partir de Perl 5.24.

A partir de Perl 5.18 puede usar un simple each en un bucle while, que actualizará $_ en cada iteración.

    while (each %ENV) {
        print "$_=$ENV{$_}\n";
    }

Para no confundir a los posibles usuarios de su código, que ejecuten versiones anteriores de Perl, con errores de sintaxis misteriosos, ponga este tipo de cosas en la parte superior de su archivo para indicar que el código funciona sólo en versiones Perl de cosechas recientes:

    use 5.012;  # así keys/values/each trabajan sobre arrays
    use 5.018;  # para que each actualice $_ en un test de un while

Vea también keys, values y sort.

eof IDENTIFICADOR_ARCHIVO
eof ()
eof

Devuelve 1 si la siguiente lectura sobre IDENTIFICADOR_ARCHIVO devolverá un fin-de-archivo, o si IDENTIFICADOR_ARCHIVO no está abierto. IDENTIFICADOR_ARCHIVO puede ser una expresión cuyo valor da el identificador de archivo real. (Note que esta función realmente lee un carácter y luego hace un ungetc, así que no es útil en un contexto interactivo). No lea de un archivo del que se ha llegado al final (o vuelva a llamar a eof(IDENTIFICADOR_ARCHIVO) sobre él) después de haber alcanzado un fin-de-archivo. Tipos de archivos como por ejemplo terminales pueden perder la condición de fin-de-archivo si lo hace.

Un eof sin argumento usa el último archivo leído. Usar eof() con paréntesis vacíos es diferente. Se refiere a un pseudo archivo formado por los archivos listados en la línea de comandos y accedidos vía el operador <>. Como <> no es explícitamente abierto, como lo sería un identificador de archivo, un eof() antes de que se use un <>, causará que se examine @ARGV para determinar si la entrada está disponible. De forma semejante, un eof() después de que un <> haya devuelto un fin-de-archivo asumirá que está procesando otra lista @ARGV, y si no ha establecido un nuevo @ARGV, leerá la entrada desde STDIN; vea "Operadores E/S" in perlop.

En un bucle while (<>), eof o eof(ARGV) pueden usarse para detectar el fin de un archivo, mientras que eof() sólo detectará el final del último archivo. Ejemplos:

    # reiniciar el numerado de líneas en cada archivo de entrada
    while (<>) {
        next if /^\s*#/;  # salta los comentarios
        print "$.\t$_";
    } continue {
        close ARGV if eof;  # ¡No eof()!
    }

    # inserta guiones justo antes de la última línea del último archivo
    while (<>) {
        if (eof()) {  # check for end of last file
            print "--------------\n";
        }
        print;
        last if eof();     # necesario si estamos leyendo de una terminal
    }

Truco práctico: casi nunca necesita usar eof en Perl, porque los operadores de entrada normalmente devuelven undef cuando no hay más datos, o si se produce un error.

eval EXPR
eval BLOQUE
eval

En la primera forma, a menudo referido como una "evaluación de cadena de caracteres", el valor devuelto por EXPR es interpretado y ejecutado como si fuera un pequeño programa Perl. El valor de la expresión (que es en sí mismo determinada en contexto escalar) es primero interpretada, y si no hay ningún error, ejecutada como un bloque dentro del contexto léxico del actual programa Perl. Esto significa que, en particular, cualquier otra variable léxica externa es visible dentro de ella, y la configuración de variable de paquete o de subrutinas y las definiciones de formato siguen permaneciendo.

Note que el valor se interpreta cada vez que se ejecuta eval. Si se omite EXPR, se usa $_. Esta forma se usa típicamente para retrasar el interpretado subsecuente ejecución del texto de EXPR hasta el momento de la ejecución.

Si la característica "unicode_eval" está habilitada (que lo es por defecto con una declaración use 5.16 o superior), EXPR o $_ se tratan como una cadena de caracteres, así que las declaraciones use utf8 no tienen efecto, y los filtros de código fuente quedan prohibidos. En ausencia de la característica "unicode_eval" feature, la cadena se tratará a veces como caracteres y otras veces como bytes, dependiendo de la codificación interna, y los filtros de código fuente activados dentro de eval muestran el comportamiento errático, pero histórico, de afectar a algún archivo externo que todavía se está compilando. Vea también la palabra clave evalbytes, que siempre trata su entrada como un flujo de bytes y funciona correctamente con filtros de código fuente, y el pragma feature.

Los problemas pueden surgir si la cadena de caracteres expande a un escalar conteniendo un número en punto flotante. El escalar se puede expandir a letras, como en "NaN" o "Infinity"; o, dentro del ámbito de un use locale, el punto decimal puede ser otra cosa cualquiera aparte de un punto (como una coma). Es muy posible que ninguno de estos se interpreten como se espera.

En la segunda forma, el código en el interior de BLOQUE se interpreta sólo una vez, -al mismo tiempo que el código que rodea al propio eval es interpretado-, y se ejecuta dentro del contexto del actual programa Perl. Esta forma es típicamente usada para atrapar excepciones más eficientemente que la primera forma (ver arriba), mientras que también provee del beneficio de comprobar el código dentro del BLOQUE en tiempo de compilación.

El último punto y coma, si lo hay, puede ser omitido del valor de EXPR o dentro de BLOQUE.

En ambas formas, el valor devuelto es el valor de la última expresión evaluada dentro del mini-programa; una instrucción return se puede usar también, como si fuera una subrutina. La expresión que da el valor de retorno se evalúa en contexto vacío (void), escalar o lista, dependiendo del contexto en que se encuentre el eval. Ver wantarray para saber cómo determinar el contexto de la evaluación.

Si hay algún error de sintaxis o en tiempo de ejecución, o se ejecuta una instrucción die, eval devuelve undef en contexto escalar o una lista vacía en contexto lista, y $@ se inicializa al mensaje de error. (Antes de 5,16, un error causaba que undef era devuelto en contexto de lista para errores de sintaxis, pero no para errores en tiempo de ejecución). Si no hay errores, se garantiza que $@ será una cadena vacía. Un operador de control de flujo como last o goto puede pasar por alto el valor de $@. Tenga cuidado porque usar eval ni silencia a Perl a la hora de imprimir avisos al STDERR, ni rellena el texto de los mensajes de aviso dentro de $@. Para hacer cualquiera de estas dos cosas debe usar $SIG{__WARN__}, o desactivar los avisos dentro del BLOQUE o EXPR usando no warnings 'all'. Vea warn, perlvar, y warnings.

Note que, como eval atrapa errores considerados fatales, es útil para determinar cuándo una característica en particular (como socket o symlink) está implementada. También es el mecanismo de captura de excepciones de Perl, donde el operador die se usa para levantar excepciones.

Si desea capturar los errores cuando se carga un módulo XS, algunos problemas con la interfaz binaria (como el sesgo de versión de Perl) puede ser fatal, incluso con eval a menos que esté establecido $ENV{PERL_DL_NONLAZY}. Vea perlrun.

Si el código a ser ejecutado no varía, puede usar la forma BLOQUE de eval para atrapar errores en tiempo de ejecución sin incurrir en la penalidad de recompilar cada vez. El error, si hay alguno, se devuelve en $@. Ejemplos:

    # hace la división-por-cero no fatal
    eval { $respuesta = $a / $b; }; warn $@ if $@;

    # lo mismo, pero menos eficiente
    eval '$respuesta = $a / $b'; warn $@ if $@;

    # un error en tiempo de compilación
    eval { $respuesta = }; # MAL

    # un error en tiempo de ejecución
    eval '$respuesta =';   # actualiza $@

Usar la forma eval {} como una trampa de excepciones en bibliotecas puede traer algunos problemas. Debido al posible mal estado de la llamada __DIE__, quizás deseé no activar ninguna de las llamadas __DIE__ que el código de usuario puede haber instalado. Puede usar la construcción local $SIG{__DIE__} para este propósito, como muestra este ejemplo:

    # un trampa privada para una excepción de división-por-cero
    eval { local $SIG{'__DIE__'}; $respuesta = $a / $b; };
    warn $@ if $@;

Esto es especialmente significativo, dado que las llamadas __DIE__ pueden llamar de nuevo a die, que tiene el efecto de cambiar los mensajes de error:

    # llamadas __DIE__ pueden modificar los mensajes de error
    {
       local $SIG{'__DIE__'} =
              sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x };
       eval { die "foo vive aquí" };
       print $@ if $@;                # imprime "bar vive aquí"
    }

Debido a que provoca una acción extraña a gran distancia, este comportamiento no intuitivo se puede arreglar en una futura distribución.

Dentro de eval, debe, especialmente, recordar qué es lo que está haciendo en cada momento:

    eval $x;        # CASO 1
    eval "$x";      # CASO 2

    eval '$x';      # CASO 3
    eval { $x };    # CASO 4

    eval "\$$x++";  # CASO 5
    $$x++;          # CASO 6

Los casos 1 y 2 se comportan idénticamente: ejecutan el código contenido en la variable $x. (Aunque el caso 2 tiene unas engañosas dobles comillas haciendo maravillar al lector de qué es lo que puede pasar -que es nada-). Los casos 3 y 4 se comportan de la misma manera: ejecutan el código '$x', que no hace nada excepto devolver el valor de $x. (El caso 4 es el preferido por razones puramente visuales, pero también tiene la ventaja de la compilación en tiempo de compilación en lugar de en tiempo de ejecución). Caso 5 es aquel donde normalmente debería usar dobles comillas, excepto que en esta situación en particular, puede usar en su lugar referencias simbólicas, como en el caso 6.

Antes de Perl 5.14, la asignación a $@ ocurría antes de la restauración de las variables localizadas, lo que significa que su código, al ejecutarse en versiones anteriores, requería de una variable temporal si deseaba enmascarar algunos pero no todos los errores:

    # altera $@ solo en una infame repugnancia
    {
       my $e;
       {
         local $@; # proteger el actual $@
         eval { test_repugnancia() };
         # $@ =~ /infame/ and die $@; # sólo en Perl 5.14 y superiores
         $@ =~ /infame/ and $e = $@;
       }
       die $e if defined $e
    }

eval BLOQUE no cuenta como un bucle, así que las instrucciones de control de bucle next, last, o redo no se pueden usar para dejar o reiniciar el bloque.

Un eval '' ejecutado dentro de una subrutina definida en el paquete DB no ve el usual ámbito léxico circundante, sino más bien el ámbito de la primera parte del código no-DB que le llamó. No necesita preocuparse de esto a menos que esté escribiendo un depurador Perl.

evalbytes EXPR
evalbytes

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 contenga caracteres cuyo valor ordinal supere el 255 resulta en un error. Los filtros de código fuente activados dentro del código evaluado se aplican al propio código.

evalbytes sólo está disponible si la característica "evalbytes" (vea feature) está activada o si está prefijada con CORE::. La característica "evalbytes" se activa automáticamente con una declaración use v5.16 (o superior) en el ámbito actual.

exec LISTA
exec PROGRAMA LISTA

La función exec ejecuta un comando del sistema y nunca regresa; use system en lugar de exec si quiere que regrese. Fallará y devolverá falso sólo si el comando no existe y se ejecuta directamente en lugar de hacerlo con el shell de comandos del sistema (ver abajo).

Como es un error frecuente usar exec en lugar de system, Perl le avisará si se llama a exec en contexto vacío, y si hay alguna instrucción a continuación que no sea die o warn o exit (si warnings está activado -pero usted, siempre lo tiene así, ¿verdad?-). Si verdaderamente quiere continuar un exec con otra instrucción, puede usar algunas de estas formas para evitar el aviso:

    exec ('foo')   or print STDERR "no puedo exec foo: $!";
    { exec ('foo') }; print STDERR "no puedo exec foo: $!";

Si hay más de un argumento en LISTA, se llama a execvp(3) con los argumentos de LISTA. Si sólo hay un elemento en la LISTA, se comprueba si el argumento tiene metacaracteres shell, y si lo hay, el argumento entero es pasado al shell de comandos para que interpretarse (suele ser /bin/sh -c en plataformas Unix, pero varía en otras). Si no hay metacaracteres shell en el argumento, se divide en palabras y pasadas directamente a execvp, que es más eficiente. Ejemplos:

    exec '/bin/echo', 'Tus argumentos son: ', @ARGV;
    exec "sort $salida | uniq";

Si de verdad no quiere ejecutar el primer argumento, pero quiere engañar al programa que está ejecutando sobre su propio nombre, puede especificar el programa que realmente quiere ejecutar como un "objeto indirecto" (sin la coma) enfrente de la LISTA, como en exec PROGRAMA LISTA. (Esto siempre fuerza la interpretación de la LISTA como una lista multievaluada, incluso si sólo hay un único escalar en la lista). Ejemplo:

    my $shell = '/bin/csh';
    exec $shell '-sh';    # finge que es un shell de login

o, más directamente,

    exec {'/bin/csh'} '-sh';  # finge que es un shell de login

Cuando los argumentos se ejecutan por medio del shell del sistema, los resultados están sujetos a sus peculiaridades y capacidades. Ver "`STRING`" in perlop para los detalles.

Usar un objeto indirecto con exec o system es también más seguro. Este uso (que también funciona bien con system) fuerza la interpretación de los argumentos como una lista multievaluada, incluso si la lista sólo tiene un argumento. De esta forma estará protegido de la expansión de los comodines del shell o de la división en palabras con un espacio en blanco dentro de ellas.

    my @args = ( "echo sorpresa" );

    exec @args;                 # sujeto al escapado shell
                                # si @args == 1
    exec { $args[0] } @args;    # seguro incluso con una lista de un argumento

La primera versión, sin el objeto indirecto, ejecuta el programa echo, pasándole "sorpresa" como argumento. La segunda versión no; intentó ejecutar un programa llamado, literalmente, "echo sorpresa"; no lo encontró, y estableció $? a un valor distinto de cero para indicar error.

En Windows, solo la sintaxis de objetos indirecto en exec PROGRAMA LISTA evitará, de forma efectiva, evitar usar la shell; exec LISTA, incluso con más de un elemento, volverá a usar la shell si falla el primer intento de lanzamiento.

Perl intenta vaciar todos los archivos abiertos para salida antes de ejecutar exec, pero esto puede no estar soportado en algunas plataformas (vea perlport). Para estar seguros, puede necesitar establecer $| ($AUTOFLUSH en el módulo English) o llamar el método autoflush de IO::Handle en cualquiera de los identificadores de archivo abiertos para evitar la pérdida de datos en la salida.

Note que exec no llamará a sus bloques END, ni llamará a ningún método DESTROY de sus objetos.

Cuestiones de portabilidad: "exec" in perlport.

exists EXPR

Dada una expresión que especifica un elemento de un hash, devuelve verdadero si el elemento especificado en el hash se ha inicializado, incluso si el correspondiente valor está indefinido.

    print "Existe\n"    if exists  $hash{$clave};
    print "Definido\n"  if defined $hash{$clave};
    print "Verdadero\n" if $hash{$clave};

exists también puede llamarse sobre elementos de array, pero su comportamiento es mucho menos evidente, y está fuertemente ligado a la utilización de delete en arrays.

AVISO: Se desaconseja fuertemente llamar a exists en valores de array. La noción de borrar o comprobar la existencia de elementos de arrays de Perl no es conceptualmente coherente, y puede llevar a un comportamiento sorprendente.

    print "Existe\n"    if exists  $array[$indice];
    print "Definido\n"  if defined $array[$indice];
    print "Verdadero\n" if $array[$index];

Un elemento de un hash o de un array puede ser verdadero sólo si está definido, y está definido solo si ya existe, pero lo inverso no es necesariamente cierto.

Dada una expresión que especifica el nombre de una subrutina, devuelve verdadero si la subrutina especificada ha sido declarada, incluso si esta está indefinida. Mencionar el nombre de una subrutina para saber si existe o está definida no cuenta como si fuera su declaración. Note que puede llamarse a una subrutina que no existe: su paquete puede tener un método AUTOLOAD que la hace aparecer la primera vez que se le llama; ver perlsub.

    print "Existe\n"   if exists  &subrutina;
    print "Definido\n" if defined &subrutina;

Note que EXPR puede ser todo lo arbitrariamente complicada que se quiera con tal de que la operación final sea un escalar de un hash o de un array o el nombre de una subrutina:

    if (exists $ref->{A}->{B}->{$clave})  { }
    if (exists $hash{A}{B}{$clave})       { }

    if (exists $ref->{A}->{B}->[$i])      { }
    if (exists $hash{A}{B}[$i])           { }

    if (exists &{$ref->{A}{B}{$clave}})   { }

Aunque el array o hash más profundamente anidado no se autovivifique sólo por que su existencia sea comprobada, cualquiera de los niveles intermedios sí que lo hará. Así. $ref->{"A"} y $ref->{"A"}->{"B"} aparecerán en la existencia debido a la comprobación del elemento $clave. Esto sucede en cualquier parte en que se use el operador flecha, incluso aquí:

    undef $ref;
    if (exists $ref->{"Alguna clave"})    { }
    print $ref;  # imprime HASH(0x80d3d5c)

Esta sorprendente autovivificación en que al primer vistazo -o incluso al segundo- parece que es un contexto valor-izquierda quizás será arreglado en una futura distribución.

Usar una llamada de subrutina en lugar del nombre de una subrutina como argumento a exists, es un error.

    exists &sub;    # OK
    exists &sub();  # Error
exit EXPR
exit

Evalúa EXPR y sale inmediatamente con este valor. Ejemplo:

    my $ans = <STDIN>;
    exit 0 if $ans =~ /^[Xx]/;

Vea también die. Si se omite EXPR, sale con estado 0. Los únicos valores universalmente reconocidos para EXPR son 0 para éxito y 1 para error; otros valores están sujetos a interpretación dependiendo del entorno en que el programa Perl está corriendo. Por ejemplo, saliendo con 69 (EX_UNAVAILABLE) desde un filtrado de un correo entrante hacia sendmail hará que el despachador de correo devuelva el elemento sin entregar, pero no siempre es cierto.

No use exit para abortar una subrutina si existe la posibilidad de que alguien pueda capturar el error que sucedió. Use en su lugar die, que puede atraparse por un eval.

La función exit no siempre termina de forma inmediata. Llama primero a cualquier rutina END definida, pero estas rutinas END pueden abortar la salida por sí mismas. Igualmente cualquier destructor de objetos que necesite llamarse, lo será antes de la salida real. Las rutinas END y los destructores pueden cambiar el estado de salida modificando $?. Si esto es un problema, puede llamar a POSIX::_exit($status) para saltar el procesado de END y de los destructores. Ver perlmod para los detalles.

Cuestiones de portabilidad: "exit" in perlport.

exp EXPR
exp

Devuelve e (la base natural del logaritmo) a la potencia de EXPR. Si EXPR se omite, devuelve exp($_).

fc EXPR
fc

Devuelve la versión de EXPR con los tamaños de caja cambiados. Esta es la función interna de la secuencia de escapado \F en las cadenas doblemente entrecomilladas.

El plegado de caja es el proceso de trasladar cadenas de una forma donde las diferencias de caja son eliminadas; comparar dos cadenas en sus formas plegadas es una forma efectiva de averiguar si las dos cadenas son iguales, independientemente de su tamaño de caja.

A grandes rasgos, si ha encontrado alguna vez escribiendo algo como esto

    lc($esto) eq lc($eso)    # ¡Incorrecto!
        # o
    uc($esto) eq uc($eso)    # ¡También incorrecto!
        # o
    $esto =~ /^\Q$eso\E\z/i  # ¡Correcto!

Ahora puede escribirlo como

    fc($esto) eq fc($eso)

Y obtener los resultados correctos.

Perl sólo implementa la forma completa de plegado de caja, pero puede realizar plegados sencillos usando "casefold()" in Unicode::UCD y "prop_invmap()" in Unicode::UCD. Para más información sobre plegado de caja, consulte el Estándar Unicode, específicamente las secciones 3.13 Default Case Operations, 4.2 Case-Normative, y 5.18 Case Mappings, disponible en http://www.unicode.org/versions/latest/, así como los Case Charts disponibles en http://www.unicode.org/charts/case/.

Si se omite EXPR, usa $_.

Esta función se comporta de la misma manera bajo varios pragmas, como en "use feature 'unicode_strings", como lo hace lc, con la única excepción de fc de LATIN CAPITAL LETTER SHARP S (U+1E9E) dentro del ámbito de use locale. El plegado de caja de este carácter normalmente sería "ss", pero como se ha explicado en la sección de lc, los cambios de caja que cruzan la frontera 255/256 son problemáticos bajo los locales, y es por ello que se prohibió. Por tanto, esta función bajo locale devuelve en su lugar la cadena de caracteres "\x{17F}\x{17F}", la cual es la LATIN SMALL LETTER LONG S. Ya que este carácter se pliega a si mismo a una "s", la cadena de caracteres de dos de ellas juntas tendría que ser equivalente a un solo U+1E9E cuándo se plegase.

Mientras que el Estándar Unicode define dos formas adicionales de plegado de caja, una para las lenguas turcas y otra que nunca asigna un carácter en múltiples caracteres, éstas no se proporcionan en el núcleo de Perl. Sin embargo, el módulo CPAN Unicode::Casing se puede utilizar para proporcionar una implementación.

fc sólo está disponible si la característica "fc" está habilitada o si está prefijada con CORE::. La característica "fc" se activa automáticamente con una declaración use v5.16 (o superior) en el ámbito actual.

fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR

Implementa la función fcntl(2). Probablemente escribirá

    use Fcntl;

primero para obtener las definiciones de las constantes. El procesamiento de argumentos y el valor devuelto funcionan como ioctl. Por ejemplo:

    use Fcntl;
    my $flags = fcntl($filehandle, F_GETFL, 0)
        or die "No puedo hacer fcntl F_GETFL: $!";

No necesita comprobar con defined al regreso de fcntl. Como ioctl, mapea un 0 devuelto de la llamada del sistema en un "0 but true" ("0, pero cierto") en Perl. Esta cadena es verdadera en contexto booleano y 0 en contexto numérico. También es una excepción en el sistema normal de avisos Argument "..." isn't numeric sobre conversiones numéricas no apropiadas.

Tenga en cuenta que fcntl levanta una excepción si se utiliza en una máquina que no implemente fcntl(2). Vea el módulo Fcntl o la página de manual fcntl(2) para aprender qué funciones están disponibles en su sistema.

Aquí hay un ejemplo que establece un identificador de archivo llamado $REMOTE a no bloqueante a nivel de sistema. Aunque, tendrá que negociar con $|.

    use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);

    my $flags = fcntl($REMOTE, F_GETFL, 0)
        or die "No puedo obtener los flags para el socket: $!\n";

    fcntl($REMOTE, F_SETFL, $flags | O_NONBLOCK)
        or die "No puedo poner los flags para el socket: $!\n";

Cuestiones de portabilidad: "fcntl" in perlport.

__FILE__

Un token especial que devuelve el nombre del archivo en el que aparece.

fileno IDENTIFICADOR_ARCHIVO

Devuelve el descriptor de archivo para un identificador de archivo, o indefinido si el identificador de archivo no está abierto. Si no hay un descriptor de archivo real a nivel del sistema operativo, como puede suceder con identificadores de archivo relacionados con objetos de memoria a través de open con una referencia para el tercer argumento, se devuelve -1.

Esto es principalmente útil para construir bitmaps para select y operaciones POSIX de bajo nivel sobre tty. Si el IDENTIFICADOR_ARCHIVO es una expresión, el valor se toma como un identificador de archivo indirecto, generalmente su nombre.

Puede usar esto para encontrar cuándo dos identificadores de archivos se refieren al mismo descriptor subyacente:

    if (fileno($this) != -1 && fileno($this) == fileno($that)) {
        print "\$this y \$that son duplicados\n";
    } elsif (fileno($this) != -1 && fileno($that) != -1) {
        print "\$this y \$that son diferentes " .
            "descriptores de archivo subyacentes\n";
    } else {
        print "Al menos uno de \$this o \$that " .
            "no tienen un descriptor a un archivo real\n";
    }

El comportamiento de fileno en un identificador de directorio depende del sistema operativo. En un sistema con dirfd(3) o similar, fileno en un identificador de directorio devuelve el descriptor de archivo subyacente asociado con el identificador; en sistemas que no lo soportan, devuelve el valor indefinido, y establece fileno (errno).

flock IDENTIFICADOR_ARCHIVO,OPERACIÓN

Llama a flock(2), o una emulación de ella, sobre IDENTIFICADOR_ARCHIVO. Devuelve verdadero para éxito, falso en caso de error. Produce un error fatal si se usa en una máquina que no implemente flock(2), bloqueo fcntl(2), o lockf(3). flock es el interfaz portable de Perl para el bloqueo de archivo, aunque solo bloquea archivos enteros, no registros.

Dos, potencialmente no obvias, pero tradicionales semánticas de flock son: que espera indefinidamente hasta que el bloqueo se concede, y que sus cerrojos son meramente consultivos. Tales bloqueos, discrecionalmente, son más flexibles, pero ofrecen pocas garantías. Esto significa que los programas que no usen flock pueden modificar archivos bloqueados con flock. Vea perlport, la documentación específica de su adaptación Perl, y sus páginas de manual locales, para los detalles. Es mejor asumir el comportamiento tradicional si está escribiendo programas portables. (Pero si no, puede siempre sentirse libre de escribir sus propias idiosincrasias del sistema (algunas veces llamadas "features" -características-). Adhesión servil a los requerimientos de portabilidad no debe impedirle obtener el trabajo hecho).

OPERACIÓN es una de LOCK_SH, LOCK_EX, o LOCK_UN, posiblemente combinado con LOCK_NB. Estas constantes tienen, tradicionalmente, los valores 1, 2, 8 y 4, pero puede usar los nombres simbólicos si los importa con el módulo Fcntl, tanto de forma individual o como un grupo usando la marca :flock. LOCK_SH solicita un bloqueo compartido, LOCK_EX solicita un bloqueo exclusivo y LOCK_UN devuelve un bloqueo solicitado previamente. Si LOCK_NB se combina a nivel de bit con 'or' con LOCK_SH o LOCK_EX entonces flock regresa inmediatamente en vez de bloquear esperando por el cerrojo; compruebe el valor de estado devuelto para ver si lo ha conseguido.

Para evitar la posibilidad de descoordinación, Perl ahora vacía el IDENTIFICADOR_ARCHIVO antes de bloquearlo o desbloquearlo.

Note que la emulación integrada con lockf(3) no provee de bloqueos compartidos y requiere que el IDENTIFICADOR_ARCHIVO se abra con intención de escribir en él. Estas son las semánticas que lockf(3) implementa. La mayor parte si no todos los sistemas implementan lockf(3) en términos de bloqueo con fcntl(2), aunque, las diferencias en la semántica no debería sorprender a muchas personas.

Note que la emulación de fcntl(2) de flock(3) requiere que IDENTIFICADOR_ARCHIVO sea abierto con intención de leer para usar LOCK_SH y requiere ser abierto con intención de escribir para usar LOCK_EX.

Note también que algunas versiones de flock no pueden bloquear cosas sobre la red; necesitará usar un fcntl más específico del sistema para hacer esto. Si le gusta, puede forzar a Perl a que ignore la función de su sistema flock(2) y proveer de su propia emulación basada en fcntl(2), pasando la opción -Ud_flock al programa Configure cuando configure y genere un nuevo Perl.

Esto es un agregador de correo para sistemas BSD.

    # importa constantes LOCK_* y SEEK_END
    use Fcntl qw(:flock SEEK_END);

    sub lock {
        my ($fh) = @_;
        flock($fh, LOCK_EX) or die "No puedo bloquear el buzón - $!\n";

        # y, en caso de que alguien haya añadido algo mientras esperábamos...
        seek($fh, 0, SEEK_END) or die "No puedo posicionarme - $!\n";
    }

    sub unlock {
        my ($fh) = @_;
        flock($fh, LOCK_UN) or die "No puedo desbloquear el buzón - $!\n";
    }

    open(my $mbox, ">>", "/usr/spool/mail/$ENV{'USER'}")
        or die "No puedo abrir el buzón: $!";

    lock($mbox);
    print $mbox $msg,"\n\n";
    unlock($mbox);

En sistemas que soportan un flock(2) real, los bloqueos se heredan a través de las llamadas fork, teniendo en cuenta que se recurrirá a la caprichosa función fcntl(2) que pierde sus bloqueos, haciendo difícil escribir servidores.

Ver también DB_File para otros ejemplos de flock.

Cuestiones de portabilidad: "flock" in perlport.

fork

Hace una llamada del sistema fork(2) para crear un nuevo proceso ejecutando el mismo programa en el mismo punto. Devuelve el pid del hijo al proceso padre, 0 al proceso hijo, o undef si el fork no funcionó. Descriptores de archivo (y algunas veces bloqueos en estos descriptores) son compartidos, mientras que todo lo demás es copiado. En la mayoría de los sistemas que soportan fork(2), se ha tenido gran cuidado en hacerlo extremadamente eficiente (por ejemplo, usando la tecnología copy-on-write en páginas de datos), haciendo de él el paradigma dominante de la multitarea en las últimas décadas.

Perl intenta vaciar todos los archivos abiertos para salida antes de crear un proceso hijo, pero es posible que esto no esté soportado en algunas plataformas (vea perlport). Para estar seguros, puede necesitar establecer $| ($AUTOFLUSH en el módulo English) o llamar el método autoflush de IO::Handle en cualquiera de los identificadores de archivo abiertos para evitar la salida duplicada.

Si hace un fork sin luego esperar a sus hijos, irá acumulando zombies. En algunos sistemas, puede evitarlo poniendo $SIG{CHLD} a "IGNORE". Ver también perlipc para más ejemplos de fork y borrado de hijos moribundos.

Note que si su hijo hereda los descriptores de archivo del sistema como STDIN y STDOUT que estén realmente conectados a una tubería o a un socket, incluso si usted sale del programa, el servidor remoto (por ejemplo, un script CGI o un proceso lanzado en segundo plano desde un shell remoto) no se dará cuenta de que se ha ido. Deberá reabrirlos a /dev/null si eso es un problema.

En algunas plataformas, como Windows, en donde la llamada del sistema fork(2) no está disponible, Perl se puede compilar para emular fork dentro del intérprete de Perl. La emulación está diseñada al nivel del programa Perl, para que sea tan compatible como sea posible con el fork(2) del "Unix". Sin embargo, tiene limitaciones que se tienen que considerar en el código que pretenda ser portable. Vea perlfork para más detalles.

Cuestiones de portabilidad: "fork" in perlport.

format

Declara una imagen del formato para usar con la función write. Por ejemplo:

    format Algo =
        Test: @<<<<<<<< @||||| @>>>>>
              $str,     $%,    '$' . int($numero)
    .

    $str = "widget";
    $numero = $coste/$cantidad;
    $~ = 'Algo';
    write;

Ver perlform para más detalles y ejemplos.

formline DIBUJO,LISTA

Esta es una función interna usada por format, aunque usted también puede llamarla. Formatea (vea perlform) una lista de valores de acuerdo a los contenidos de CUADRO, colocando la salida en el acumulador de salida de format, $^A (o $ACCUMULATOR en English). Finalmente, cuando se hace un write, los contenidos de write se escriben al identificador de archivo. Puede también leer $^A y volver a ponerla otra vez a "". Note que un formato típicamente hace un formline por línea del formato, pero a la misma función formline no le preocupa cuántos avances de línea están incluidos en el CUADRO. Esto significa que los tokens ~ y ~~ tratan al CUADRO entero como una única línea. Puede por eso necesitar usar múltiples formlines para implementar un único registro format, como lo hace el propio compilador de format.

Tenga cuidado si pone dobles comillas alrededor del cuadro, porque un carácter @ puede ser tomado como el comienzo del nombre de un array. formline siempre devuelve verdadero. Vea perlform para otros ejemplos.

Si está intentando usar esto en lugar de write para capturar la salida, puede encontrar que sea más sencillo abrir un identificador de archivo en un escalar (open $fh, ">", \$salida) y escribir en él.

getc IDENTIFICADOR_ARCHIVO
getc

Devuelve el siguiente carácter desde el archivo de entrada asociado a IDENTIFICADOR_ARCHIVO, o el valor indefinido al final del archivo, o si ocurrió un error (en este último caso, se establece $!). Si se omite IDENTIFICADOR_ARCHIVO, se lee desde STDIN. Esto no es particularmente eficiente. Sin embargo, esto no se puede usar para extraer caracteres sueltos sin esperar a que el usuario pulse la tecla de Enter. Para esto, intente algo como esto:

    if ($BSD_STYLE) {
        system "stty cbreak </dev/tty >/dev/tty 2>&1";
    }
    else {
        system "stty", '-icanon', 'eol', "\001";
    }

    my $tecla = getc(STDIN);

    if ($BSD_STYLE) {
        system "stty -cbreak </dev/tty >/dev/tty 2>&1";
    }
    else {
        system 'stty', 'icanon', 'eol', '^@'; # ASCII NUL
    }
    print "\n";

La determinación de cómo poner $BSD_STYLE se deja como ejercicio al lector.

La función POSIX::getattr puede hacer esto de forma más portable en sistemas compatibles con POSIX. Vea también el módulo Term::ReadKey en CPAN.

getlogin

Implementa la función de la biblioteca C del mismo nombre, que en la mayoría de los sistemas devuelve el login actual desde /etc/utmp, si existe. Si devuelve la cadena vacía, utilice getpwuid.

    my $login = getlogin || getpwuid($<) || "Kilroy";

No considere usar getlogin para autenticación: no es tan seguro como getpwuid.

Cuestiones de portabilidad: "getlogin" in perlport.

getpeername SOCKET

Devuelve la dirección socket empaquetada del otro extremo de la conexión SOCKET.

    use Socket;
    my $hersockaddr    = getpeername($sock);
    my ($port, $iaddr) = sockaddr_in($hersockaddr);
    my $herhostname    = gethostbyaddr($iaddr, AF_INET);
    my $herstraddr     = inet_ntoa($iaddr);
getpgrp PID

Devuelve el actual grupo del proceso especificado por el PID. Use un PID de 0 para obtener el grupo del proceso actual. Elevará una excepción si se usa en una máquina que no implemente getpgrp(2). Si PID se omite, devuelve el grupo del proceso actual. Note que la versión POSIX de getpgrp no acepta un argumento PID, por lo que sólo PID==0 es verdaderamente portable.

Cuestiones de portabilidad: "getpgrp" in perlport.

getppid

Devuelve el identificador de proceso del proceso padre.

Nota para los usuarios de Linux: Entre v5.8.1 y v5.16.0 Perl evitará la semántica de hilos no compatible con POSIX que usan una minoría de sistemas Linux (y sistemas Debian GNU/kFreeBSD) que utilizan LinuxThreads; esta emulación se ha eliminado. Vea la documentación de $$ para más detalles.

Cuestiones de portabilidad: "getppid" in perlport.

getpriority CUÁL,QUIÉN

Devuelve la prioridad actual de un proceso, un grupo de procesos o un usuario. (Vea getpriority(2)). Lanzará una excepción fatal si se usa en una máquina que no implemente getpriority(2).

Cuestiones de portabilidad: "getpriority" in perlport.

getpwnam NOMBRE
getgrnam NOMBRE
gethostbyname NOMBRE
getnetbyname NOMBRE
getprotobyname NOMBRE
getpwuid UID
getgrgid GID
getservbyname NOMBRE,PROTOCOLO
gethostbyaddr DIRECCIÓN,TIPODIR
getnetbyaddr DIRECCIÓN,TIPODIR
getprotobynumber NÚMERO
getservbyport PUERTO,PROTOCOLO
getpwent
getgrent
gethostent
getnetent
getprotoent
getservent
setpwent
setgrent
sethostent SIGUEABIERTO
setnetent SIGUEABIERTO
setprotoent SIGUEABIERTO
setservent SIGUEABIERTO
endpwent
endgrent
endhostent
endnetent
endprotoent
endservent

Estas rutinas son las mismas que sus homólogas en la biblioteca del sistema. En contexto lista, los valores devueltos por varias de ellas son como sigue:

 #    0        1          2           3         4
 my ( $nombre, $password, $gid,       $miembros ) = getgr*
 my ( $nombre, $alias,    $tipoadr,   $red      ) = getnet*
 my ( $nombre, $alias,    $puerto,    $protocolo) = getserv*
 my ( $nombre, $alias,    $protocolo            ) = getproto*
 my ( $nombre, $alias,    $tipoadr,   $longitud, @direcs ) = gethost*
 my ( $nombre, $password, $uid,       $gid,     $cuota,
    $comentario,$gcos,    $dir,       $shell,   $expira ) = getpw*
 #    5        6          7           8         9

(Si la entrada no existe, el valor de retorno es un único valor verdadero, sin significado).

El significado exacto del campo $gcos varía pero usualmente contiene el nombre real del usuario (como opuesto al nombre de login) y otra información perteneciente al usuario. Tenga cuidado, sin embargo, que en muchos sistemas los usuarios son capaces de cambiar esta información y por eso no puede confiarse y por eso el $gcos queda contaminado (ver perlsec). La $contrasena y el $shell, la contraseña codificada del usuario y el shell del login, están también contaminados, por la misma razón.

En contexto escalar, obtiene el nombre, a menos que la función fuera localizar por nombre, en cuyo caso obtendrá la otra cosa, cualquiera que sea. (Si la entrada no existe obtendrá el valor indefinido). Por ejemplo:

    my $uid    = getpwnam($nombre);
    my $nombre = getpwuid($numero);
    my $nombre = getpwent();
    my $gid    = getgrnam($nombre);
    my $nombre = getgrgid($numero);
    my $nombre = getgrent();
    # etc.

En getpw*() los campos $cuota, $comentario y $expiracion son casos especiales en el sentido que en muchos sistemas no están soportados. Si la $cuota no está soportada, es un escalar vacío. Si está soportada, usualmente codifica la cuota de disco. Si el campo $comentario no está soportado, es un escalar vacío. Si está soportado usualmente codifica algún comentario administrativo sobre el usuario. En algunos sistemas el campo $cuota puede ser $cambio o $edad, campos que tienen que ver con la caducidad de la contraseña. En algunos sistemas el campo $comentario puede ser $clase. El campo $expira, si está presente, codifica el periodo de expiración de la cuenta o de la contraseña. Para ver la disponibilidad y el significado exacto de estos campos, en su sistema, por favor consulte getpwnam(3) y su archivo del sistema pwd.h. Puede también encontrar, dentro de Perl, que es lo que significan sus campos $cuota, $comentario y $expira usando el módulo Config y los valores d_pwquota, d_pwage, d_pwchange, d_pwcomment y d_pwexpire. Archivos de contraseñas shadow sólo se soportan si el proveedor los implementa con la intuitiva moda de que llamando a las rutinas regulares de la biblioteca C se obtienen las versiones shadow si está corriendo con bajos privilegios o si existe la función shadow(3) tal como se encuentra en System V (esto incluye Solaris y Linux). Los sistemas que implementen un sistema de contraseñas shadow propietario es impropable que sean soportados.

El valor de $miembros devuelto por getgr*() es una lista separada por espacios de los nombres de login de los miembros del grupo.

Para las funciones gethost*(), si la variable h_errno se soporta en C, se devolverá vía $? si la llamada a la función falla. El valor devuelto @addrs por una exitosa llamada es una lista de las direcciones en crudo devueltas por la correspondiente llamada a la biblioteca. En el dominio de Internet, cada dirección son cuatro bytes de longitud; puede desempaquetarlos diciendo algo como:

    my ($w,$x,$y,$z) = unpack('W4',$addr[0]);

La biblioteca Socket hace esto ligeramente más fácilmente:

    use Socket;
    my $iaddr = inet_aton("127.1"); # o la dirección que sea
    my $nombre = gethostbyaddr($iaddr, AF_INET);

    # o de otra manera
    my $straddr = inet_ntoa($iaddr);

En sentido contrario, para resolver un nombre de host a la dirección IP puede escribir lo siguiente:

    use Socket;
    my $packed_ip = gethostbyname("www.perl.org");
    my $ip_address;
    if (defined $packed_ip) {
        $ip_address = inet_ntoa($packed_ip);
    }

Cerciórese de que se llama a gethostbyname en contexto ESCALAR y compruebe que se ha definido su valor de retorno.

La función getprotobynumber, a pesar de que sólo toma un argumento, tiene la precedencia de un operador de lista, así que tenga cuidado:

    getprotobynumber $numero eq 'icmp'   # INCORRECTO
    getprotobynumber($numero eq 'icmp')  # esto es lo que significa
    getprotobynumber($numero) eq 'icmp'  # mejor de esta manera

Si está cansado de recordar qué elemento de la lista devuelta contiene qué valor, existen interfaces por nombre, en módulos estándar: File::stat, Net::hostent, Net::netent, Net::protoent, Net::servent, Time::gmtime, Time::localtime y User::grent. Estas sobreescriben a las predefinidas, ofreciendo versiones que devuelven objetos con los nombres apropiados para cada campo. Por ejemplo:

   use File::stat;
   use User::pwent;
   my $is_his = (stat($archivo)->uid == pwent($loquesea)->uid);

Incluso aunque parezcan los mismos métodos (uid), no lo son, porque un objeto File::stat es diferente de un objeto User::pwent.

Cuestiones de portabilidad: "getpwnam" in perlport a "endservent" in perlport.

getsockname SOCKET

Devuelve la dirección de socket empaquetada de este final de la conexión SOCKET, en el caso de que no conozca la dirección porque tenga diferentes IP por las que la conexión se pudo haber realizado.

    use Socket;
    my $mysockaddr = getsockname($sock);
    my ($port, $myaddr) = sockaddr_in($mysockaddr);
    printf "Conectar a %s [%s]\n",
       scalar gethostbyaddr($myaddr, AF_INET),
       inet_ntoa($myaddr);
getsockopt SOCKET,NIVEL,OPCIÓN

Consulta la opción con nombre OPCIÓN asociada con el SOCKET en un determinado NIVEL. Opciones pueden existir en múltiples niveles de protocolo dependiendo del tipo de socket, pero al menos existirá el más alto nivel de socket SOL_SOCKET (definido en el módulo Socket). Para consultar opciones a otro nivel, se debe indicar el apropiado número de protocolo que controle a esa opción. Por ejemplo, para indicar que una opción se ha de interpretar por el protocolo TCP, NIVEL se debe establecer al número de protocolo del TCP, que puede obtener usando getprotobyname.

La llamada devuelve una cadena empaquetada representando la opción socket solicitada, o undef si hay un error, con la razón del error establecida en $!. Lo que exista exactamente en la cadena empaquetada depende de NIVEL y OPCIÓN; consulte getsockopt(2) para más detalles. Un caso común es que la opción sea un entero, en cuyo caso el resultado es un entero empaquetado, que podrá decodificar usando unpack con el formato i (o I).

Aquí hay un ejemplo para comprobar si el algoritmo de Nagle está habilitado en un socket:

    use Socket qw(:all);

    defined(my $tcp = getprotobyname("tcp"))
        or die "No puedo determinar el número de protocolo para tcp";
    # my $tcp = IPPROTO_TCP; # Alternativa
    my $packed = getsockopt($socket, $tcp, TCP_NODELAY)
        or die "getsockopt TCP_NODELAY: $!";
    my $nodelay = unpack("I", $empaquetado);
    print "El algoritmo de Nagle está ",
           $nodelay ? "desactivado\n" : "activado\n";

Cuestiones de portabilidad: "getsockopt" in perlport.

glob EXPR
glob

En contecto lista, devuelve una (posiblemente vacía) lista de la expansión de nombres de archivo del valor de EXPR como si el shell estandar Unix /bin/csh lo hiciera. En contexto escalar, glob itera a través de la expansión de nombres de archivo, devolviendo undef cuando se agote la lista. Esto es la función interna que implementa el operador <*.c>, pero puede usarla directamente. Si se omite EXPR, se usa $_. El operador <*.c> se explica con más detalle en "Operadores E/S" in perlop.

Tenga en cuenta que glob divide sus argumentos por los espacios en blanco y trata a cada segmento como patrones independientes. En este sentido, glob("*.c *.h") coincide con todos los archivos con una extensión .c o .h. La expresión glob(".* *") coincide con todos los archivos en el directorio de trabajo actual. Si quiere expandir nombres de archivo que puedan contener espacios en blanco, tendrá que usar comillas adicionales alrededor del espaciado nombre de archivo, para protegerlo. Por ejemplo, para expandir nombres de archivo que tienen una e, seguida por un espacio, seguido por una f, utilice uno de estos ejemplos:

    my @espacios = <"*e f*">;
    my @espacios = glob '"*e f*"';
    my @espacios = glob q("*e f*");

Si tuviera que usar una variable, puede usar esto:

    my @espacios = glob "'*${var}e f*'";
    my @espacios = glob qq("*${var}e f*");

Si los únicos caracteres comodín en glob son las llaves, no se coincidirá con ningún archivo, pero, potencialmente, se devuelven muchas cadenas. Por ejemplo, esto produce nueve cadenas, una por cada par de frutas y colores:

    my @muchos =  glob "{manzana,tomate,cereza}={verde,amarilla,roja}";

Este operador se implementa usando la extensión estándar File::Glob. Ver File::Glob para los detalles, incluyendo bsd_glob que no trata al espacio en blanco como separador de patrones.

Cuestiones de portabilidad: "glob" in perlport.

gmtime EXPR
gmtime

Funciona igual que localtime pero los valores devueltos se localizan por la zona horaria estándar de Greenwich.

Nota: cuando se le llama en contexto lista, $isdst, el último valor devuelto por gmtime siempre es 0. No hay horario de verano en el horario GMT.

Cuestiones de portabilidad: "gmtime" in perlport.

goto ETIQUETA
goto EXPR
goto &NOMBRE

La forma goto ETIQUETA busca la instrucción etiquetada con ETIQUETA y continua la ejecución desde allí. No se puede utilizar para salir de un bloque o una subrutina pasada a sort. Se puede utilizar para ir a casi cualquier sitio que esté dentro del ámbito dinámico, incluyendo fuera de las subrutinas, pero es usualmente mucho mejor usar otras construcciones, como last o die. El autor de Perl nunca ha tenido la necesidad de usar esta forma de goto (en Perl, desde luego. C es otra historia). (La diferencia con C es que no ofrece bucles nombrados combinados con control de bucles. Perl sí, y esto reemplaza a la mayor parte de los usos estructurados de goto en otros lenguajes).

La forma goto EXPR evalúa EXPR a una referencia de código o nombre de etiqueta. Si evalúa a una referencia de código, será gestionada como el goto &NAME visto antes. Esto es especialmente útil para implementar colas de recursión con goto __SUB__.

Si la expresión evalúa a un nombre de etiqueta, su ámbito se resolverá dinámicamente. Esto permite crear goto calculados como en FORTRAN, pero no se recomienda como algo necesario, sobre si está optimizando en la fase de mantenimiento:

    goto ("FOO", "BAR", "GLARCH")[$i];

Como se muestra en este ejemplo, goto EXPR está exento de la regla "se parece a una función". Un par de paréntesis puestos a continuación no (necesariamente) delimitan su argumento. goto("NE")."XT" es equivalente a goto NEXT. También, a diferencia de otros operadores con nombre, este tiene la misma precedencia que una asignación.

El uso de goto ETIQUETA o goto EXPR para saltar en una construcción es obsoleto y emitirá una advertencia. Incluso entonces, no se puede usar para ir a cualquier construcción que requiere inicialización, como una subrutina o un bucle foreach. Tampoco se puede usar para ir a una construcción que se ha optimizado.

La forma goto &NOMBRE es muy diferente de las otras formas de goto. De hecho, no es un goto en el sentido normal y no tiene el estigma asociado de los otros gotos. En cambio, sale de la subrutina actual (perdiendo cualquier cambio hecho por local) e inmediatamente llama a la subrutina indicada pasándole el valor actual de @_. Esto se usa en subrutinas AUTOLOAD() que desean cargar otra subrutina y fingen que ésta otra subrutina se ha llamado en primer lugar (excepto que cualquier modificación @_ en la subrutina actual se propaga a la otra). Después del goto, ni siquiera caller será capaz de decir qué rutina se llamó en primer lugar.

NOMBRE no necesita ser el nombre de una subrutina; puede ser una variable escalar que contenga una referencia a un código o un bloque que evalúa a una referencia de código.

grep BLOQUE LISTA
grep EXPR,LISTA

Es similar en espíritu, pero no es lo mismo, que con grep(1) y sus hermanos. En particular, no está limitado a usar expresiones regulares.

Evalúa el BLOQUE o EXPR para cada elemento de LISTA (poniendo localmente $_ a cada elemento) y devuelve un valor de lista consistente en los elementos por los que la expresión evaluada es verdadera. En contexto escalar, devuelve el número de veces que la expresión fue verdadera.

    my @foo = grep(!/^#/, @bar);    # quitar los comentarios

o equivalentemente,

    my @foo = grep {!/^#/} @bar;    # quitar los comentarios

Note que $_ es un alias al valor de la lista, por lo que se puede usar para modificar los elementos de la LISTA. Mientras que esto suele ser útil, puede causar resultados extraños si los elementos de la LISTA no son variables. De forma semejante, grep devuelve alias de la lista original, como los alias de los elementos de la lista de las variables de los bucles for. Es decir, modificar un elemento de la lista devuelto por grep (por ejemplo, en un foreach, map u otro grep) realmente modifica el elemento en la lista original. Esto es algo usualmente a evitarse cuando se está escribiendo código claro.

Vea también map para ver una lista compuesta de los resultados del BLOQUE o EXPR.

hex EXPR
hex

Interpreta EXPR como una cadena en hexadecimal y devuelve el valor numérico correspondiente. Si se omite EXPR, usa $_.

    print hex '0xAf'; # imprime '175'
    print hex 'aF';   # lo mismo
    $entrada_valida =~ /\A(?:0?[xX])?(?:_?[0-9a-fA-F])*\z/

Una cadena hexadecimal consiste en dígitos hexadecimales y un prefijo opcional 0x o x Cada dígito hexadecimal puede ir precedido por un único guión bajo, que se ignorará. Cualquier otro carácter disparará una advertencia y provocará que el resto de la cadena se ignore (incluso los espacios en blanco colindantes, a diferencia de oct). Solo se pueden representar enteros, y un desborde de enteros disparará una advertencia.

Para convertir cadenas que podrían comenzar con 0, 0x o 0b, vea oct). Para presentar algo en formato hexadecimal, mire en printf, sprintf, y unpack.

import LISTA

No existe la función predefinida import. Sólo es un método (subrutina) ordinario definido (o heredado) por módulos que desean exportar nombres a otro módulo. La función use llama al método import del paquete a usar. Ver también use, perlmod y Exporter.

index CADENA,SUBCADENA,POSICIÓN
index CADENA,SUBCADENA

La función index busca por un string dentro de otro, pero sin tener el comportamiento de un sistema de coincidencias basado en expresiones regulares. Devuelve la posición de la primera ocurrencia de SUBSTR en STRING en o después de POSICIÓN. Si se omite POSICIÓN, comienza a buscar desde el comienzo del string. POSICIÓN antes del comienzo del string o después de su final es tratado como si estuviera al principio o al final, respectivamente. POSICIÓN y el valor de retorno están basados en cero. Si la subcadena no se encuentra, index devuelve -1.

int EXPR
int

Devuelve la parte entera de EXPR. Si se omite EXPR, usa $_. No debe usar esta función para redondear: primero, porque trunca hacia 0 y segundo, porque las representaciones máquina de números en punto flotante puede producir, algunas veces, resultados dispares. Por ejemplo, int(-6.725/0.025) produce -268 en vez del valor correcto -269; esto es porque el valor realmente es -268.99999999999994315658. Usualmente, las funciones sprintf, printf, o las POSIX::floor y POSIX::ceil le serviran mejor que int.

ioctl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR

Implementa la función ioctl(2). Probablemente primero querrá escribir

    require "sys/ioctl.ph";  # probablemente en
                             # $Config{archlib}/sys/ioctl.ph

para obtener las correctas definiciones de la función. Si sys/ioctl.ph no existe o no tiene las definiciones correctas, tendrá que incorporar las suyas propias, basadas en sus archivos de cabecera C como las de <sys/ioctl.h>. (Existe un script Perl llamado h2ph que viene con el kit Perl que puede ayudarle en esto, pero no es nada trivial). ESCALAR se leerá o escribirá dependiendo de la FUNCIÓN; un puntero C al valor de la cadena ESCALAR se pasará como tercer argumento de la llamada real a ioctl. (Si ESCALAR no tiene un valor de cadena sino que tiene un valor numérico, ese valor será el que se pase, en lugar de un puntero al valor de la cadena. Para garantizar que esto sea cierto, sume un 0 al escalar antes de usarlo). Las funciones pack y unpack pueden ser necesarias para manipular los valores de las estructuras utilizadas por ioctl.

El valor devuelto de ioctl (y fcntl) es como sigue:

    si OS devuelve:    entonces Perl devuelve:
        -1                 valor indefinido
         0                 cadena "0 but true"
    otra cosa              ese número

Así, Perl devuelve verdadero en éxito y falso en caso de error, por lo que aún podemos determinar el valor real devuelto por el sistema operativo:

    my $retval = ioctl(...) || -1;
    printf "Sistema devolvió %d\n", $retval;

La cadena especial "0 but true" (0, pero verdadero) es una excepción de que el Argumento "..." no es numérico en conversiones numéricas impropias.

Cuestiones de portabilidad: "ioctl" in perlport.

join EXPR,LISTA

Une las cadenas separados de LISTA en una única cadena con campos separados por el valor de EXPR y devuelve la nueva cadena. Ejemplo:

   my $rec = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);

Cuidado que, a diferencia de split, join no toma un patrón como su primer argumento. Busque las diferencias con split.

keys HASH
keys ARRAY

Llamado en contexto de lista, devuelve una lista consistente en todas las claves del hash indicado, o en Perl 5.12 o posteriores, los índices de un array. Versiones de Perl anteriores a 5.12 producirán un error de sintaxis si intenta utilizar un array como argumento. En contexto escalar, devuelve el número de claves o índices.

Las entradas de un hash son devueltas en un aparente orden aleatorio. El orden aleatorio real es específico a un hash dado; las mismas series de operaciones en dos hashes pueden resultar en diferentes órdenes para cada hash. Cualquier inserción en el hash puede cambiar el orden, así como cualquier eliminación, con la excepción de que la clave más reciente devuelta por each o keys se puede borrar sin que cambie el orden. Siempre y cuando no se modifique un determinado hash puede confiar en que keys, values y each devuelven repetidamente lo mismo en el mismo orden. Vea "Ataques de complejidad algorítmica" in perlsec para los detalles de por qué el orden en un hash se aleatoriza. Aparte de las garantías proporcionadas aquí los detalles exactos de algoritmo que usa Perl para recorrer un hash está sujeto a cambio en cualquier lanzamiento de Perl. Hashes enlazados pueden comportarse diferentemente a los hashes de Perl con respecto a los cambios en el orden, en la inserción y borrado de los elementos.

Como efecto colateral, llamando a keys reinicia el iterador interno del HASH o del ARRAY (vea each). De forma particular, llamando a keys en contexto nulo (void) reinicia el iterador sin otro efecto.

Aquí hay otra forma de imprimir su entorno:

    my @keys = keys %ENV;
    my @values = values %ENV;
    while (@claves) {
        print pop(@keys), '=', pop(@values), "\n";
    }

o de forma ordenada por la clave:

    foreach my $key (sort(keys %ENV)) {
        print $key, '=', $ENV{$key}, "\n";
    }

Los valores devueltos son copias de las claves originales en el hash, así que modificarlas no afectará al hash original. Compare con values.

Para ordenar un hash por valor, necesitará usar la función sort. Esto es una ordenación numérica descendente de un hash por sus valores:

    foreach my $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) {
        printf "%4d %s\n", $hash{$clave}, $clave;
    }

Usado como valor-izquierda, keys le permite incrementar el número de casillas de memoria hash para el hash indicado. Puede hacerle ganar más eficiencia si sabe que el hash va a tener un gran tamaño. (Esto es similar a pre-extender un array asignándole un gran número a $#array). Si dice

    keys %hash = 200;

entonces %hash tendrá al menos 200 casillas de memoria reservados para él -- 256 de ellos, de hecho, ya que se redondea a la siguiente potencia de dos. Estas casillas serán mantenidos incluso si hace %hash = (). Use undef %hash si quiere liberar el almacenamiento mientras mantiene a %hash en el ámbito. No puede reducir el número de casillas reservadas para el hash usando keys de esta manera (pero no necesita preocuparse si hace esto por accidente; intentarlo no tiene ningún efecto). keys @array en un contexto de valor-izquierda es un error de sintaxis.

A partir de 5.14, una característica experimental permitía a keys tomar una expresión escalar. Se ha considerado que este experimento no ha funcionado, y se eliminó a partir de Perl 5.24.

Para no confundir a los posibles usuarios de su código, que ejecuten versiones anteriores de Perl, con errores de sintaxis misteriosos, ponga este tipo de cosas en la parte superior de su archivo para indicar que el código funciona sólo en versiones Perl de cosechas recientes:

    use 5.012;  # así keys/values/each trabajan sobre arrays

Vea también each, values y sort.

kill SEÑAL, LISTA
kill SEÑAL

Manda una señal a una lista de procesos. Devuelve el número de argumentos exitosos que fueron utilizados para señalar (que no es necesariamente el mismo número de procesos realmente asesinados, p. ej., cuando se mata a un grupo de procesos).

    my $cnt = kill 'HUP', $child1, $child2;
    kill 'KILL', @goners;

SEÑAL puede ser tanto un nombre de señal (una cadena) o un número. Un nombre de señal puede empezar con un prefijo SIG, así que FOO y SIGFOO refieren a la misma señal. La forma en cadena de caracteres de SEÑAL es la recomendada para mantener la portabilidad porque la misma señal puede tener números diferentes en diferentes sistemas operativos.

Se puede encontrar una lista de nombres de señales soportadas por la plataforma actual en $Config{sig_name}, ofrecida por el módulo Config. Vea Config para más detalles.

Un nombre de señal negativo es igual a un número de señal negativa, en donde se mata grupos de procesos en vez de procesos. Por ejemplo, kill '-KILL', $pgrp y kill -9, $pgrp enviará SIGKILL al grupo de procesos especificado entero. Eso significa que, de forma general, deseará utilizar señales positivas, y no negativas.

Si la SEÑAL es cero o la cadena ZERO (o SIGZERO), no se envía ninguna señal al proceso, pero kill comprueba si es posible enviar una señal a la misma (lo que significa, para ser breve, que el proceso es propiedad del mismo usuario, o somos el super-usuario). Esto es útil para comprobar que un proceso hijo aún está vivo (aunque sólo sea como un zombie) y no ha cambiado su UID. Ver perlport para notas sobre la portabilidad de esta construcción.

El comportamiento de kill cuando el PROCESO es el número cero o negativo depende del sistema operativo. Por ejemplo, en los sistemas conformes a POSIX, un cero señalará al grupo del proceso actual y -1 señalará todos los procesos, y cualquier otro número de PROCESO negativo actuará como un número de señal y matará el grupo entero del proceso especificado.

Si tanto la SEÑAL y el PROCESO son negativos, los resultados son indefinidos. Se puede producir un aviso en una futura versión.

Ver "Señales" in perlipc para más detalles.

En algunas plataformas, como en Windows, en donde la llamada del sistema fork(2) no está disponible, Perl se puede compilar para emular fork dentro del intérprete de Perl. Esta emulación tiene limitaciones relacionadas con la muerte que tienen que ser consideradas, para código que se ejecute en Windows y código que tenga la intención de ser portable.

Vea perlfork para más detalles.

Si no hay ninguna LISTA de procesos, no se envía ninguna señal, y el valor de retorno es 0. Sin embargo, esto se utiliza a veces, debido a que causa la ejecución de controles de contaminación. Pero vea "Aclarado y detección de datos contaminados" in perlsec.

Cuestiones de portabilidad: "kill" in perlport.

last ETIQUETA
last EXPR
last

El comando last es como la instrucción break del C (usada en bucles); inmediatamente sale del bucle en cuestión. Si la ETIQUETA se omite, el comando se refiere al bucle más interior en que se encuentre. La forma last EXPR, disponible a partir de Perl 5.18.0, permite que se compute un nombre de etiqueta en tiempo de ejecución; de lo contrario es idéntico a last ETIQUETA. El bloque continue, si está, no se ejecuta:

    LINEA: while (<STDIN>) {
        last LINE if /^$/;  # salir cuando se termine la cabecera
        #...
    }

last no se puede usar para salir de un bloque que devuelve un valor como en eval {}, sub {} o do {}, y no debería usarse para salir de una operación grep o map.

Note que un bloque por sí mismo es semánticamente idéntico a un bucle que se ejecuta una vez. Así last se puede usar para salir de forma prematura de este bloque.

Ver también continue para una ilustración de cómo funcionan last, next y redo.

A diferencia de otros operadores con nombre, tiene la misma precedencia que una asignación. También está exenta de la regla "se-parece-a-una-función", así que last ("foo")."bar" hará que "bar" sea parte del argumento a last.

lc EXPR
lc

Devuelve una versión de EXPR, en minúsculas. Esta es la función interna que implementa el escapado \L en las cadenas entre comillas dobles.

Si se omite EXPR, usa $_.

Lo que se devuelve depende de varios factores:

Si use bytes está activo:

Los resultados siguen las reglas ASCII. Sólo los caracteres A-Z cambian, a a-z, respectivamente.

De lo contrario, si está activo use locale para LC_CTYPE:

Respeta la configuración regional LC_CTYPE actual de los códigos de carácter < 256; y utiliza las reglas Unicode para los códigos de carácter restantes (esto último sólo puede ocurrir si también está establecido el indicador UTF8). Vea perllocale.

A partir de v5.20, Perl usa todas las reglas Unicode si la configuración regional es UTF-8. Por contra, hay una deficiencia en este esquema, y es que los cambios de tamaños de caja que cruzan el límite 255/256 no están bien definidos. Por ejemplo, la minúscula de LATIN CAPITAL LETTER SHARP S (U+1E9E) en las reglas Unicode es U+00DF (en las plataformas ASCII). Pero bajo use locale (antes de v5.20 o no está activa la localización UTF-8), la minúscula de U+1E9E es ella misma, porque 0xDF quizás no sea LATIN SMALL LETTER SHARP S en la configuración regional actual, y Perl no tiene forma de saber incluso si existe el carácter en la configuración regional, y aún menos qué código de carácter es. Perl devuelve un resultado que está por encima de 255 (casi siempre el carácter de entrada sin cambiar), para todos los casos (y no hay muchos) donde el límite 255/256, de otro modo, sería traspasado; y a partir de v5.22, lanza una advertencia locale (No puedo hacer ... en una configuración regional que no es UTF-8; se resuelve a ...).

De otra forma, si EXPR tiene activado el indicador UTF8:

Se utilizan las reglas Unicode para el cambio de tamaño de caja.

De otra forma, si use feature 'unicode_strings' o use locale ':not_characters' están habilitados:

Se utilizan las reglas Unicode para el cambio de tamaño de caja.

De lo contrario:

Se utilizan las reglas ASCII para el cambio de tamaño de caja. La minúscula de cualquier carácter fuera del rango ASCII es el propio carácter.

lcfirst EXPR
lcfirst

Devuelve el valor de EXPR con el primer carácter en minúsculas. Esta es la función interna que implementa el escapado \l en las cadenas entre comillas dobles.

Si se omite EXPR, usa $_.

Esta función se comporta de la misma manera bajo varios pragmas, como por ejemplo en una configuración regional, como lo hace lc.

length EXPR
length

Devuelve la longitud en caracteres del valor de EXPR. Si se omite EXPR, devuelve la longitud de $_. Si EXPR es indefinido, devuelve undef.

Esta función no puede utilizarse en un array o hash para averiguar cuántos elementos tienen. Para ello, utilice scalar @array y scalar keys %hash, respectivamente.

Al igual que todas las operaciones de caracteres de Perl, length normalmente trata con caracteres lógicos, no bytes físicos. Para saber la cantidad de bytes que una cadena codificada como UTF-8 ocupa, utilice length(Encode::encode_utf8(EXPR)) (tendrá que poner use Encode primero). Ver Encode y perlunicode.

__LINE__

Un token especial que compila al actual número de línea.

Crea un nuevo nombre de archivo enlazado con el nombre del archivo antiguo. Devuelve verdadero en caso de éxito, o falso en caso contrario.

Cuestiones de portabilidad: "link" in perlport.

listen SOCKET,TAMAÑO_COLA

Hace lo mismo que la llamada del sistema listen(2). Devuelve verdadero si tiene éxito; de lo contrario, falso. Ver el ejemplo en "Sockets: Comunicación Cliente/Servidor" in perlipc.

local EXPR

Lo que realmente querrá usar es my, debido a que local no es lo que la mayoría de la gente piensa de "local". Vea "Variables privadas con my()" in perlsub para más detalles.

Un local() modifica las variables listadas para que sean locales en el bloque que les rodea, un archivo o un eval(). Si se lista más de un valor, esa lista debe ser puesta entre paréntesis. Ver "Valores temporales con local()" in perlsub para más detalles, incluidas las cuestiones relativas a arrays y hash atados.

La construcción delete local EXPR también se puede utilizar para localizar la supresión de elementos de un array o hash en el bloque actual. Ver "Eliminación local de elementos de tipos compuestos" in perlsub.

localtime EXPR
localtime

Convierte un tiempo devuelto por la función time() en una lista de 9 elementos según la zona horaria local. Típicamente se usa como sigue:

    #     0    1    2     3     4    5     6     7     8
    my ($seg,$min,$hora,$mdia,$mes,$anno,$sdia,$ydia,$esdst) =
                                                localtime(time);

Todos los elementos de la lista son numéricos y derivan de la 'struct tm' de C. $seg, $min y $hora son los segundos, minutos y horas del tiempo especificado.

$mdia es el día del mes, y $mes es el mes en el rango 0..11, con 0 indicando enero, y 11, diciembre. Esto hace que sea fácil obtener un nombre de mes desde una lista:

    my @abbr = qw(Ene Feb Mar Abr May Jun Jul Ago Sep Oct Nov Dic);
    print "$abbr[$mes] $mdia";
    # $mes=9, $mdia=18 da "Oct 18"

$anno contiene el número de años desde 1900. Para obtener un año de 4 dígitos, escriba:

    $anno += 1900;

Para obtener los dos últimos dígitos del año (ej., "01" en 2001) hacer:

    $anno = sprintf("%02d", $anno % 100);

$sdia es el día de la semana, con 0 indicando domingo y 3 indicando miércoles. $ydia es el día del año, en el rango 0..364 (o 0..365 en los años bisiestos).

$isdst es verdadero si el tiempo especificado se produce durante el horario de verano; en caso contrario, falso.

Si se omite EXPR, localtime utiliza la hora actual (devuelta por time).

En contexto escalar, localtime devuelve el valor de ctime(3):

    my $ahora_cadena = localtime;  # ej., "Thu Oct 13 04:54:34 1994"

El formato de este valor escalar no es dependiente de la configuración regional, sino que viene predefinido en Perl. Para GMT, en lugar de la hora local, use la función predefinida gmtime. Vea también el módulo Time::Local (para convertir los segundos, minutos, horas, etc., de nuevo al valor entero devuelto por time), y las funciones strftime y mktime del módulo POSIX.

Para obtener algo similar, pero con cadenas de fecha dependiente de la configuración región, ajuste apropiadamente sus variables de entorno a la región (por favor, vea perllocale) e intente, por ejemplo:

    use POSIX qw(strftime);
    my $ahora_cadena = strftime "%a %b %e %H:%M:%S %Y", localtime;
    # o para GMT formateado de acuerdo a su configuración regional:
    my $ahora_cadena = strftime "%a %b %e %H:%M:%S %Y", gmtime;

Note que %a y %b, las formas cortas del día de la semana y el mes del año, pueden no ser necesariamente de tres caracteres de ancho.

Los módulos Time::gmtime y Time::localtime proporcionan mecanismos convenientes de acceso por nombre para las funciones gmtime y localtime, respectivamente.

Para una completa y actualizada representación del tiempo mire en el módulo DateTime en CPAN.

Cuestiones de portabilidad: "localtime" in perlport.

lock COSA

Esta función coloca un bloqueo sobre una variable compartida, o un objeto referenciado contenido en COSA hasta que el bloqueo salga del ámbito.

El valor devuelto es el mismo escalar, si el argumento es un escalar, o una referencia, si el argumento es un hash, array o subrutina.

lock es una "palabra clave débil": significa que si usted ha definido una función con este nombre (antes de cualquier llamada a ella), esa función es la que se llamará. Si no está bajo use threads::shared, no hará nada. Ver threads::shared.

log EXPR
log

Devuelve el logaritmo natural (base e) de EXPR. Si se omite EXPR, devuelve el logaritmo de $_. Para obtener el logaritmo de otra base, use álgebra básica: el logaritmo de base N de un número es igual al logaritmo natural de ese número dividido por el logaritmo natural de N. Por ejemplo:

    sub log10 {
        my $n = shift;
        return log($n)/log(10);
    }

Vea también exp para la operación inversa.

lstat IDENTIFICADOR_ARCHIVO
lstat EXPR
lstat IDENTIFICADOR_DIR
lstat

Hace lo mismo que la función stat (incluyendo el establecimiento del identificador de archivo especial _) pero de un enlace simbólico en lugar del archivo apuntado por el enlace simbólico. Si los enlaces simbólicos no están implementados en su sistema, se hace un stat normal. Para información más detallada, por favor consulte la documentación de stat.

Si se omite EXPR, usa $_.

Cuestiones de portabilidad: "lstat" in perlport.

m//

El operador de emparejamiento. See "Operadores Regex" in perlop.

map BLOQUE LISTA
map EXPR,LISTA

Evalúa el BLOQUE o EXPR para cada elemento de LISTA (estableciendo localmente $_ a cada elemento) y devuelve una lista de valores compuesta de los resultados de cada evaluación. En contexto escalar, devuelve el número total de elementos generados. Evalúa BLOQUE o EXPR en contexto lista, de manera que cada elemento de la LISTA puede producir cero, uno o más elementos en el valor devuelto.

    my @caracteres = map(chr, @numeros);

traduce una lista de números a sus caracteres correspondientes.

    my @cuadrados = map { $_ * $_ } @numeros;

traduce una lista de números a sus valores al cuadrado.

    my @cuadrados = map { $_ > 5 ? ($_ * $_) : () } @numeros;

demuestra que el número de elementos devueltos pueden diferir de la cantidad de elementos de la entrada. Para omitir un elemento, devuelva una lista vacía (). Esto también puede lograrse escribiendo

    my @cuadrados = map { $_ * $_ } grep { $_ > 5 } @numeros;

lo que hace más clara nuestras intenciones.

Map siempre devuelve una lista, que puede asignarse a un hash de tal manera que los elementos serán parejas de claves y valores. Ver perldata para más detalles.

    my %hash = map { una_clave_para($_) => $_ } @array;

es sólo una manera divertida de escribir

    my %hash;
    foreach (@array) {
        $hash{una_clave_para($_)} = $_;
    }

Note que $_ es un alias al valor de la lista, por lo que se puede usar para modificar los elementos de la LISTA. Mientras que esto suele ser útil, puede causar resultados extraños si los elementos de la LISTA no son variables. El uso de un bucle foreach normal para este propósito sería más claro en la mayoría de los casos. Vea también grep para un array compuesto por los elementos de la lista original en que el BLOQUE o EXPR se evalúa como verdadero.

{ comienza tanto una referencia a hash como bloques, por lo que map { ... podría ser tanto el comienzo de map BLOQUE LISTA o map EXPR, LISTA. Debido a que Perl no mira, por adelantado, por el cierre }, tiene que hacer una conjetura basándose en lo que encuentra justo después de {. Por lo general, lo hace bien, pero si no, no se dará cuenta de que algo anda mal hasta que llega a la } y se encuentra con la omisión de (o una inesperada) coma. El error de sintaxis estará indicado cerca de }, pero tendrá que cambiar algo cerca de {, como en el uso de un + unario o un punto y coma, para darle un poco de ayuda a Perl:

 my %hash = map {  "\L$_" => 1  } @array; # perl supone EXPR. mal
 my %hash = map { +"\L$_" => 1  } @array; # perl supone BLOQUE. bien
 my %hash = map {; "\L$_" => 1  } @array; # esto también funciona
 my %hash = map { ("\L$_" => 1) } @array; # como esto también
 my %hash = map {  lc($_) => 1  } @array; # y esto.
 my %hash = map +( lc($_) => 1 ), @array; # esto es EXPR ¡y funciona!

 my %hash = map  ( lc($_), 1 ),   @array; # evalúa a (1, @array)

o para forzar a un constructor de un hash anónimo use +{:

    my @hashes = map +{ lc($_) => 1 }, @array; # EXPR, así que necesita
                                              # una coma al final

para obtener una lista de hashes anónimos, cada uno con sólo una entrada cada uno.

mkdir NOMBRE_ARCHIVO,MÁSCARA
mkdir ARCHIVO
mkdir

Crea el directorio especificado por el nombre de ARCHIVO, con permisos especificados por la MÁSCARA (y modificada a su vez por umask). Si tiene éxito devuelve verdadero; en caso contrario devuelve falso y asigna $! (errno). MÁSCARA vale por defecto 0777, si no se indica, y ARCHIVO es por defecto $_, si no se indica, también.

En general, es mejor crear directorios con una MÁSCARA permisiva y dejar que el usuario lo modifique con su umask que suministrar una MÁSCARA restrictiva y no darle al usuario una forma de ser más permisivo. Las excepciones a esta regla son cuando el archivo o directorio debe mantenerse privados (archivos de correo, por ejemplo). La documentación para umask explica la elección de la MÁSCARA con más detalle.

Tenga en cuenta que de acuerdo con POSIX 1.003.1-1996, el nombre de archivo puede tener cualquier número de barras diagonales. Algunos sistemas operativos y de sistemas de archivos no interpretan esto de forma correcta, por lo que Perl automáticamente elimina todas las barras diagonales finales para tener a todo el mundo feliz.

Para, recursivamente, crear una estructura de directorios, mire la función del make_path del módulo File::Path.

msgctl ID,CMD,ARG

Llama a la función msgctl(2) de System V IPC. Probablemente escribirá

    use IPC::SysV;

primero para obtener las definiciones de las constantes. Si CMD es IPC_STAT, entonces ARG debe ser una variable que contendrá la estructura msqid_ds devuelta. Devuelve lo mismo que ioctl: el valor indefinido para indicar un error, "0 but true" para el caso de cero, o el valor de retorno real, en caso contrario. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV y IPC::Semaphore.

Cuestiones de portabilidad: "msgctl" in perlport.

msgget CLAVE,INDICADORES

Llama a la función msgget(2) de System V IPC. Devuelve el identificador de una cola de mensajes, o el valor undef en caso de error. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV y IPC::Msg.

Cuestiones de portabilidad: "msgget" in perlport.

msgrcv ID,VAR,TAMAÑO,TIPO,INDICADORES

Llama a la función System V IPC msgrcv para recibir un mensaje desde la cola de mensaje ID en la variable VAR con un tamaño máximo de mensaje. Note que en cuanto se recibe un mensaje, el tipo de mensaje, en formato de un entero largo en forma nativa, será la primera cosa almacenada en VAR, seguida por el mensaje real. Este empaquetado se puede abrir con unpack("l! a*"). Contamina la variable. Devuelve verdadero si tuvo éxito, falso en caso de error. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV y IPC::Msg.

Cuestiones de portabilidad: "msgrcv" in perlport.

msgsnd ID,MSG,INDICADORES

Llama a la función msgsnd de System V IPC para enviar el mensaje MSG a la cola de mensajes ID. MSG debe comenzar con un tipo de mensaje, contenido en un entero nativo largo, seguido por la longitud del mensaje real, y finalmente el mensaje mismo. Este tipo de empaquetado se puede lograr con pack("l! a*", $tipo, $mensaje). Devuelve verdadero si tuvo éxito, falso en caso de error. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV y IPC::Msg.

Cuestiones de portabilidad: "msgsnd" in perlport.

my LISTAVAR
my TIPO VARLIST
my LISTAVAR : ATRIBUTOS
my TIPO LISTAVAR : ATRIBUTOS

Un my declara las variables listadas como locales (léxicamente) en el bloque, archivo, o eval que las engloba. Si se lista más de una variable, la lista se debe poner entre paréntesis.

La semántica exacta e interfaz de TIPO y ATRIBUTOS están aún en evolución. TIPO puede ser una palabra simple, una constante declarada con use constant, o __PACKAGE__. Está vinculado al uso del pragma fields, y los atributos se gestionan con el pragma attributes, o a partir de Perl 5.8.0 también a través del módulo Attribute::Handlers. Ver "Variables privadas con my()" in perlsub para más detalles.

Note que con una lista entre paréntesis, se puede utilizar undef como un marcador de posición ficticio, por ejemplo para saltar la asignación de valores iniciales:

    my ( undef, $min, $hora ) = localtime;
next ETIQUETA
next EXPR
next

El comando next es como la instrucción continue en C; comienza la siguiente iteración del bucle:

    LINEA: while (<STDIN>) {
        next LINEA if /^#/;  # descartar comentarios
        #...
    }

Note que si hubiera un bloque continue a continuación del anterior, se ejecutaría incluso en las líneas descartadas. Si la ETIQUETA se omite, el comando se refiere al bucle más interior en que se encuentre. La forma next EXPR, disponible a partir de Perl 5.18.0, permite que se compute un nombre de etiqueta en tiempo de ejecución; de lo contrario es idéntico a next ETIQUETA.

next no se puede utilizar para salir de un bloque que devuelve un valor, como en eval {}, sub {} o do {}, y no se debe utilizar para salir de una operación grep o map.

Note que un bloque por sí mismo es semánticamente idéntico a un bucle que se ejecuta una vez. Por lo tanto next saldrá de ese bloque.

Ver también continue para una ilustración de cómo funcionan last, next y redo.

A diferencia de otros operadores con nombre, tiene la misma precedencia que una asignación. También está exenta de la regla "se-parece-a-una-función", así que next ("foo")."bar" hará que "bar" sea parte del argumento a next.

no Módulo VERSIÓN LISTA
no MÓDULO VERSIÓN
no MÓDULO LISTA
no MÓDULO
no VERSIÓN

Vea la función use, y su opuesta no.

oct EXPR
oct

Interpreta EXPR como una cadena en octal y devuelve el valor correspondiente. (Si EXPR comienza con 0x, se interpreta como una cadena en hexadecimal. Si EXPR empieza con 0b, se interpreta como una cadena binaria. El espacio en blanco que le rodea es ignorado en los tres casos). Lo que le sigue se interpretará como un decimal, binario, octal y hexadecimal en la notación estándar de Perl:

    $val = oct($val) if $val =~ /^0/;

Si se omite EXPR, usa $_. Para hacer lo contrario (producir un número en octal), use sprintf o printf:

    my $dec_perms = (stat("filename"))[2] & 07777;
    my $oct_perm_str = sprintf "%o", $permisos;

La función oct es de uso común cuando una cadena como 644 se tiene que convertir en un modo de archivo, por ejemplo. Aunque Perl convierte automáticamente las cadenas en números según sea necesario, esta conversión automática asume que es en base 10.

Se ignora, y sin avisar, el espacio en blanco superfluo, como también cualquier otro carácter que no sea un dígito, como un punto decimal (oct sólo gestiona números enteros no negativos, no enteros negativos o en punto flotante).

open IDENTIFICADOR_ARCHIVO,EXPR
open IDENTIFICADOR_ARCHIVO,MODO,EXPR
open IDENTIFICADOR_ARCHIVO,MODO,EXPR,LISTA
open IDENTIFICADOR_ARCHIVO,MODO,REFERENCIA
open IDENTIFICADOR_ARCHIVO

Abre el archivo cuyo nombre viene dado por EXPR, y lo asocia con IDENTIFICADOR_ARCHIVO.

Ejemplos sencillos para abrir un archivo en modo lectura:

    open(my $fh, "<", "input.txt")
        or die "No puedo abrir < input.txt: $!";

y para escritura:

    open(my $fh, ">", "output.txt")
        or die "No puedo abrir > output.txt: $!";

(Lo siguiente es una referencia general a open: para una introducción más suave puede considerar el leer perlopentut).

Si IDENTIFICADOR_ARCHIVO es una variable escalar indefinida (o array o elemento hash), un nuevo identificador de archivo es autovivificado, significando que a la variable es asignada una referencia a un nuevo, anónimo y reservado identificador de archivo. De lo contrario, si IDENTIFICADOR_ARCHIVO es una expresión, su valor es el identificador de archivo real. (Esto se considera una referencia simbólica, por lo que use strict "refs" no debe estar activado).

Si se especifican tres (o más) argumentos, es tomado el modo de apertura (incluyendo un codificado opcional) del segundo argumento, a diferencia del nombre del archivo, que estará en el tercer argumento. Si MODO es < o nada, el archivo se abre para lectura. Si MODO es >, el archivo es abierto para salida. Los archivos que ya existan serán truncados ("sobreescritos"); y los que no existan serán creados como nuevos archivos. Si MODO es >>, el archivo es abierto en modo añadir, y de nuevo, será creado si es necesario.

Puede poner un + en frente de > o < para indicar que desea acceder al archivo tanto en lectura como en escritura; así, +< casi siempre es la forma preferida para la lectura/escritura de actualizaciones -el modo +> primero sobreescribirá el archivo-. Por lo general, no puede utilizar el modo de lectura y escritura para la actualización de archivos de texto, ya que tienen registros de longitud variable. Ver la opción -i en perlrun para una mejor aproximación. El archivo se crea con permisos 0666 modificados por el valor de umask del proceso.

Estos prefijos se corresponden con los modos de la función fopen(3) de r, r+, w, w+, a y a+.

En las formas de la llamada de uno y de dos argumentos, el modo y el nombre del archivo debe concatenarse (en ese orden), preferiblemente separados por espacio en blanco. Puede -pero no debe- omitir el modo en estos formatos cuando ese modo sea <. Siempre es más seguro utilizar el formato de dos argumentos de open si el argumento con el nombre de archivo es un literal bien visible.

Para tres o más argumentos, cuando MODO es |-, el nombre del archivo se interpreta como un comando cuya salida va a ser entubada, y si MODO es -|, el nombre del archivo se interpreta como un comando que entuba la salida hacia nosotros. En la forma de dos argumentos (y un argumento), debe sustituir el guión (-) por el comando. Ver "Usando open() por IPC" in perlipc para más ejemplos de sobre esto. (No se le permite hacer un open a un comando que entube tanto en la entrada como en la salida, pero vea IPC::Open2, IPC::Open3, y "Comunicación bidireccional con otro proceso" in perlipc para alternativas sobre esto).

En la forma de tubería tomando tres o más argumentos, si se especifica LISTA (argumentos adicionales después del nombre del comando) entonces LISTA son los argumentos para el comando invocado, si la plataforma lo soporta. El significado de open con más de tres argumentos para modos no entubados aún no está definido, pero "capas" experimentales pueden dar significados adicionales a la LISTA de argumentos adicionales.

En la forma de dos argumentos (y de un argumento), abriendo <- o - abre STDIN, y abriendo >- abre STDOUT.

Puede (y normalmente debería) usar la forma de tres argumentos de open para especificar capas E/S (algunas veces referidas como "disciplinas") para aplicarlas al identificador, afectando al modo en que la entrada y salida son procesadas (vea open y PerlIO para más detalles). Por ejemplo:

  open(my $fh, "<:encoding(UTF-8)", $archivo)
    || die "No puedo abrir $archivo codificado en UTF-8: $!";

abre el archivo codificado en UTF-8 que contiene caracteres Unicode; vea perluniintro. Tenga en cuenta que si las capas se especifican en la forma de tres argumentos, entonces las capas por defecto almacenadas en ${^OPEN} se ignoran (vea perlvar; normalmente fijados por el pragma open o la opción -CioD). Esas capas también se ignorarán si especifica un carácter de dos puntos sin que le siga ningún nombre. En ese caso, se usa la capa predeterminada para el sistema operativo (:raw en Unix, :crlf en Windows).

open() devuelve un valor distinto de cero en caso de éxito, indefinido en otro caso. Si el open contiene una tubería, el valor de retorno pasa a ser el pid del subproceso.

En algunos sistemas (en general, sistemas basados en DOS y Windows) es necesario usar binmode cuando no esté trabajando con un archivo de texto. Para una mejor portabilidad es siempre una buena idea usarlo cuando sea apropiado, y nunca usarlo cuando no sea apropiado. También, la gente puede establecer su E/S para que esté codificado, por defecto, en Unicode UTF-8, y no en bytes.

Al abrir un archivo, es difícil que sea una buena idea seguir si la solicitud ha fallado, por lo que open se utiliza con frecuencia con die. Incluso si die no hace lo que usted quiere (por ejemplo, en un script CGI, en la que desea dar formato a un mensaje de error apropiado (aunque existen módulos que pueden ayudar con ese problema)) controle siempre el valor de retorno de la apertura de un archivo.

Se cerrará el identificador de archivo cuando su contador de referencias llegue a cero. Si es una variable declarada en un ámbito léxico con my, normalmente significa el final del ámbito que la engloba. Sin embargo, este cierre automático no comprueba errores, así que es mejor cerrar explícitamente los identificadores de archivo, especialmente aquellos que se usaron para escribir:

    close($handle)
       || warn "close falló: $!";

Un estilo más viejo es utilizar una palabra simple como identificador de archivo, así

    open(FH, "<", "input.txt")
       or die "No puedo abrir < input.txt: $!";

Entonces puedes usar FH como identificador de archivo, en close FH y <FH> y demás. Note que es una variable global, así que esta forma no es la recomendada en código nuevo.

Como atajo, la llamada con un solo argumento toma el nombre del archivo de la variable escalar global del mismo nombre que el identificador de archivo:

    $ARTICULO = 100;
    open(ARTICULO) or die "No puedo encontrar el artículo $ARTICULO: $!\n";

Aquí, $ARTICULO debe ser una variable escalar global (package), no declarada con my o state.

Como un caso especial, la forma de tres argumentos con un modo de lectura/escritura y el tercer argumento siendo undef:

    open(my $tmp, "+>", undef) or die ...

abre un identificador de archivo a un archivo anónimo temporal. También, usando +< trabaja de forma simétrica, pero debe considerar, escribir antes algo en el archivo temporal. Necesitará llamar a seek antes de leer.

Perl se compila usando PerlIO por defecto. A menos que haya cambiado esto (como compilar Perl con Configure -Uuseperlio), puede abrir identificadores de archivo directamente a escalares Perl de esta forma:

    open(my $fh, ">", \$variable) || ..

Para (re)abrir STDOUT o STDERR como un archivo en memoria, primero, cierrelos:

    close STDOUT;
    open(STDOUT, ">", \$variable)
        or die "No puedo abrir STDOUT: $!";

Ver perliol para información detallada sobre PerlIO.

Ejemplos generales:

 open(my $log, ">>", "/usr/spool/news/twitlog");
 # si open falla, la salida es descartada

 open(my $dbase, "+<", "dbase.mine")      # abrir para actualizar
     or die "No puedo abrir 'dbase.mine' para actualizar: $!";

 open(my $dbase, "+<dbase.mine")          # lo mismo
     or die "No puedo abrir 'dbase.mine' para actualizar: $!";

 open(my $articulo_fh, "-|", "caesar <$articulo")  # decodificar el artículo
                                                 # artículo
     or die "No puedo iniciar caesar: $!";

 open(my $articulo_fh, "caesar <$articulo |")      # lo mismo
     or die "No puedo iniciar caesar: $!";

 open(my $out_fh, "|-", "sort >Tmp$$")    # $$ es el id de nuestro proceso
     or die "No puedo iniciar sort: $!";

 # archivos en memoria
 open(my $memoria, ">", \$var)
     or die "No puedo abrir el archivo en memoria: $!";
 print $memoria "foo!\n";             # la salida aparecerá en $var

Puede también, en la tradición del shell Bourne, especificar una EXPR comenzando con >&, en cuyo caso el resto de la cadena se interpreta como el nombre de un identificador de archivo (o descriptor de archivo, si es numérico) para que sea duplicado (con dup(2)) y luego abierto. Puede usar & después de >, >>, <, +>, +>>, y +<. El modo que especifique debe coincidir con el modo del identificador de archivo original. (Duplicar un identificador de archivo no tiene en cuenta ningún contenido actual de los búfer de E/S). Si utiliza la forma de tres argumentos, entonces puede pasar un número, el nombre de un identificador de archivo o la normal "referencia a un glob".

Aquí hay un script que salva, redirecciona, y restaura STDOUT y STDERR usando varios métodos:

    #!/usr/bin/perl
    open(my $oldout, ">&STDOUT")     or die "No puedo duplicar STDOUT: $!";
    open(OLDERR,     ">&", \*STDERR) or die "No puedo duplicar STDERR: $!";

    open(STDOUT, '>', "foo.out") or die "No puedo redirigir STDOUT: $!";
    open(STDERR, ">&STDOUT")     or die "No puedo duplicar STDOUT: $!";

    select STDERR; $| = 1;  # hacerlo sin búfer
    select STDOUT; $| = 1;  # hacerlo sin búfer

    print STDOUT "stdout 1\n";  # esto funciona
    print STDERR "stderr 1\n";  # también para subprocesos

    open(STDOUT, ">&", $oldout) or die "No puedo duplicar \$oldout: $!";
    open(STDERR, ">&OLDERR")    or die "No puedo duplicar OLDERR: $!";

    print STDOUT "stdout 2\n";
    print 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 C de fdopen(3) de ese descriptor de archivo (y no llamar a dup(2)); esto es lo más parco en descriptores de archivos. Por ejemplo:

    # abrir para lectura, reutilizando el número de descriptor de $fd
    open(my $fh, "<&=", $fd)

o bien

    open(my $fh, "<&=$fd")

o bien

    # abrir para añadir, usando el número de descriptor de $oldfh
    open(my $fh, ">>&=", $oldfh)

Ser parco en identificadores de archivo también es útil (además de ser parsimonioso), por ejemplo cuando algo depende de descriptores de archivo, como por ejemplo, el uso del bloqueo flock. Si sólo hace open(my $A, ">>&", $B), el identificador de archivo $A no tendrá el mismo descriptor de archivo que $B, y por lo tanto flock($A) no hará un flock($B), y viceversa. Pero con open(my $A, ">>&=", $B), los identificadores de archivo compartirán el mismo descriptor de archivo del sistema subyacente.

Tenga en cuenta que si está usando un Perl más viejo que 5.8.0, Perl usa las bibliotecas estándares C de fdopen(3) para implementar la funcionalidad de =. En muchos sistemas Unix, fdopen(3) falla cuando los descriptores de archivo exceden de un valor determinado, por lo general, 255. Para las versiones de Perl 5.8.0 y posteriores, PerlIO es (casi siempre) el valor predeterminado.

Puede ver cuándo su Perl se ha compilado con PerlIO ejecutando perl -V:useperlio. Si dice 'define', tiene PerlIO; de lo contrario, no.

Si abre una tubería en el comando - (es decir, ya sea |- o -| con la forma de uno o dos argumentos de open), entonces se crea un fork implícito, y open regresa dos veces: en el proceso padre devuelve el PID del proceso hijo, y el proceso hijo devuelve un (valor definido) 0. Use defined($pid) o // para determinar cuándo open tuvo éxito.

Por ejemplo, utilice esto

   my $child_pid = open(my $desde_hijo, "-|") // die "No puedo hacer fork: $!";

o bien

   my $child_pid = open(my $al_hijo,   "-|") // die "No puedo hacer fork: $!";

seguido por

    if ($child_pid) {
        # soy el padre:
        # o escribo $al_hijo o leo $desde_hijo
        ...
       waitpid $child_pid, 0;
    } else {
        # soy el hijo; use STDIN/STDOUT de forma normal
        ...
        exit;
    }

El identificador de archivo se comporta de forma normal para el padre, pero la E/S del identificador de archivo es entubada desde/hacia el STDOUT/STDIN del proceso hijo. En el proceso hijo, el identificador de archivo no se abre: la E/S sucede desde/hasta el nuevo STDOUT/STDIN. Habitualmente esto se usa como el open entubado cuando quiere ejercer más control sobre cómo el comando entubado es ejecutado, como cuando se ejecuta con setuid y no quiero tener que escanear comandos del shell buscando metacaracteres.

Los siguientes bloques son, más o menos, equivalentes:

    open(my $fh, "|tr '[a-z]' '[A-Z]'");
    open(my $fh, "|-", "tr '[a-z]' '[A-Z]'");
    open(my $fh, "|-") || exec 'tr', '[a-z]', '[A-Z]';
    open(my $fh, "|-", "tr", '[a-z]', '[A-Z]');

    open(my $fh, "cat -n '$archivo'|");
    open(my $fh, "-|", "cat -n '$archivo'");
    open(my $fh, "-|") || exec "cat", "-n", $archivo;
    open(my $fh, "-|", "cat", "-n", $archivo);

Los dos últimos ejemplos de cada bloque muestra la tubería como "en forma de lista", que todavía no está soportado en todas las plataformas. Una buena regla general es que si su plataforma tiene una verdadera función fork (en otras palabras, si su plataforma es Unix, incluyendo Linux y MacOS X), puede utilizar la forma de lista. Querrá usar la forma de lista de la tubería para que pueda pasar argumentos literales al comando sin el riesgo de que el shell interprete cualquier posible metacarácter que hubiera en ellos. Sin embargo, esto también le impedirá la apertura de tuberías a comandos que, intencionalmente, contenga metacaracteres shell, tales como:

    open(my $fh, "|cat -n | expand -4 | lpr")
        || die "No puedo entubar hacia lpr: $!";

Ver "Aperturas seguras de tuberías" in perlipc para más ejemplos sobre esto.

Perl intentará vaciar todos los archivos abiertos para la salida antes de cualquier operación que pueda hacer un fork, pero esto quizás no esté soportado en algunas plataformas (vea perlport). Para estar seguros, puede necesitar establecer $| ($AUTOFLUSH en el módulo English) o llamar el método autoflush de IO::Handle en cualquiera de los identificadores de archivo abiertos para evitar la pérdida de datos en la salida.

En sistemas que soportan el indicador close-on-exec (cerrar en ejecución) en archivos, este indicador se establecerá para el descriptor de archivo abierto más recientemente según lo determinado por el valor de $^F. Ver "$^F" in perlvar.

Cerrando cualquier identificador de archivo entubado hace que el proceso padre espere a que el hijo termine, y devuelva el valor de estado en $? y en ${^CHILD_ERROR_NATIVE}.

Al nombre del archivo pasado a las formas de uno y dos argumentos de open se le eliminarán los espacios en blanco iniciales y finales, y se activará la redirección por parte de los caracteres especiales. Esta propiedad, conocida como "open() mágico", a menudo se puede utilizar con buenos resultados. Un usuario podría especificar un nombre de archivo como "rsh cat archivo |", o podría cambiar ciertos nombres de archivo, según lo que necesite:

    $archivo =~ s/(.*\.gz)\s*$/gzip -dc < $1|/;
    open(my $fh, $archivo) or die "No puedo abrir $archivo: $!";

Use la forma de tres argumentos para abrir un archivo con una cantidad arbitraria de caracteres extraños, en su nombre,

    open(my $fh, "<", $archivo)
        || die "No puedo abrir $archivo: $!";

de lo contrario es necesario proteger los espacios en blanco iniciales y finales:

    $archivo =~ s#^(\s)#./$1#;
    open(my $fh, "<"$archivo\0")
        || die "No puedo abrir $archivo: $!";

(esto quizás no funcione en algunos sistemas de archivos extraños). Uno debe elegir escrupulosamente entre la magia y la forma de tres argumentos de open:

    open(my $in, $ARGV[0]) || die "No puedo abrir $ARGV[0]: $!";

permitirá al usuario especificar un argumento de la forma "rsh cat archivo |", pero no funcionará en un nombre de archivo que tenga un espacio al final, mientras que

    open(my $in, "<", $ARGV[0])
        || die "No puedo abrir $ARGV[0]: $!";

tendrá exactamente las restricciones contrarias. (Sin embargo, algunos shell soportan la sintaxis perl su_programa.pl <( rsh cat archivo ), que produce un nombre de archivo que se puede abrir de forma normal).

Si busca un "auténtico" open(2) como en C, entonces debe usar la función sysopen, que no incluye ninguna magia (pero puede utilizar, sutilmente, diferentes modos de acceso a archivos que con el open de Perl, que se corresponde a la función del C fopen(3)). Esta es otra manera de proteger los nombres de archivo de su interpretación. Por ejemplo:

    use IO::Handle;
    sysopen(my $fh, $path, O_RDWR|O_CREAT|O_EXCL)
        or die "No puedo abrir $path: $!";
    $fh->autoflush(1);
    print $fh "algo $$\n";
    seek($fh, 0, 0);
    print "El archivo contiene: ", readline($fh);

Vea seek para más detalles acerca de mezclar lectura y escritura.

Cuestiones de portabilidad: "open" in perlport.

opendir IDENTIFICADOR_DIR,EXPR

Abre un directorio llamado EXPR para procesarse por readdir, telldir, seekdir, rewinddir, y closedir. Devuelve verdadero si tuvo éxito. IDENTIFICADOR_DIR puede ser una expresión cuyo valor se puede usar como un identificador de directorio indirecto, normalmente el nombre real del identificador. Si IDENTIFICADOR_DIR es una variable escalar indefinida (o elemento array o hash), a la variable se le asigna una referencia a un nuevo identificador de directorio anónimo; es decir, es autovivificado. Los IDENTIFICADOR_DIR tienen su propio espacio de nombres separados de los IDENTIFICADOR_ARCHIVO.

Vea el ejemplo en readdir.

ord 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, usa $_. (Note que es un carácter, no un byte).

Para lo contrario, vea chr. Vea perlunicode para más información acerca de Unicode.

our LISTAVAR
our TIPO VARLIST
our LISTAVAR : ATRIBUTOS
our TIPO LISTAVAR : ATRIBUTOS

our crea un alias léxico a una variable de paquete (es decir, global) con el mismo nombre en el paquete actual, para usarla dentro del ámbito léxico actual.

our tiene las mismas reglas de ámbito que my o state, significando que solo es válido dentro de un ámbito léxico. A diferencia de my o state, que declaran nuevas variables (léxicas), solo our crea un alias a una variable existente: una variable de paquete del mismo nombre.

Esto significa que cuando use strict 'vars' está activo, our le permite usar una variable de paquete sin calificarla con el nombre de paquete, pero sólo en el ámbito léxico de la declaración our. Esto se aplica inmediatamente, incluso en la misma sentencia.

    package Foo;
    use strict;

    $Foo::foo = 23;

    {
        our $foo;   # alias de $Foo::foo
        print $foo; # imprime 23
    }

    print $Foo::foo; # imprime 23

    print $foo; # ERROR: requiere un nombre explícito de paquete

Esto funciona incluso si la variable de paquete no se haya usado antes, como si las variables de paquete aparecieran a la existencia la primera vez que se usen.

    package Foo;
    use strict;

    our $foo = 23;   # igual que $Foo::foo = 23

    print $Foo::foo; # imprime 23

Ya que la variable se vuelve legal inmediatamente bajo use strict 'vars', así que mientras no exista una variable con ese nombre en ese ámbito, puede entonces referirse a la variable de paquete dentro de la misma sentencia.

    package Foo;
    use strict;

    my  $foo = $foo; # error, el $foo de la parte derecha no está declarado
    our $foo = $foo; # sin errores

Si se lista más de una variable, la lista debe ser puesta entre paréntesis.

    our($bar, $baz);

Una declaración our declara un alias para una variable de paquete que será visible en todo su ámbito léxico, incluso más allá de los límites del paquete. El paquete en el que se introduce la variable se determina en el punto de la declaración, no en el momento de usarse. Esto significa que el siguiente comportamiento cumple que:

    package Foo;
    our $bar;      # declara $Foo::bar para el resto del ámbito léxico
    $bar = 20;

    package Bar;
    print $bar;    # pinta 20, porque se refiere a $Foo::bar

Se permiten múltiples declaraciones our con el mismo nombre en el mismo ámbito léxico si están en diferentes paquetes. Si están en el mismo paquete, Perl emitirá mensajes de advertencia -si los tiene activados-, al igual que múltiples declaraciones de my. A diferencia de una segunda declaración de my, que unirá el nombre a una nueva variable, una segunda declaración de our en el mismo paquete, en el mismo ámbito, es simplemente redundante.

    use warnings;
    package Foo;
    our $bar;      # declara $Foo::bar para el resto del ámbito léxico
    $bar = 20;

    package Bar;
    our $bar = 30; # declara $Bar::bar para el resto del ámbito léxico
    print $bar;    # pinta 30

    our $bar;      # emite una advertencia pero no tiene otro efecto
    print $bar;    # sigue pintando 30

Una declaración our también puede tener una lista de atributos asociados a ella.

La semántica exacta e interfaz de TIPO y ATRIBUTOS están aún en evolución. TIPO está vinculado al uso del <pragma fields, y los atributos se gestionan con el pragma attributes, o a partir de Perl 5.8.0 también a través del módulo Attribute::Handlers. Ver "Variables privadas con my()" in perlsub para más detalles.

Note que con una lista entre paréntesis, se puede utilizar undef como un marcador de posición ficticio, por ejemplo para saltar la asignación de valores iniciales:

    our ( undef, $min, $hora ) = localtime;

our difiere de use vars, que permite usar un nombre no calificado solo dentro del paquete afectado, pero sí en diversos ámbitos.

pack PLANTILLA,LISTA

Toma una LISTA de valores y la convierte en una cadena usando las reglas dadas por la PLANTILLA. La cadena resultante es la concatenación de los valores convertidos. Normalmente, cada valor convertido se parece a su representación a nivel de máquina. Por ejemplo, en máquinas de 32 bits, un entero se puede representar por una secuencia de 4 bytes, que en Perl se presentará como una cadena de cuatro caracteres de longitud.

Vea perlpacktut para una introducción a esta función.

La PLANTILLA es una secuencia de caracteres que dan el orden y el tipo de los valores, de la siguiente manera:

    a  Una cadena con datos binarios arbitrarios, serán rellenados con nulos.
    A  Una cadena de texto (ASCII), será rellenada con espacios.
    Z  Una cadena terminada en cero (ASCIZ), será rellenada con nulos.

    b  Una cadena de bit (en orden de bit ascendente dentro de cada byte,
       like vec()).
    B  Un cadena de bit (en orden de bit descendente dentro de cada byte).
    h  Una cadena hexadecimal (primero el nibble bajo).
    H  Una cadena hexadecimal (primero el nibble alto).

    c  Un valor de un carácter con signo (8 bit).
    C  Un valor de un carácter sin signo (octeto).
    W  Un valor de un carácter sin signo (puede ser mayor de 255).

    s  Un valor de un corto con signo (16 bit).
    S  Un valor de un corto sin signo.

    l  Un valor de un largo con signo (32 bit).
    L  Un valor de un largo sin signo.

    q  Un valor cuádruplo con signo (64 bit).
    Q  Un valor cuádruplo sin signo.
         (Quads están disponibles sólo si su sistema soporta valores de 64-bit
          enteros _y_ si Perl se compiló para soportar
          aquello. En caso contrario, lanza una excepción).

    i  Un valor entero con signo.
    I  Un valor entero sin signo.
         (Este 'entero' es _al_menos_, de 32 bit de ancho. Su exacto
          tamaño depende de lo que un compilador C local llame 'int').

    n  Un corto sin signo (16 bit) en orden "red" (big-endian).
    N  Un largo sin signo (32 bit) en orden "red" (big-endian).
    v  Un corto sin signo (16 bit) en orden "VAX" (little-endian).
    V  Un largo sin signo (32 bit) en orden "VAX" (little-endian).

    j  Un valor entero Perl interno con signo (IV).
    J  Un valor entero Perl interno sin signo (UV).

    f  Un flotante en simple precisión en formato nativo.
    d  Un flotante en doble precisión en formato nativo.

    F  Un valor Perl interno de punto flotante (NV) en formato nativo
    D  Un flotante en doble-largo precisión en formato nativo.
         (Dobles largos están disponibles sólo si su sistema soporta
          valores doble largos _y_ si Perl se compiló para
          soportarlo. En caso contrario, lanza una excepción.
          Note que existen diferentes formatos de dobles largos).

    p  Un puntero a una cadena terminada en nulo.
    P  Un puntero a una estructura (una cadena de longitud fija).

    u  Una cadena codificada con uuencode.
    U  Un número de un carácter Unicode. Codifica a un carácter en modo ca-
       rácter y UTF-8 (o UTF-EBCDIC en plataformas EBCDIC) en
       modo byte.

    w  Un entero comprimido en BER (no en ASN.1 BER, vea perlpacktut
       para detalles). Sus bytes representan un entero sin signo en
       base 128, primero los dígitos más significativos, con el menor número de dígitos
       que sea posible. El octavo bit (el bit más alto) es puesto en cada byte
       excepto el último.

    x  Un byte nulo (es decir, ASCII NUL, "\000", chr(0))
    X  Retrocede un byte.
    @  Relleno con nulos o truncar a una posición absoluta, contado desde el
       inicio del grupo () más interno.
    . Relleno con nulos o truncado a una posición absoluta especificada por
       el valor.
    (  Inicia un grupo ().

Uno o más de los modificadores siguientes pueden, opcionalmente, seguir a ciertas letras en la PLANTILLA (la segunda columna enumeran las letras para las cuales el modificador es válido):

    !   sSlLiI     Fuerza a tamaños nativos (short, long, int) en lugar
                   de tamaños fijos (16-/32-bit).

    !   xX         Hace x y X actuar como comandos de alineamiento.

    !   nNvV       Trata a enteros como con signo, en lugar de sin signo.

    !   @.         Especifica una posición como desplazamiento de byte en la interna
                   representación de la cadena empaquetada. Eficiente
                   pero peligroso.

    >   sSiIlLqQ   Fuerza un orden de bytes en big-endian.
        jJfFdDpP   (El "big end" toca la construcción).

    <   sSiIlLqQ   Fuerza un orden de bytes en little-endian.
        jJfFdDpP   (El "little end" toca la construcción).

Los modificadores > y < también se pueden utilizar en los grupos () para obligar a un orden particular de bytes en todos los componentes de ese grupo, que incluye todos sus subgrupos.

Se aplica las siguientes reglas:

  • Cada letra puede, opcionalmente, estar seguida por un número que indica el número de repeticiones. Un número de repeticiones podría estar opcionalmente encerrada entre paréntesis, como en pack("C[80]", @arr). El número de repeticiones engulle a 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, descrita abajo. El suministro de un * para el número de repeticiones en lugar de un número significa usar tantos elementos como queden, a excepción de:

    • @, x y X, donde es equivalente a 0.

    • ., donde significa relativo al inicio de la cadena.

    • u, donde es equivalente a 1 (o 45, que aquí es equivalente).

    Se puede reemplazar un número de repeticiones con una plantilla de letras encerrada entre corchetes para utilizar la longitud en bytes empaquetada de la plantilla entre corchetes para indicar ese número de repeticiones.

    Por ejemplo, la plantilla x[L] salta tantos bytes como en un largo empaquetado, y la plantilla "$t X[$t] $t" desempaqueta dos veces lo que $t desempaquete (cuando se expanda la variable). Si la plantilla que figura entre corchetes contiene los comandos de alineación (como x![d]), su longitud se calculará como si el comienzo de la plantilla tuviera la máxima alineación posible.

    Cuando se utiliza con Z, un * como el número de repeticiones, está garantizado que añadirá un byte nulo final, por lo que la cadena resultante es siempre un byte más largo que la longitud en bytes del propio elemento.

    Cuando se utiliza con @, el número de repeticiones representa un desplazamiento desde el inicio del grupo () más interior.

    Cuando se utiliza con ., el número de repeticiones determina la posición de partida para calcular el valor de desplazamiento de la siguiente manera:

    • Si el número de repeticiones es 0, es relativa a la posición actual.

    • Si el número de repeticiones es *, el desplazamiento es relativo al inicio de la cadena empaquetada.

    • Y si es un número entero n, el desplazamiento es relativo al inicio del n-ésimo grupo () más interno, o al inicio de la cadena si n es más grande que el número de grupos.

    El número 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 sustituidos por 45. El número de repeticiones no debe ser mayor de 65.

  • Los tipos a, A, y Z absorben un solo valor, pero se empaqueta como una cadena de longitud indicada, rellenada con nulos o espacios según sea necesario. Al desempaquetar, A elimina el espacio en blanco y nulos sobrantes del final, Z elimina todo después del primer nulo, y a devuelve los datos sin ningún tipo de recorte.

    Si el valor a empaquetar es demasiado largo, el resultado se trunca. Si es demasiado largo y se indica un contador explícito, Z empaqueta solo $contador-1 bytes, seguido por un byte nulo. Por lo tanto Z siempre empaqueta un valor nulo adicional, excepto cuando el contador es 0.

  • Del mismo modo, los formatos b y B empaquetan una cadena con una dada longitud de bits. Cada uno de estos formatos genera un bit del resultado. Estos suelen ser seguidos por un número de repetición, como B8 o B64.

    Cada bit resultante se basa en el bit menos significativo del correspondiente carácter de la entrada, es decir, en ord($carácter)%2. En particular, los caracteres "0" y "1" generan los bits 0 y 1, al igual que los caracteres "\000" y "\001".

    A partir del comienzo de la cadena de entrada, cada 8-tupla de caracteres se convierte en un carácter de la salida. Con el formato b, el primer carácter de la 8-tupla determina el bit menos significativo de un carácter; con el formato B, se determina el bit más significativo de un carácter.

    Si la longitud de la cadena de entrada no es divisible por 8, el resto se rellena como si la cadena de entrada estuviera completada con caracteres nulos hasta el final. Del mismo modo durante el desempaquetado, los bits "extra" se ignoran.

    Si la cadena de entrada es más larga de lo necesario, los caracteres sobrantes se ignoran.

    Un * como contador de repetición utiliza todos los caracteres del campo de entrada. Al desempaquetar, los bits se convierten a una cadena de 0 y 1.

  • El formato h y H empaqueta una cadena con tantos nibles (grupos de 4 bits, representables como dígitos hexadecimales, "0" .. "9" "a" .. "f") contenga.

    Para cada formato así, pack genera 4 bits del resultado. Con caracteres no-alfabéticos, el resultado se basa en los 4 bits menos significativos del carácter de entrada, es decir, en ord($carácter)%16. En particular, los caracteres "0" y "1" generan los nibles 0 y 1, así como los bytes "\000" y "\001". Para los caracteres "a".."f" y "A".."F", el resultado es compatible con los dígitos hexadecimales acostumbrados, de modo que "a" y "A" generan ambos el nible 0xA==10. Utilice sólo estos caracteres hexadecimales con este formato.

    A partir del comienzo de la plantilla a pack, cada par de caracteres se convierte en un carácter en la salida. Con el formato h, el primer carácter del par determina el nible menos significativo de la salida de caracteres; con el formato H, determina el nible más significativo.

    Si la longitud de la cadena de entrada no es par, se comporta como si estuviera rellenada con un carácter nulo al final. Del mismo modo, los nibles "extra" se ignoran durante el desempaquetado.

    Si la cadena de entrada es más larga de lo necesario, los caracteres sobrantes se ignoran.

    Un * como contador de repetición utiliza todos los caracteres del campo de entrada. Para unpack, los nibles se convierten en una cadena de dígitos hexadecimales.

  • El formato p empaqueta un puntero a una cadena terminada en nulo. Usted es responsable de asegurarse que la cadena no es un valor temporal, ya que podría quedar desasignado antes de poder usar el resultado empaquetado. El formato P empaqueta un puntero a una estructura del tamaño indicado por la longitud. Un puntero nulo se crea si el valor correspondiente para p o P es undef; de forma similar con unpack, 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 ni tan grande como un int, ni tan grande como un long- quizás no pueda ser posible empaquetar o desempaquetar punteros en orden big-endian o little-endian. Intentarlo, lanza una excepción.

  • La plantilla / permite empaquetar y desempaquetar una secuencia de elementos en donde la estructura empaquetada contiene un contador de elementos empaquetados seguido por los propios elementos empaquetados. Esto es útil cuando la estructura que está desempaquetando tiene codificados los tamaños o recuentos de repetición para algunos de sus campos dentro de la propia estructura como campos separados.

    Para pack, escriba longitud-item/secuencia-item, y la longitud-item indica el valor de la longitud de lo que está empaquetado. Formatos de mayor uso son los empaquetados de enteros como el n para las cadenas de Java, w de ASN.1 o SNMP, y N de XDR de Sun

    Para pack, secuencia-ítem puede tener un contador de repeticiones, en cuyo caso el mínimo de él y del número de elementos disponibles se usa como el argumento para longitud-ítem. Si no tiene contador de repeticiones o utiliza un '*', se utiliza el número de elementos disponibles.

    Para unpack, se usa una pila interna de argumentos enteros desempaquetados. Escriba /secuencia-item y el contador de repeticiones se obtiene extrayéndolo del último elemento de la pila. La secuencia-item no debe tener un contador de repeticiones.

    Si secuencia-item se refiere a un tipo de cadena de caracteres ("A", "a", o "Z"), la longitud-item es la longitud de la cadena, no el número de cadenas. Con un contador de repeticiones explícito para el empaquetado, la cadena de empaquetado se ajusta a esa longitud. Por ejemplo:

     Este código:                           da este resultado:
    
     unpack("W/a", "\004Gurusamy")          ("Guru")
     unpack("a3/A A*", "007 Bond  J ")      (" Bond", "J")
     unpack("a3 x2 /A A*", "007: Bond, J.") ("Bond, J", ".")
    
     pack("n/a* w/a","hola,","mundo")      "\000\004hola,\005mundo"
     pack("a/W2", ord("a") .. ord("z"))    "2ab"

    La longitud-item no se devuelve de forma explícita desde unpack.

    Indicando un contador al formato longitud-item solo es útil para A, a, o Z. Empaquetando con un longitud-item de a o Z puede introducir caracteres "\000", que Perl no considerará como legal en cadenas numéricas.

  • Los tipos enteros s, S, l, y L pueden ser seguidos por un modificar ! para especificar un corto (short) o largo (long) nativos. Como se muestra en el ejemplo anterior, una simple l significa exactamente 32 bits, aunque el long nativo, tal como lo ve el compilador de C local, puede ser mayor. Esto es sobre todo un problema en plataformas de 64-bits. Se puede ver si usando ! provoca alguna diferencia, de esta manera:

        printf "formato s es %d, s! es %d\n",
            length pack("s"), length pack("s!");
    
        printf "formato l es %d, l! es %d\n",
            length pack("l"), length pack("l!");

    i! y I! también están permitidos, pero solo a efectos de completar: son idénticos a i y I.

    Los tamaños reales (en bytes) de short, int, long y long largos nativos en la plataforma donde Perl fue compilado también están disponibles desde la línea de comandos:

        $ perl -V:{short,int,long{,long}}size
        shortsize='2';
        intsize='4';
        longsize='4';
        longlongsize='8';

    o programáticamente a través del módulo Config:

           use Config;
           print $Config{shortsize},    "\n";
           print $Config{intsize},      "\n";
           print $Config{longsize},     "\n";
           print $Config{longlongsize}, "\n";

    $Config{longlongsize} es indefinido en sistemas sin soporte de long largo.

  • Los formatos enteros s, S, i, I, l, L, j, y J inherentemente no portátiles entre procesadores y sistemas operativos porque siguen el orden nativo de los bytes. Por ejemplo, un entero de 4 bytes 0x12345678 (305419896 en decimal) se ordenaría nativamente (dispuesto en y gestionado por los registros de la CPU) en bytes como

        0x12 0x34 0x56 0x78  # big-endian    (byte superior antes)
        0x78 0x56 0x34 0x12  # little-endian (byte inferior antes

    Básicamente, Intel y VAX son little-endian, mientras que todos los demás, incluyendo Motorola m68k/88k, PPC, Sparc, HP PA, Power y Cray, son big-endian. Alpha y MIPS pueden ser: Digital/Compaq utilizados (bueno, usados) en modo little-endian, pero SGI/Cray los usa en modo big-endian.

    Los nombres big-endian y little-endian son referencias cómicas a los hábitos alimenticios de comer huevos por el extremo pequeño de los Liliputienses y por el extremo grande de los Blefuscudianos de la clásica sátira de Jonathan Swift, Los Viajes de Gulliver . Esto entró en la jerga informática a través del documento "On Holy Wars and a Plea for Peace" (De las Guerras Santas y un llamamiento por la Paz), de Danny Cohen, USC/ISI IEN 137, 1 de abril de 1980.

    Algunos sistemas pueden tener ordenaciones de byte aún más raras.

       0x56 0x78 0x12 0x34
       0x34 0x12 0x78 0x56

    Se llaman mid-endian, middle-endian, mixed-endian, o solo algo raro.

    Puede determinar la ordenación de bytes de su sistema con este conjuro:

       printf("%#02x ", $_) for unpack("W*", pack L=>0x12345678);

    El orden de los bytes en la plataforma donde Perl fue compilado está también disponible vía Config:

        use Config;
        print "$Config{byteorder}\n";

    o desde la línea de comandos:

        $ perl -V:byteorder

    Las ordenaciones "1234" y "12345678" son little-endian; "4321" y "87654321" son big-endian. Sistemas con binarios multiarquitectura serán "ffff", indicando que la información estática no funciona, y que se deben hacer pruebas en tiempo de ejecución.

    Para enteros empaquetados de forma portátil, o bien usar los formatos n, N, v, y V o bien los modificadores > y < descritos a continuación. Vea también perlport.

  • También los números en punto flotante tienen distintas ordenaciones. Normalmente (pero no siempre) coincide con la ordenación de los enteros. Incluso aunque la mayor parte de las plataformas de nuestros días usan el formato binario IEEE 754, hay diferencias, especialmente si están implicados los dobles largos. Puede consultar las variables de Config, doublekind y longdblkind (también doublesize, longdblsize): la "clase" de valores se enumeran, a diferencia de byteorder.

    La mejor opción para una buena portabilidad es, probablemente, mantener los dobles de 64 bit IEEE 754, y seguir la ordenación de los bytes del sistema. Otra posibilidad es el formato "%a") de printf.

  • A partir de Perl 5.10.0, los formatos de enteros y de punto flotante, junto con los formatos p y P y los grupos (), se podrán continuar con los modificadores de ordenación de bytes > o <, para forzar, respectivamente, el orden de bytes big-endian o little-endian. Estos modificadores son especialmente útiles dado que n, N, v y V no cubren valores enteros con signo, enteros de 64 bits, o de punto flotante.

    Éstas son algunas de las preocupaciones a tener en cuenta cuando se usa un modificador de ordenación:

    • Intercambiando enteros con signo entre distintas plataformas funciona sólo cuando todas 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, así que por lo general esto no es ningún problema.

    • Los modificadores > o < solo pueden usarse con formatos de punto flotante en máquinas con ordenación big-endian o little-endian. De lo contrario, al tratar de usarlos lanzará una excepción.

    • Forzar una ordenación de bytes en valores de punto flotante para el intercambio de datos sólo puede funcionar si todas las plataformas utilizan la misma representación binaria de punto flotante IEEE. Incluso si todas las plataformas usan IEEE, todavía puede haber diferencias sutiles. El ser capaz de usar > o < en valores de punto flotante puede ser útil, pero también peligroso si no sabe exactamente lo que está haciendo. No es una forma general de almacenar de forma portátil los valores de punto flotante.

    • Cuando se usa > o < en un grupo (), afecta a todos los tipos dentro del grupo que acepten a los modificadores de ordenación de bytes, incluyendo a todos los subgrupos. Se ignora silenciosamente todos los demás tipos. No está autorizado a anular la ordenación de bytes dentro de un grupo que ya tenga un sufijo de modificador de ordenación de bytes.

  • Los números reales (float y double) solo están en formato nativo de la máquina. Debido a la multiplicidad de formatos de punto flotante y la falta de una norma de representación en la "red" para ellos, no hay ninguna facilidad para el intercambio de datos. Esto significa que datos empaquetados de punto flotante escritos en una máquina quizás no puedan leerse en otra, aunque ambas utilizan aritmética IEEE de punto flotante (porque la ordenación de bytes de la representación en memoria no es parte de la especificación IEEE). Vea también perlport.

    Si sabe exactamente lo que está haciendo, puede usar los modificadores > o < para forzas una ordenación de bytes de los valores.

    Debido a que Perl utiliza dobles (o dobles largos, si está configurado así) internamente para todos cálculos numéricos, convirtiendo de doble en flotante y de allí a doble de nuevo, pierde precisión, por lo que unpack("f", pack("f", $foo)) no será, generalmente, igual a $foo.

  • pack y unpack pueden funcionar de dos modos: modo de caracteres (modo C0) donde la cadena empaquetada se procesa por cada carácter, y el modo byte UTF-8 (modo U0) donde la cadena empaquetada se procesa en su formato codificado en UTF-8, byte a byte. El modo carácter es el predeterminado a menos que la cadena de formato empiece con U. Siempre puede cambiar de modo con un explícito C0 o U0 en mitad del formato. Este modo permanece activo hasta el cambio del modo siguiente, o hasta el final del grupo () en que se aplicó directamente.

    Usar C0 para obtener los caracteres Unicode mientras se utiliza U0 para obtener bytes no Unicode, no es necesariamente obvio. Probablemente le valga con algunos de estos ejemplos:

        $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
          perl -CS -ne 'printf "%v04X\n", $_ for unpack("C0A*", $_)'
        03B1.03C9
        $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
          perl -CS -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
        CE.B1.CF.89
        $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
          perl -C0 -ne 'printf "%v02X\n", $_ for unpack("C0A*", $_)'
        CE.B1.CF.89
        $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
          perl -C0 -ne 'printf "%v02X\n", $_ for unpack("C0A*", $_)'
        C3.8E.C2.B1.C3.8F.C2.89

    Estos ejemplos también ilustran que no debería tratar de usar pack/unpack como un sustituto del módulo Encode.

  • Debe hacer cualquier alineamiento o rellenado, insertando, por ejemplo, suficientes "x", mientras desempaqueta. No hay forma, para un pack y unpack, saber qué caracteres van o vienen, por lo que controlan su salida y entrada como secuencias planas de caracteres.

  • Un grupo () es una sub-PLANTILLA encerrada entre paréntesis. Un grupo puede tener un contador de repeticiones, ya sea de forma postfija, o para unpack, también a través del carácter de plantilla /. Dentro de cada repetición de un grupo, posicionarse con @ comienza de nuevo en 0. Por lo tanto, el resultado de

        pack("@1A((@2A)@3A)", qw[X Y Z])

    es la cadena "\0X\0\0YZ".

  • x y X aceptan el modificar ! para actuar como comando de alineamiento: saltan hacia adelante o atrás a la posición más cercana alineada a un múltiplo de contador caracteres. Por ejemplo, para pack o unpack una estructura en C como

        struct {
            char   c;    /* uno con signo, carácter 8-bit */
            double d;
            char   cc[2];
        }

    puede tener que usar la plantilla c x![d] d c[2]. Esto supone que los dobles deben estar alineados con el tamaño de un doble.

    Para los comandos de alineación, un contador de 0 es equivalente a un contador de 1; ambos son instrucciones no efectivas.

  • n, N, v y V aceptan el modificador ! para representar enteros de 16-/32-bit con signo en distinta ordenación de bytes. Esto es portátil solo cuando todas las plataformas compartiendo datos empaquetados usa la misma representación binaria de enteros con signo; por ejemplo, cuando todas las plataformas utilizan la representación de complemento a dos.

  • Los comentarios pueden integrarse en una PLANTILLA usando # hasta el final de la línea. El espacio en blanco puede separar los códigos de empaquetado, pero los modificadores y los contadores de repetición deben seguir de inmediato. Rompiendo plantillas complejas en líneas individuales, debidamente comentadas, puede servir para mejorar la legibilidad y facilitar el mantenimiento de los formatos pack/unpack, como /x lo es para las expresiones regulares complicadas.

  • Si PLANTILLA requiere más argumentos de los que se pasan a pack, éste asume que los argumentos adicionales son iguales a "". Si PLANTILLA requiere menos argumentos de los que se le dan, los argumentos adicionales se ignoran.

  • Intentar empaquetar los valores especiales de punto flotante Inf y NaN (infinito, también en negativo), y no-es-un-número) en valores enteros empaquetados (como "L") es un error fatal. La razón de esto es que, sencillamente, no existe ningún mapeo sensato para estos valores especiales, en enteros.

Ejemplos:

    $foo = pack("WWWW",65,66,67,68);
    # foo es "ABCD"
    $foo = pack("W4",65,66,67,68);
    # lo mismo
    $foo = pack("W4",0x24b6,0x24b7,0x24b8,0x24b9);
    # lo mismo con letras Unicode acentuadas.
    $foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9);
    # lo mismo con letras Unicode acentuadas. No obtiene
    # los bytes UTF-8 porque la U al principio del formato causó
    # un cambio al modo U0, así que los bytes UTF-8 se han unido en
    # caracteres
    $foo = pack("C0U4",0x24b6,0x24b7,0x24b8,0x24b9);
    # foo es "\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 = pack("ccxxcc",65,66,67,68);
    # foo es "AB\0\0CD"

    # NOTA: Los ejemplos anteriores de "W" y "c" son correctos
    # solo en sistemas ASCII y derivados, como ISO Latin 1
    # y UTF-8. En sistemas EBCDIC, el primer ejemplo sería
    #      $foo = pack("WWWW",193,194,195,196);

    $foo = pack("s2",1,2);
    # "\001\000\002\000" en little-endian
    # "\000\001\000\002" en big-endian

    $foo = pack("a4","abcd","x","y","z");
    # "abcd"

    $foo = pack("aaaa","abcd","x","y","z");
    # "axyz"

    $foo = pack("a14","abcdefg");
    # "abcdefg\0\0\0\0\0\0\0"

    $foo = pack("i9pl", gmtime);
    # una auténtica struct tm (en mi sistema)

    $utmp_template = "Z8 Z8 Z16 L";
    $utmp = pack($utmp_template, @utmp1);
    # una struct utmp (del BSD)

    @utmp2 = unpack($utmp_template, $utmp);
    # "@utmp1" eq "@utmp2"

    sub bintodec {
        unpack("N", pack("B32", substr("0" x 32 . shift, -32)));
    }

    $foo = pack('sx2l', 12, 34);
    # un 12 short, dos bytes cero de relleno, un 34 long
    $bar = pack('s@4l', 12, 34);
    # un 12 short, relleno con ceros a la posición 4, un 34 long
    # $foo eq $bar
    $baz = pack('s.l', 12, 4, 34);
    # un 12 short, relleno con ceros a la posición 4, un 34 long

    $foo = pack('nN', 42, 4711);
    # empaqueta 16 y 32-bit enteros sin signo, en big-endian
    $foo = pack('S>L>', 42, 4711);
    # exactamente lo mismo
    $foo = pack('s<l<', -42, 4711);
    # empaqueta 16 y 32-bit enteros con signo, en little-endian
    $foo = pack('(sl)<', -42, 4711);
    # exactamente lo mismo

La misma plantilla se puede usar, generalmente, con unpack.

package ESPACIO_NOMBRES
package ESPACIO_NOMBRES VERSIÓN
package ESPACIO_NOMBRES BLOQUE
package ESPACIO_NOMBRES VERSIÓN BLOQUE

Declara el BLOQUE o el resto de la unidad de compilación como pertenecientes al espacio de nombres especificado. El ámbito de la declaración del paquete es, tanto el BLOQUE suministrado o, en ausencia de un BLOQUE, desde la misma declaración hasta el final del ámbito actual (el bloque, archivo o eval que lo engloba). Es decir, las formas sin un BLOQUE son operativas hasta el final del ámbito actual, al igual que los operadores my, state y our. Todos los identificadores dinámicos no calificados en este ámbito pertenecerán al espacio de nombres indicado, salvo cuando se reemplace por otra declaración package o cuando sean uno de los identificadores especiales que califican dentro de main::, al igual que STDOUT, ARGV, ENV, y las variables especiales de caracteres de puntuación.

Una instrucción package afecta sólo a las variables dinámicas, incluyendo las que haya usado con local, pero no a las variables de ámbito léxico, que se crean con my, state o our. Normalmente será la primera declaración en un archivo incluido por medio de un require o use. Usted puede cambiar de paquete en más de un lugar, ya que sólo determina qué tabla de símbolos, por defecto, se utilizará por el compilador para el resto de ese bloque. Puede hacer referencia a los identificadores de otros paquetes distintos del actual anteponiendo el identificador con el nombre del paquete y un dos puntos doble, como en $AlgunPaquete::var o EstePaquete::CONTROLADOR_ENTRADA. Si el nombre del paquete se omite, se asume que es main. Es decir, $::sail es equivalente a $main::sail (y también a $main'sail, algo que se puede ver en código muy antiguo, escrito en su mayoría en Perl 4).

Si se indica VERSIÓN, package inicializa la variable $VERSION en el espacio de nombres indicado a un objeto version con la VERSIÓN indicada. VERSIÓN debe ser un número de versión al estilo "estricto", según lo define el módulo version: un número decimal positivo (entero o decimal) sin exponentes o una v-cadena con una 'v' precedente con al menos tres componentes. Debe ajustar el valor de $VERSION solo una vez por paquete.

Ver "Paquetes" in perlmod para más información sobre paquetes, módulos y clases. Ver perlsub para otras cuestiones sobre el ámbito o contexto.

__PACKAGE__

Un token especial que devuelve el nombre del paquete en el que aparece.

pipe IDENTIFICADOR_LECTURA,IDENTIFICADOR_ESCRITURA

Abre un par de tuberías conectadas como lo hace correspondiente llamada al sistema. Tenga en cuenta que si se establece un circuito de procesos entubados, puede producirse un bloqueo mortal a menos que sea muy cuidadoso. Además, tenga en cuenta que las tuberías de Perl utilizan el búfer de E/S, así que puede que necesite establecer $| para limpiar su IDENTIFICADOR_ESCRITURA después de cada comando, dependiendo de la aplicación.

Devuelve verdadero en caso de éxito.

Ver IPC::Open2, IPC::Open3, y "Comunicación Bidireccional con otro proceso" in perlipc para ejemplos de estas cosas.

En los sistemas que soportan el indicador "cerrado-en-ejecución" en los archivos, ese indicador se establece en todos los nuevos descriptores de archivos abiertos cuyo fileno sean más altos que el valor actual de $^F (por defecto 2 para STDERR). Ver "$^F" in perlvar.

pop ARRAY
pop

Extrae y devuelve el último valor del array, acortando el array en un elemento.

Devuelve el valor indefinido si el array está vacío, aunque esto también puede suceder en otras situaciones. Si se omite ARRAY, se extrae desde el array @ARGV en el programa principal, y del array @_ en subrutinas, igual que shift.

A partir de 5.14, una característica experimental permitía a pop tomar una expresión escalar. Se ha considerado que este experimento no ha funcionado, y se quitó a partir de Perl 5.24.

pos ESCALAR
pos

Devuelve el desplazamiento desde donde la última búsqueda m//g terminó para la variable en cuestión ($_ es la que se usa cuando no se especifica ninguna otra variable). Tenga en cuenta que 0 es un desplazamiento válido de la coincidencia. undef indica que la posición de búsqueda se restablece (generalmente debido a un error de coincidencia, pero también puede ser porque aún no se ha ejecutado la coincidencia sobre 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, por lo que también influirá en la aserción de ancho cero \G en las expresiones regulares. Estos dos efectos toman lugar en la siguiente coincidencia, por lo que no puede afectar a la posición con pos durante la coincidencia actual, como en (?{pos() = 5}) o s//pos() = 5/e.

Actualizando pos también reinicializa el indicador que coincide-con-longitud-cero, descrita en "Coincidiendo con patrones repetidos en una cadena de longitud cero" in perlre.

Debido a que una coincidencia m//gc fallida no reinicia el desplazamiento, el retorno de pos no cambiará en ningún caso. Vea perlre y perlop.

print

Imprime una cadena o una lista de cadenas. Devuelve verdadero si tuvo éxito. IDENTIFICADOR_ARCHIVO puede ser una variable escalar conteniendo el nombre de o una referencia al identificador de archivo, introduciendo así un nivel más de indirección. (NOTA: Si IDENTIFICADOR_ARCHIVO es una variable y el siguiente token es un término, se puede malinterpretar como un operador a menos que interponga un + o ponga los argumentos entre paréntesis). Si se omite IDENTIFICADOR_ARCHIVO, se imprime al canal de salida seleccionado por última vez (vea select). Si la LISTA se omite, se imprime $_ al actual canal de salida seleccionado. Para utilizar solamente IDENTIFICADOR_ARCHIVO para imprimir en él el contenido de $_, debe ser un identificador de archivo real, como FH, no uno indirecto como $fh. Para configurar el controlador de salida predeterminado a otro valor distinto que STDOUT, use el operador select.

El valor actual de $, (si lo tiene) es impreso entre cada elemento de la LISTA. El valor actual de $\ (si lo tiene) es impreso después de que toda la LISTA se haya impreso. Debido a que print toma una LISTA, cualquier cosa en la LISTA se evalúa en contexto de lista, incluyendo cualquier subrutina que devuelva listas. Tenga cuidado de no seguir la palabra clave print con un paréntesis de apertura a menos que desee que el correspondiente paréntesis de cierre ponga fin a los argumentos de la impresión; ponga paréntesis alrededor de todos los argumentos (o interponga un +, pero esto no parece tan bonito).

Si está almacenando identificadores en un array o hash, o en general, en cualquier expresión más compleja que un simple identificador o una sencilla variable escalar sin subíndice, para acceder a él, tendrá que utilizar un bloque que retorne el valor del identificador de archivo, en cuyo caso la LISTA no se puede omitir:

    print { $archivos[$i] } "cosas\n";
    print { $OK ? STDOUT : STDERR } "cosas\n";

Imprimir a una tubería o socket cerrados generará una señal SIGPIPE. Ver perlipc para más información sobre el manejo de señales.

printf IDENTIFICADOR_ARCHIVO FORMATO, LISTA
printf IDENTIFICADOR_ARCHIVO
printf FORMATO, LISTA
printf

Equivalente a print IDENTIFICADOR_ARCHIVO sprintf(FORMATO, LISTA), excepto que $\ (el separador de registro a la salida) no se añade. El FORMATO y la LISTA son, de hecho, interpretados como una sola lista. El primer argumento de la lista se interpretará como el formato para printf. Esto significa que printf(@_) utilizará $_[0] como el formato. Vea sprintf para una explicación del argumento de formato. Si use locale (incluyendo use locale ':not_characters') está en activo y se ha llamado a POSIX::setlocale, el carácter utilizado para el separador decimal en números formateados en punto flotante se ve afectado por la configuración regional de LC_NUMERIC. Vea perllocale y POSIX.

Por razones históricas, si omite la lista, se usará $_ como formato; para usar un IDENTIFICADOR_ARCHIVO sin una lista, debe usar un identificador de archivo simple, como FH, no uno indirecto como $fh. Aun así, esto raramente será lo que quiera hacer; si $_ contiene códigos de formateo, se reemplazarán con la cadena vacía y se emitirá un aviso, si los avisos están habilitados. Use un solo print si quiere imprimir los contenidos de $_.

No caiga en la trampa de utilizar un printf cuando valdría un simple print. El print es más eficiente y menos propenso a errores.

prototype FUNCIÓN
prototipo

Devuelve el prototipo de una función como una cadena (o undef si la función no tiene ningún prototipo). FUNCIÓN es una referencia a, o el nombre de, la función cuyo prototipo se desea recuperar. Si se omite FUNCIÓN, se usa $_.

Si FUNCIÓN es una cadena que comienza con CORE::, el resto es tomado como un nombre para una función predefinida de Perl. Si los argumentos de la función predefinida no se pueden expresar adecuadamente por un prototipo (como en system), prototype devuelve undef, porque la orden interna en realidad no se comporta como una función de Perl. De lo contrario, se devuelve la cadena que describe el prototipo equivalente.

push ARRAY,LISTA

Considera a ARRAY como una pila añadiendo los valores de LISTA al final de ARRAY. La longitud de ARRAY se incrementa por la misma cantidad que la longitud de LISTA. Tiene el mismo efecto que

    for my $valor (LISTA) {
        $ARRAY[++$#ARRAY] = $valor;
    }

pero es más eficiente. Devuelve el número de elementos en el array tras la llamada a push.

A partir de 5.14, una característica experimental permitía a push tomar una expresión escalar. Se ha considerado que este experimento no ha funcionado, y se quitó a partir de Perl 5.24.

q/CADENA/
qq/CADENA/
qw/CADENA/
qx/CADENA/

Comillas generales. Ver "Operadores entrecomillados" in perlop.

qr/CADENA/

Entrecomillado de expresión regular. See "Operadores Regex" in perlop.

quotemeta EXPR
quotemeta

Devuelve el valor de EXPR con todos los caracteres ASCII que no formen parte de una "palabra" escapados con una barra diagonal inversa. (Es decir, todos los caracteres ASCII que no se ajusten a /[A-Za-z_0-9]/ serán precedidos por una barra diagonal inversa en la cadena devuelta, con independencia de cualquier configuración regional). Esta es la función interna que implementa el escapado de \Q en las cadenas con doble entrecomillado. (Vea más abajo para el comportamiento en códigos de carácter que no son ASCII).

Si se omite EXPR, usa $_.

quotemeta (y \Q ... \E) son útiles cuando se interpolan cadenas en expresiones regulares, porque por defecto una variable interpolada será considerada una mini expresión regular. Por ejemplo:

    my $instruccion = 'El rápido zorro marrón saltó sobre el perezoso perro';
    my $subcadena = 'rápido.*?zorro';
    $instruccion =~ s{$subcadena}{gran lobo malo};

Hará que $instruccion se convierta en 'El gran lobo malo saltó sobre ...'.

De otra forma:

    my $instruccion = 'El rápido zorro marrón saltó sobre el perezoso perro';
    my $subcadena = 'rápido.*?zorro';
    $instruccion =~ s{\Q$subcadena\E}{gran lobo malo};

o:

    my $instruccion = 'El rápido zorro marrón saltó sobre el perezoso perro';
    my $subcadena = 'rápido.*?zorro';
    my $subcadena_escapada = quotemeta($subcadena);
    $instruccion =~ s{$subcadena_escapada}{gran lobo malo};

Ambas dejará la instrucción como estaba. Normalmente, se debe usar quotemeta o \Q al aceptar cadenas de entrada provenientes del usuario.

En Perl 5.14, todos los caracteres no ASCII se marcan con caracteres de escape en las cadenas no codificadas como UTF-8; en las cadenas UTF-8 no se marcan.

A partir de Perl v5.16, Perl adopta una estrategia definida en Unicode en el escapado de caracteres no ASCII; el escapado de caracteres ASCII no ha cambiado.

Se sigue aplicando el escapado de cadenas no UTF-8 cuando se esté fuera del ámbito de use feature 'unicode_strings', que consiste en escapar a todos los caracteres del rango superior de Latin1. Esto proporciona una completa compatibilidad hacia atrás para los programas antiguos que no utilizan Unicode. (Tenga en cuenta que unicode_strings se activa automáticamente en el ámbito de use v5.12 o mayor).

Dentro del ámbito de use locale, todos los códigos de carácter que no sean ASCII Latin1, se escapan tanto si la cadena está codificada en UTF-8 como si no. Como se mencionó anteriormente, la configuración regional no afecta al escapado de caracteres del rango ASCII. Esto protege contra configuraciones regionales con caracteres como "|" que son considerados como caracteres que forman parte de las palabras.

De lo contrario, Perl escapa caracteres no ASCII utilizando una adaptación de Unicode (vea http://www.unicode.org/reports/tr31/). Los únicos códigos de carácter que son escapados son los 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, los dos más importantes son Pattern_Syntax y Pattern_White_Space. Han sido creadas por Unicode para, exactamente, este propósito de decidir qué caracteres en un patrón de expresión regular debe ser escapado. Ningún carácter que puede ir en un identificador tiene estas propiedades.

Perl promete, que si alguna vez añadimos metacaracteres de patrones de expresión regular a la docena que ya está definida (\ | ( ) [ { ^ * $ + ? .), sólo usaremos aquellos que tengan la propiedad Pattern_Syntax. Perl también promete, que si alguna vez añadimos caracteres que se han de considerar como espacio en blanco en las expresiones regulares (actualmente, las más afectadas serán las que tengan el /x), todos ellos tendrán la propiedad Pattern_White_Space.

Unicode promete que el conjunto de códigos de carácter que tienen estas dos propiedades nunca cambiará, así que algo que no se escape en v5.16 nunca tendrá que escaparse en cualquier futura versión de Perl. (No todos los códigos de carácter que coinciden con Pattern_Syntax tienen realmente caracteres asignados a ellos; así que hay espacio para crecer, pero son desactivados tanto si están asignados como si no. Perl, por supuesto, nunca usaría un punto de código asignado como un metacarácter real).

Escapar caracteres que tienen las otras 3 propiedades se hace para mejorar la legibilidad de la expresión regular y no porque realmente se necesita que estén escapados para los fines de las expresiones regulares (caracteres con la propiedad White_Space es probable que sean indistinguibles en la página o en la pantalla de los que tienen la propiedad Pattern_White_Space; y las otras dos propiedades contienen caracteres no imprimibles).

rand EXPR
rand

Devuelve un número decimal aleatorio mayor o igual a 0 y menor que el valor de EXPR. (EXPR debe ser positiva). Si la EXPR se omite, se usa 1. Actualmente EXPR con el valor de 0 es también un caso especial como el de 1 (no estaba documentado esto antes de Perl 5.8.0 y está sujeto a cambios en futuras versiones de Perl). Automáticamente llama a srand a menos que srand ya se haya llamado. Vea también srand.

Aplique int al valor devuelto por rand si quiere obtener enteros aleatorios en lugar de fraccionarios. Por ejemplo,

    int(rand(10))

devuelve un número entero aleatorio entre 0 y 9, inclusive.

(Nota: si su función rand devuelve constantemente números demasiado grandes o demasiado pequeños, entonces su versión de Perl fue, probablemente, compilada con un número incorrecto de RANDBITS).

rand no es criptográficamente seguro. No debe confiar en él en situaciones delicadas de seguridad. Al escribir estas líneas, una serie de módulos de 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.

read IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO
read IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD

Intento de leer LONGITUD caracteres de datos en la variable ESCALAR del IDENTIFICADOR_ARCHIVO especificado. Devuelve el número de caracteres realmente leídos, 0 al final del archivo, o undef si hubo un error (en este último caso se actualiza el valor de $!). ESCALAR crecerá o se reducirá de manera que el último carácter realmente leído es el último carácter del escalar después de la lectura.

Un DESPLAZAMIENTO se puede especificar para colocar los datos leídos en algún otro lugar de la cadena, distinto del principio. Un DESPLAZAMIENTO negativo especifica el desplazamiento en número de caracteres contando desde el final de la cadena. Un DESPLAZAMIENTO positivo mayor que la longitud de ESCALAR resulta en un cadena rellenada al tamaño requerido con bytes "\0" antes de que el resultado de la lectura sea añadido.

La llamada se implementa en términos de Perl o de la función nativa fread(3) de su sistema. Para obtener una auténtica llamada del sistema read(2), vea sysread.

Note los caracteres: dependiendo del estado del identificador de archivo, se leen bytes (8-bit) o caracteres. Por defecto, todos los identificadores de archivo operan en bytes, pero por ejemplo, si el identificador se ha abierto con la capa de E/S :utf8 (vea open, y el pragma open), la E/S operará en caracteres Unicode codificados en UTF-8, no bytes. Del mismo modo, para la capa :encoding: en este caso casi todos los caracteres se pueden leer.

readdir IDENTIFICADOR_DIR

Devuelve la siguiente entrada de directorio de un directorio abierto con opendir. Si se usa en contexto de lista, devuelve el resto de las entradas en el directorio. Si no hay más entradas, devuelve el valor indefinido en el contexto escalar y la lista vacía en el contexto de lista.

Si está planeando hacer test de archivos de los valores retornados por un readdir, más le vale anteponer el directorio en cuestión. De lo contrario, debido a que no hicimos antes un chdir, se estará probando en un archivo incorrecto.

    opendir(my $dh, $algun_dir) || die "No puedo hacer opendir en $algun_dir: $!";
    my @dots = grep { /^\./ && -f "$algun_dir/$_" } readdir($dh);
    closedir $dh;

A partir de Perl 5.12 puede usar un simple readdir en un bucle while, que actualizará $_ en cada iteración.

    opendir(my $dh, $algun_dir) || die "No puedo hacer opendir en $algun_dir: $!";
    while (readdir $dh) {
        print "$algun_dir/$_\n";
    }
    closedir $dh;

Para no confundir a los posibles usuarios de su código, que ejecuten versiones anteriores de Perl, con errores misteriosos, ponga este tipo de cosas en la parte superior de su archivo para indicar que el código funciona sólo en versiones Perl de cosechas recientes:

    use 5.012; # así, readdir asigna a $_ en un solitario test del while
readline EXPR
readline

Lee del identificador de archivo cuyo typeglob esté contenido en EXPR (o desde *ARGV si se omite EXPR). En contexto escalar, cada llamada lee y devuelve la siguiente línea hasta que se alcance el final del archivo, en cuyo caso la siguiente llamada devuelve undef. En contexto de lista, lee hasta el final de archivo y devuelve una lista de líneas. Note que la noción de "línea" usada aquí es según tenga definido $/ o $INPUT_RECORD_SEPARATOR en English. Ver "$/" in perlvar.

Cuando $/ tenga un valor de undef, cuando readline esté en contexto escalar (es decir, modo de absorción completa de archivo), y cuando se esté leyendo un archivo vacío, devuelve '' la primera vez, seguido a continuación de undef.

Esto es la función interna que implementa el operador <EXPR>, pero puede usarla directamente. El operador <EXPR> se discute con más detalle en "Operadores E/S" in perlop.

    my $linea = <STDIN>;
    my $linea = readline(STDIN);    # lo mismo

Si readline encuentra un error del sistema operativo, $! se establecerá al correspondiente mensaje de error. Puede ser útil comprobar $! cuando está leyendo de identificadores de archivo en los que no confía, como un tty o un socket. En el ejemplo siguiente se utiliza la forma del operador de readline y muere si el resultado no está definido.

    while ( ! eof($fh) ) {
        defined( $_ = readline $fh ) or die "readline falló: $!";
        ...
    }

Note que no puede gestionar errores de readline de esta manera con el identificador de archivo ARGV. En este caso, tiene que abrir cada elemento de @ARGV debido a que eof gestiona ARGV de otra manera.

    foreach my $arg (@ARGV) {
        open(my $fh, $arg) or warn "No puedo abrir $arg: $!";

        while ( ! eof($fh) ) {
            defined( $_ = readline $fh )
                or die "readline falló para $arg: $!";
            ...
        }
    }

Devuelve el valor de un enlace simbólico, si los enlaces simbólicos están implementados. Si no, lanza una excepción. Si hay un error del sistema, devuelve el valor indefinido y establece $! (errno). Si se omite EXPR, usa $_.

Cuestiones de portabilidad: "readlink" in perlport.

readpipe EXPR
readpipe

EXPR es ejecutada como un comando del sistema. Todo lo que salga por la salida estándar del comando se devuelve. En contexto escalar, se devuelve como una sola cadena (potencialmente multi-línea). En contexto lista, devuelve una lista de líneas (según haya definido lo que son líneas con $/ (o $INPUT_RECORD_SEPARATOR en English)). Esto es la función interna que implementa el operador qx/EXPR/, pero puede usarla directamente. El operador qx/EXPR/ se discute con más detalle en "Operadores E/S" in perlop. Si se omite EXPR, usa $_.

recv SOCKET,ESCALAR,LONGITUD,INDICADORES

Recibe un mensaje de un socket. Intenta leer LONGITUD caracteres de datos en la variable ESCALAR del identificador de archivo SOCKET especificado. ESCALAR crecerá o se reducirá a la longitud de la lectura real. Toma los mismos indicadores que la llamada al sistema del mismo nombre. Devuelve la dirección del remitente si el protocolo del SOCKET lo soporta; de otra manera, devuelve una cadena vacía. Si hay un error, devuelve el valor indefinido. Esta llamada está implementada realmente en términos de la llamada del sistema recvfrom(2). Ver "UDP: Paso de mensajes" in perlipc para ejemplos.

Note los caracteres: dependiendo del estado del socket, se leen bytes (8-bit) o caracteres. Por defecto todos los sockets operan en bytes, pero por ejemplo si el socket se ha cambiado usando binmode para operar con la capa de E/S :encoding(utf8) (vea el pragma open), la E/S operará en caracteres Unicode codificados en UTF-8, no bytes. Del mismo modo, para la capa :encoding: en este caso casi todos los caracteres se pueden leer.

redo ETIQUETA
redo EXPR
redo

El comando redo reinicia la iteración sin evaluar de nuevo la condición. El bloque continue, si está, no se ejecuta: Si la ETIQUETA se omite, el comando se refiere al bucle más interior en que se encuentre. La forma redo EXPR, disponible a partir de Perl 5.18.0, permite que se compute un nombre de etiqueta en tiempo de ejecución; de lo contrario es idéntico a redo ETIQUETA. Los programas que quieren engañarse a sí mismos acerca de lo que se acaba de introducir suelen utilizar este comando:

    # elimina ingenuamente comentarios Pascal
    # (aviso: asumes que no hay { o } en cadenas)
    LINEA: while (<STDIN>) {
        while (s|({.*}.*){.*}|$1 |) {}
        s|{.*}| |;
        if (s|{.*| |) {
            my $front = $_;
            while (<STDIN>) {
                if (/}/) {  # ¿fin de comentario?
                    s|^|$frente\{|;
                    redo LINEA;
                }
            }
        }
        print;
    }

redo no puede usarse para reiniciar un bloque que devuelve un valor, como eval {}, sub {} o do {}, y no se debe usar para salir de una operación grep o map.

Note que un bloque por sí mismo es semánticamente idéntico a un bucle que se ejecuta una vez. Por lo tanto redo dentro de un bloque lo convertirá de forma efectiva en una construcción de bucle.

Ver también continue para una ilustración de cómo funcionan last, next y redo.

A diferencia de otros operadores con nombre, tiene la misma precedencia que una asignación. También está exenta de la regla "se-parece-a-una-función", así que redo ("foo")."bar" hará que "bar" sea parte del argumento a redo.

ref EXPR
ref

Devuelve una cadena no vacía si EXPR es una referencia; de otra manera, devuelve una cadena vacía. Si se omite EXPR, se usará $_. El valor devuelto depende del tipo de cosa que la referencia referencie.

Tipos predefinidos incluyen:

    SCALAR
    ARRAY
    HASH
    CODE
    REF
    GLOB
    LVALUE
    FORMAT
    IO
    VSTRING
    Regexp

Puede pensar en ref como un operador typeof.

    if (ref($r) eq "HASH") {
        print "r es una referencia a un hash.\n";
    }
    unless (ref($r)) {
        print "r no es una referencia.\n";
    }

El valor de retorno LVALUE indica una referencia a un valor-izquierda que no es una variable. Obtiene esto de la referencia a las llamadas a funciones como pos o substr. VSTRING se devuelve si la referencia apunta a una version string.

El resultado Regexp indica que el argumento es una expresión regular como resultado de qr//.

Si el objeto referenciado se ha bendecido en un paquete, entonces se devuelve el nombre de ese paquete. Pero no use esto, ya que se considera que es una "mala práctica". Primero, porque un objeto podría usar una clase llamada Regexp o IO, o incluso HASH. También, porque ref no tiene en cuenta a las subclases, como hace isa.

En lugar de eso, use blessed (en el módulo Scalar::Util) para comprobaciones booleanas, isa para comprobaciones de una clase específica y reftype (también en Scalar::Util) para comprobaciones de tipo. (Vea perlobj para más detalles y un ejemplo de blessed/isa).

Ver también perlref.

rename NOMBRE_VIEJO,NOMBRE_NUEVO

Cambia el nombre de un archivo; un archivo existente que se llame NOMBRE_NUEVO será sobreescrito. Devuelve verdadero en caso de éxito, o falso en caso contrario.

El comportamiento de esta función varía enormemente dependiendo de la implementación de su sistema. Por ejemplo, normalmente no funcionará a través de los límites del sistema de archivos, a pesar de que el comando del sistema mv a veces lo compense. Otras restricciones incluyen si funciona en directorios, archivos abiertos, o archivos pre-existentes. Compruebe perlport y, o bien la página de manual de rename(2) o documentación equivalente del sistema para más detalles.

Para una función independiente de la plataforma vea move en el módulo File::Copy.

Cuestiones de portabilidad: "rename" in perlport.

require VERSIÓN
require EXPR
require

Exige una versión de Perl especificada por VERSIÓN, o exige una semántica especificada por EXPR, o por $_ si EXPR se omite.

VERSIÓN puede ser un argumento numérico, como 5.006, que será comparado con $], o un literal de la forma v5.6.1, que será comparado con $^V (alias de $PERL_VERSION en English). Se genera una excepción si VERSIÓN es mayor que la versión actual del intérprete de Perl. Compare con use, que puede hacer un control similar en tiempo de compilación.

Especificando VERSIÓN como un literal de la forma v5.6.1, debe, generalmente, evitarse, porque lleva crear mensajes de error equívocos en las versiones anteriores de Perl que no admiten esta sintaxis. Se debe usar en su lugar la versión equivalente numérica.

    require v5.6.1;     # comprobación de versión en tiempo de ejecución
    require 5.6.1;      # ídem
    require 5.006_001;  # idem; preferido para mantener
                          la compatibilidad

De lo contrario, require demanda que un archivo de biblioteca sea incluido si no se hubiera incluido ya. El archivo se incluye a través del mecanismo do-ARCHIVO, que es esencialmente lo mismo que una variedad de eval con la advertencia de que las variables léxicas en la secuencia de comandos del programa serán invisibles para el código incluido. Si estuviera implementado en puro Perl, podría tener una semántica similar a lo siguiente:

    use Carp 'croak';
    use version;

    sub require {
        my ($nombrearchivo) = @_;
        if ( my $version = eval { version->parse($nombrearchivo) } ) {
            if ( $version > $^V ) {
               my $vn = $version->normal;
               croak "Se requiere Perl $vn; éste es sólo $^V. Programa parado";
            }
            return 1;
        }

        if (exists $INC{$nombrearchivo}) {
            return 1 if $INC{$nombrearchivo};
            croak "Falló la compilación en el require";
        }

        foreach $prefijo (@INC) {
            if (ref($prefijo)) {
                #... hacer otras cosas - vea texto más abajo ....
            }
            # (vea texto más abajo sobre la posible añadidura del sufijo .pmc
            # al $nombrearchivo)
            my $nombrearchivoreal = "$prefijo/$nombrearchivo";
            next if ! -e $nombrearchivoreal || -d _ || -b _;
            $INC{$nombrearchivo} = $nombrearchivoreal;
            my $resultado = do($nombrearchivoreal);
                         # pero se ejecuta en el espacio de nombres del llamante

            if (!defined $resultado) {
                $INC{$nombrearchivo} = undef;
                croak $@ ? "$@Compilación falló en require"
                         : "No puedo localizar $nombrearchivo: $!\n";
            }
            if (!$resultado) {
                delete $INC{$nombrearchivo};
                croak "$nombrearchivo no devuelve un valor verdadero";
            }
            $! = 0;
            return $resultado;
        }
        croak "No puedo localizar $nombrearchivo en \@INC ...";
    }

Tenga en cuenta que el archivo no será incluido dos veces con el mismo nombre especificado.

El archivo debe devolver verdadero como última instrucción para indicar una ejecución exitosa de cualquier código de inicialización, por lo que es habitual a tal efecto que un archivo termine con un 1; a menos que esté seguro de que devolverá cierto, de otra manera. Pero es mejor sólo para poner 1;, en caso de que añada más instrucciones.

Si EXPR es una palabra simple, el require asume una extensión ".pm" y le reemplaza :: con / en el nombre del archivo, para que sea fácil cargar módulos estándar. Esta forma de cargar módulos no tiene el riesgo de alterar el espacio de nombres propio.

En otras palabras, si intenta esto:

        require Foo::Bar;     # algo atractivo

La función require realmente buscará el archivo "Foo/Bar.pm" en los directorios especificados en el array @INC.

Pero si intenta esto:

        my $clase = 'Foo::Bar';
        require $clase;       # $clase no es una palabra suelta
    # o
        require "Foo::Bar";   # no una palabra suelta por las ""

La función require buscará por el archivo "Foo::Bar" en los directorios especificados por el array @INC y se quejará de que no lo encuentra. En este caso puede hacer:

        eval "require $clase";

Ahora que sabe cómo require busca archivos con un argumento simple, hay una funcionalidad extra que pasa por detrás de las cámaras. Antes de require busque una extensión ".pm", en primer lugar, buscará un nombre de archivo similar con una extensión ".pmc". Si se encuentra este archivo, se cargará en lugar de cualquier archivo que termine en una extensión ".pm".

También puede insertar enganches en la facilidad import poniendo código Perl directamente en el array @INC. Hay tres formas de enganches: referencias a subrutinas, referencias a arrays y objetos bendecidos.

Referencias a subrutinas son el caso más simple. Cuando el sistema de inclusión recorre @INC y se encuentra con una subrutina, se llama a esta subrutina 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, o nada, o bien una lista de hasta cuatro valores en el orden siguiente:

  1. Una referencia a un escalar, conteniendo cualquier código de fuente inicial para agregarse antes del archivo o salida del generador.

  2. Un identificador de archivo, desde el cual, el archivo será leído.

  3. Una referencia a una subrutina. Si no hay un identificador de archivo (punto anterior), entonces de esta subrutina se espera que genere una línea de código fuente por llamada, escribiendo la línea en $_ y devolviendo 1, para luego, finalmente, devolver un 0 al final del archivo. Si hay un identificador de archivo, a continuación, la subrutina se llamará a actuar como un simple filtro de código fuente, con la línea leída en $_. De nuevo, devuelve 1 para cada línea válida y 0 después de que todas las líneas han sido devueltas.

  4. Estado opcional para la subrutina. El estado es pasado en $_[1]. Una referencia a la propia subrutina es pasada en $_[0].

Si se devuelve una lista vacía, undef, o nada que coincida con los tres primeros valores anteriores, entonces require mira en los elementos restantes de @INC. Tenga en cuenta que este identificador de archivo debe ser un identificador de archivo real (en sentido estricto un typeglob o una referencia a un typeglob, bendecido o no); se ignorarán identificadores de archivo enlazados y el procesado terminará ahí.

Si el enganche es una referencia de array, su primer elemento debe ser una referencia a una subrutina. Esta subrutina se llama como antes, pero el primer parámetro es la referencia al array. Esto le permite pasar argumentos indirectamente a la subrutina.

En otras palabras, puede escribir:

    push @INC, \&mi_sub;
    sub mi_sub {
        my ($coderef, $archivo) = @_;  # $coderef is \&mi_sub
        ...
    }

o:

    push @INC, [ \&mi_sub, $x, $y, ... ];
    sub mi_sub {
        my ($arrayref, $archivo) = @_;
        # Recupera $x, $y, ...
        my (undef, @parametros) = @$arrayref;
        ...
    }

Si el enganche es un objeto, debe proporcionar un método INC que se llamará como antes, el primer parámetro siendo el propio objeto. (Tenga en cuenta que debe cualificar completamente el nombre de la subrutina, así como un no cualificado INC está siempre forzado en el paquete main). Este es un diseño de código típico:

    # En Foo.pm
    package Foo;
    sub new { ... }
    sub Foo::INC {
        my ($self, $archivo) = @_;
        ...
    }

    # En el programa principal
    push @INC, Foo->new(...);

Estos enganches también están autorizados para establecer la entradas %INC correspondientes a los archivos que se hayan cargado. Ver "%INC" in perlvar.

Para una más-que-poderosa facilidad de importación, vea use y perlmod.

reset EXPR
reset

Generalmente se usa en un bloque continue, al final de un bucle para limpiar variables y reinicializar las búsquedas m?patrón?, para que funcionen de nuevo. La expresión se interpreta como una lista de caracteres simples (guiones permitidos para indicar rangos). Todas las variables y arrays que comiencen con una de esas letras son restablecidas a su estado prístino. Si la expresión se omite, las búsquedas de una sola coincidencia (m?patrón?) se reinicializan para que vuelvan a hacer el trabajo de coincidencia. Sólo se restablecen variables o búsquedas en el paquete actual. Siempre devuelve 1. Ejemplos:

    reset 'X';      # reinicia todas las variables X
    reset 'a-z';    # reinicia las variables con minúsculas
    reset;          # solo reinicia m?una-vez? búsquedas

El restablecimiento de "A-Z" no es recomendable porque limpiará sus arrays @ARGV y @INC y su hash %ENV. Restablece solo las variables del paquete; las variables léxicas no se ven afectadas, pero ellas mismas se limpiarán, de todos modos, a la salida de su ámbito, por lo que probablemente querrá usarlas en su lugar. Vea my.

return EXPR
return

Regresa de una subrutina, eval, do FILE, un bloque sort o un bloque regex eval (pero no un bloque grep o map) con el valor indicado en EXPR. La evaluación de EXPR puede estar en contexto lista, escalar o vacío, dependiendo de cómo el valor de retorno se utilizará, y el contexto puede variar de una ejecución a la siguiente (vea wantarray). Si no se indica EXPR, devuelve una lista vacía en contexto de lista, el valor indefinido en el contexto escalar, y (por supuesto) nada en absoluto en el contexto vacío.

(En ausencia de un return explícito, una subrutina, eval, o do ARCHIVO, automáticamente devuelve el valor de la última expresión evaluada).

A diferencia de la mayor parte de operadores con nombre, esto también está exento de la regla se-parece-a-una-función, así que return ("foo")."bar" hará que "bar" sea parte del argumento a return.

reverse LISTA

En contexto de lista, devuelve una lista de valores consistente en los elementos de LISTA en el orden opuesto. En contexto escalar, concatena los elementos LISTA y devuelve un valor de cadena con todos los caracteres en orden inverso.

    print join(", ", reverse "mundo", "Hola"); # Hola, mundo

    print scalar reverse "odnum ,", "aloH";    # Hola, mundo

Si se utiliza sin argumentos en contexto escalar, reverse invierte $_.

    $_ = "odnum ,aloH";
    print reverse;                         # No hay salida, contexto lista
    print scalar reverse;                  # Hola, mundo

Tenga en cuenta que invertir un array en sí mismo (como en @a = reverse @a) preservará los elementos inexistentes mientras le sea posible, es decir, para arrays no mágicos o arrays enlazados con métodos EXISTS y DELETE.

Este operador también es útil para invertir un hash, aunque existen algunas salvedades. Si un valor está duplicado en el hash original, sólo uno de ellos se puede representar como clave en el hash invertido. Además, esto tiene el efecto de desmontar un hash y construir uno nuevo, algo que puede tardar algún tiempo en un hash grande, como en un archivo DBM.

    my %por_nombre = reverse %por_direccion;  # Invierte el hash
rewinddir IDENTIFICADOR_DIR

Establece la posición actual al comienzo del directorio para la rutina readdir en IDENTIFICADOR_DIR.

Problemas de adaptación: "rewinddir" in perlport.

rindex CADENA,SUBCADENA,POSICIÓN
rindex CADENA,SUBCADENA

Funciona igual que index excepto que devuelve la posición de la última ocurrencia de SUBCADENA en CADENA. Sí POSICIÓN es especificada, devuelve la última ocurrencia comenzando en o antes de esta posición.

rmdir NOMBRE_DIRECTORIO
rmdir

Elimina el directorio especificado por NOMBRE_DIRECTORIO si ese directorio está vacío. Si tiene éxito devuelve verdadero; en caso contrario devuelve falso y establece $! (errno). Si se omite NOMBRE_ARCHIVO, usa $_.

Para eliminar un árbol de directorio recursivamente (rm -rf en Unix) mire la función rmtree del módulo File::Path.

s///

El operador de sustitución. See "Operadores Regex" in perlop.

say IDENTIFICADOR_ARCHIVO LISTA
say IDENTIFICADOR_ARCHIVO
say LISTA
say

Igual que print, pero implícitamente añade un carácter de nueva línea. say LISTA es simplemente una abreviatura de { local $\ = "\n"; print LISTA }. Para utilizar solamente IDENTIFICADOR_ARCHIVO para imprimir en él el contenido de $_ sin una LISTA, debe ser un identificador de archivo real, como FH, no uno indirecto como $fh.

say sólo está disponible si la característica "say" está habilitada o si está prefijada con CORE::. La característica "say" se activa automáticamente con una declaración use v5.10 (o superior) en el ámbito actual.

scalar EXPR

Fuerza EXPR a interpretarse en contexto escalar y devuelve el valor de EXPR.

    my @contadores = ( scalar @a, scalar @b, scalar @c );

No hay un operador equivalente que fuerce a una expresión a interpolarse en contexto de lista, ya que en la práctica, esto nunca es necesario. Sin embargo, si realmente quiere hacer eso, puede usar la construcción @{[ (una expresión) ]}, pero por lo general un simple (una expresión) basta.

Dado que scalar es un operador unario, si, accidentalmente, usa para EXPR una lista entre paréntesis, esto se comportará como una expresión escalar con comas, evaluando todos, menos el último elemento, en contexto vacío, y devolviendo el elemento final evaluado en contexto escalar. Es muy raro que quiera hacerlo.

La simple declaración siguiente:

    print uc(scalar(foo(), $bar)), $baz;

es el equivalente moral de estos dos:

    foo();
    print(uc($bar), $baz);

Ver perlop para más detalles en operadores unarios y el operador coma, y perldata para más detalles al evaluar un hash en contexto escalar.

seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE

Establece la posición de IDENTIFICADOR_ARCHIVO, igual que la llamada fseek(3) de stdio del C. IDENTIFICADOR_ARCHIVO puede ser una expresión cuyo valor da el nombre del identificador de archivo. Los valores de DÓNDE son 0 para poner la nueva posición en bytes a POSICIÓN; 1 para poner la posición actual más POSICIÓN; y 2 para ponerlo a EOF más POSICIÓN, normalmente negativo. Para DÓNDE puede usar las constantes SEEK_SET, SEEK_CUR y SEEK_END (inicio del archivo, posición actual y fin de archivo) desde el módulo Fcntl. Devuelve 1 en caso de éxito; falso en caso contrario.

Nota sobre lo de en bytes: incluso si el identificador de archivo se ha establecido para operar en caracteres (por ejemplo usando la capa de open :encoding(utf8)), tell devolverá desplazamientos en bytes, no en caracteres (porque implementando esto convertirían en lentas a seek y tell).

Si desea posicionar el archivo para las funciones sysread o syswrite, no utilice seek, porque hace impredecible y no portátil la posición de lectura/escritura del archivo a causa del efecto del almacenamiento en búfer del archivo. Use, en cambio, sysseek.

Debido a las normas y rigores de la norma ANSI C, en algunos sistemas tendrá que hacer una búsqueda cada vez que alterne entre la lectura y la escritura. Entre otras cosas, esto puede tener el efecto de llamar a los clearerr(3) de stdio. Un DONDE de 1 (SEEK_CUR) es útil para no mover la posición del archivo:

    seek($fh, 0, 1);

Esto también es útil para aplicaciones que emulen tail -f. Una vez que llegue al EOF, en lectura y si se echa a dormir por un tiempo, (probablemente) tendrá que tocarlo con un ficticio seek para restablecer las cosas. El seek no cambia la posición, pero borra la condición de final de archivo en el identificador de archivo, para que el próximo readline ARCHIVO haga que Perl intente de nuevo leer algo. (Esperamos).

Si eso no funciona (algunas implementaciones de E/S son particularmente irritables), puede que tenga que hacer algo como esto:

    for (;;) {
        for ($curpos = tell($fh); $_ = readline($fh);
             $curpos = tell($fh)) {
            # buscar por algo y ponerlo en el archivo
        }
        sleep($por_un_rato);
        seek($fh, $curpos, 0);
    }
seekdir IDENTIFICADOR_DIR,POSICIÓN

Establece la posición actual para la rutina readdir en IDENTIFICADOR_DIR. POS debe ser un valor devuelto por telldir. seekdir también tiene las mismas advertencias sobre la posible compactación del directorio como la correspondiente rutina del sistema.

select IDENTIFICADOR_ARCHIVO
select

Devuelve el identificador de archivo seleccionado. Si se indica un IDENTIFICADOR_ARCHIVO, se establece un nuevo identificador de archivo predeterminado para la salida. Esto tiene dos efectos: primero, un write o un print sin un identificador de archivo será por defecto este IDENTIFICADOR_ARCHIVO. En segundo lugar, las referencias a variables relacionadas con la salida se referirán a este canal de salida.

Por ejemplo, si tiene que fijar la parte superior del formato de un formulario para más de un canal de salida, puede hacer lo siguiente:

    select(INFORME1);
    $^ = 'informe1_top';
    select(INFORME2);
    $^ = 'informe2_top';

IDENTIFICADOR_ARCHIVO puede ser una expresión cuyo valor da el nombre del identificador de archivo real. Por lo tanto:

    my $oldfh = select(STDERR); $| = 1; select($oldfh);

Algunos programadores prefieren pensar en identificadores de archivo como objetos con métodos, prefiriendo escribir el último ejemplo como:

    STDERR->autoflush(1);

(Antes de la versión 5.14 de Perl, primero debe poner use IO::Handle; de forma explícita).

Cuestiones de portabilidad: "select" in perlport.

select RBITS,WBITS,EBITS,TIEMPO_ESPERA

Esto llama a la función del sistema select(2) con las máscaras de bit especificadas, que pueden construirse usando fileno y vec, como muestran estas líneas:

    my $rin = my $win = my $ein = '';
    vec($rin, fileno(STDIN),  1) = 1;
    vec($win, fileno(STDOUT), 1) = 1;
    $ein = $rin | $win;

Si desea seleccionar en muchos identificadores de archivo, puede desear escribir una subrutina de esta manera:

    sub fhbits {
        my @fhlist = @_;
        my $bits = "";
        for my $fh (@fhlist) {
            vec($bits, fileno($fh), 1) = 1;
        }
        return $bits;
    }
    my $rin = fhbits(\*STDIN, $tty, $mysock);

El modismo habitual es:

 my ($n_encontrados, $tiempo_restante) =
   select(my $rout = $rin, my $wout = $win, my $eout = $ein,
                                                          $timeout);

o bloquear hasta que algo esté preparado, sólo hacemos esto

 my $n_encontrados =
   select(my $rout = $rin, my $wout = $win, my $eout = $ein, undef);

La mayoría de los sistemas no se molestan en devolver nada útil en $tiempo_restante, así que llamando select en contexto escalar sólo devuelve $n_encontrados.

Cualquiera de las máscaras de bit también puede ser undef. El tiempo de espera, si se especifica, en segundos, puede ser decimal. Nota: no todas las implementaciones son capaces de devolver $tiempo_restante. Si no, siempre devuelven $tiempo_restante igual a $tiempo_espera indicado.

Puede efectuar una espera de 250 milisegundos de esta manera:

    select(undef, undef, undef, 0.25);

Tenga en cuenta que cuando select se reinicia después de señales (por ejemplo, SIGALRM) es algo dependiente de la implementación. Vea también perlport para las notas sobre la portabilidad de select.

En caso de error, select se comporta como select(2): devuelve -1 y actualiza $!.

En algunos sistemas Unix, select(2) puede informar de un descriptor de archivo socket como "listo para leer" incluso cuando no hay datos disponibles, y por lo tanto un posterior read producirá un bloqueo. Esto puede evitarse si siempre utiliza O_NONBLOCK en el socket. Vea select(2) y fcntl(2) para más detalles.

El módulo estándar IO::Select proporciona una interfaz fácil de utilizar para select, sobre todo porque hace todo el trabajo de la máscara de bit, por usted.

AVISO : No debe tratar de mezclar el E/S con búferes (como read o select) con readline, excepto lo autorizado por POSIX, e incluso entonces sólo en sistemas POSIX. Tiene que usar en su lugar sysread

Cuestiones de portabilidad: "select" in perlport.

semctl ID,SEMNUM,CMD,ARG

Llama a la función semctl(2) de System V IPC. Probablemente escribirá

    use IPC::SysV;

primero para obtener las definiciones de las constantes. Si CMD es IPC_STAT o GETALL, entonces ARG debe ser una variable que contendrá la estructura semid_ds devuelta o el array de semáforos. Devuelve lo mismo que ioctl: el valor indefinido para indicar un error, "0 but true" para el caso de cero, o el valor de retorno real, en caso contrario. El ARG debe consistir en un vector de enteros cortos nativos, que pueden crearse con pack("s!",(0)x$nsem). Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV y IPC::Semaphore.

Cuestiones de portabilidad: "semctl" in perlport.

semget CLAVE,NSEMS,INDICADORES

Llama a la función semget(2) de System V IPC. Devuelve el id del semáforo, o el valor indefinido en caso de error. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV y IPC::Semaphore.

Cuestiones de portabilidad: "semget" in perlport.

semop CLAVE,OPSTRING

Llama a la función System V IPC semop(2) para operaciones de semáforos, como señalización y espera. OPSTRING debe ser un array empaquetado de estructuras semop. Cada estructura semop se puede generar con pack("s!3", $semnum, $semop, $semflag). La longitud de OPSTRING implica el número de operaciones de semáforos. Devuelve verdadero si tuvo éxito, falso en caso de error. A modo de ejemplo, el siguiente código espera en un semáforo $semnum del semáforo con identificador $semid:

    my $semop = pack("s!3", $semnum, -1, 0);
    die "Problema son semáforo: $!\n" unless semop($semid, $semop);

Para señalizar el el semáforo, reemplace -1 con 1. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV y IPC::Semaphore.

Cuestiones de portabilidad: "semop" in perlport.

send SOCKET,MSG,INDICADORES,DESTINO
send SOCKET,MSG,FLAGS

Envía un mensaje sobre un socket. Intenta enviar el escalar MSG al identificador de archivo SOCKET. Toma los mismos indicadores que la llamada al sistema del mismo nombre. En sockets desconectados, debe especificar un destino adonde enviarlo, en cuyo caso hace una llamada del sistema sendto(2). Devuelve el número de caracteres enviados, o el valor indefinido en caso de error. La llamada del sistema sendmsg(2) no está, actualmente, implementada. Ver "UDP: Paso de mensajes" in perlipc para ejemplos.

Note los caracteres: dependiendo del estado del socket, son enviados bytes (8-bit) o caracteres. Por defecto todos los sockets operan en bytes, pero por ejemplo si el socket se ha cambiado usando binmode para operar con la capa de E/S :encoding(utf8) (vea open, o el pragma open), la E/S operará en caracteres Unicode codificados en UTF-8, no bytes. Del mismo modo, para el pragma :encoding: en este caso casi todos los caracteres se pueden enviar.

setpgrp PID,PGRP

Establece el grupo de procesos en curso para el PID especificado, 0 para el proceso actual. Eleva una excepción si se usa en una máquina que no implemente POSIX setpgid(2) o BSD setpgrp(2). Si los argumentos se omiten, el valor predeterminado es 0,0. Tenga en cuenta que la versión de BSD 4.2 de setpgrp no acepta ningún argumento, por lo que sólo setpgrp(0,0) es portátil. Vea también POSIX::setsid().

Cuestiones de portabilidad: "setpgrp" in perlport.

setpriority CUÁL,QUIÉN,PRIORIDAD

Devuelve la prioridad actual de un proceso, un grupo de procesos o un usuario. (Vea setpriority(2)). Lanza una excepción si se usa en una máquina que no implementa setpriority(2).

Cuestiones de portabilidad: "setpriority" in perlport.

setsockopt SOCKET,NIVEL,OPCIÓN_NOMBRE,OPCIÓN_VALOR

Establece la opción de socket solicitada. Devuelve undef en caso de error. Utilice constantes enteras proporcionadas por el módulo Socket para NIVEL y OPCIÓN_NOMBRE. Los valores para NIVEL también se pueden obtener de getprotobyname. OPCIÓN_VALOR podría ser una cadena empaquetada o un entero. Un entero como OPCIÓN_VALOR es la abreviatura de pack("i", OPCIÓN_VALOR).

Un ejemplo para deshabilitar el algoritmo de Nagle del socket:

    use Socket qw(IPPROTO_TCP TCP_NODELAY);
    setsockopt($socket, IPPROTO_TCP, TCP_NODELAY, 1);

Cuestiones de portabilidad: "setsockopt" in perlport.

shift ARRAY
shift

Extrae el primer valor del array y lo devuelve, acortando el array en uno y moviendo todos los demás hacia arriba. Si no hay elementos en el array, devuelve el valor undef. Si se omite ARRAY, se desplaza el array @_ dentro del ámbito léxico de subrutinas y formatos, y el array @ARGV si está fuera de una subrutina y también dentro de los ámbitos léxicos establecidos por construcciones como eval CADENA, BEGIN {}, INIT {}, CHECK {}, UNITCHECK {} y END {}.

A partir de Perl 5.14, una característica experimental permitía a shift tomar una expresión escalar. Se ha considerado que este experimento no ha funcionado, y se quitó a partir de Perl 5.24.

Vea también unshift, push, y pop. shift y unshift hacen lo mismo con el extremo izquierdo de un array que pop y push lo hacen para el extremo derecho.

shmctl ID,CMD,ARG

Llama a la función System V IPC shmctl(2). Probablemente escribirá

    use IPC::SysV;

primero para obtener las definiciones de las constantes. Si CMD es IPC_STAT, entonces ARG debe ser una variable que contendrá la estructura shmid_ds devuelta. Devuelve lo mismo que ioctl: undef para error; "0 but true" para cero; o el valor de retorno real, en cualquier otro caso. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV.

Cuestiones de portabilidad: "shmctl" in perlport.

shmget CLAVE,TAMAÑO,INDICADORES

Llama a la función System V IPC shmget(2). Devuelve el identificador de la memoria compartida, o undef en caso de error. Vea también "SysV IPC" in perlipc y la documentación de IPC::SysV.

Cuestiones de portabilidad: "shmget" in perlport.

shmread ID,VAR,POSICIÓN,TAMAÑO
shmwrite ID,CADENA,POSICIÓN,TAMAÑO

Lee o escribe en el segmento ID de memoria compartida System V a partir de la POSICIÓN para el TAMAÑO indicado, añadiéndose a ella, copiando la entrada/salida, y desuniéndose de ella. Al leer, VAR debe ser una variable que contendrá los datos leídos. Al escribir, si CADENA es demasiado larga, sólo se utilizan TAMAÑO bytes; si CADENA es demasiado corta, se escriben nulos para llenar TAMAÑO bytes. Devuelve verdadero si tuvo éxito, falso en caso de error. shmread contamina la variable. Vea también "SysV IPC" in perlipc y la documentación del módulo IPC::SysV y IPC::Shareable en CPAN.

Cuestiones de portabilidad: "shmread" in perlport y "shmwrite" in perlport.

shutdown SOCKET,CÓMO

Cierra una conexión de socket en la manera indicada por el CÓMO, que tiene la misma interpretación que en la llamada del sistema del mismo nombre.

    shutdown($socket, 0);    # Hemos dejado de leer datas
    shutdown($socket, 1);    # Hemos dejado de escribir datos
    shutdown($socket, 2);    # Hemos dejado de usar este socket

Esto es útil con sockets cuando desee decirle al otro lado que ha terminado de escribir, pero no ha terminado la lectura, o viceversa. También es una forma más insistente de cerrar, ya que también desactiva el descriptor de archivo en cualquier copia bifurcada en otros procesos.

Devuelve 1 para el éxito; en caso de error, devuelve undef si el primer argumento no es un identificador de archivo válido, o devuelve 0 y establece $! por cualquier otro error.

sin EXPR
sin

Devuelve el seno de EXPR (expresado en radianes). Si se omite EXPR, devuelve el seno de $_.

Para la inversa de la operación seno, puede usar la función Math::Trig::asin(), o usar esta relación:

    sub asin { atan2($_[0], sqrt(1 - $_[0] * $_[0])) }
sleep EXPR
sleep

Hace que el programa duerma EXPR segundos (entero), o para siempre si se le da ningún argumento. Devuelve el número entero de segundos realmente dormidos.

Puede ser interrumpido si el proceso recibe una señal como SIGALRM.

    eval {
        local $SIG{ALRM} = sub { die "¡Alarma!\n" };
        sleep;
    };
    die $@ unless $@ eq "¡Alarma!\n";

Probablemente no puede entremezclar llamadas a alarm y sleep, porque sleep se implementa, a menudo, con alarm.

En algunos sistemas antiguos, se puede dormir hasta un segundo meno de lo que ha solicitado, en función de la forma en cómo se cuenten los segundos. La mayoría de los sistemas modernos siempre duermen la cantidad correspondiente. Sin embargo, quizás puedan parecer dormir más de lo indicado, debido a que su proceso no puede planificarse de forma inmediata en un sistema multitarea ocupado.

Para lapsos de tiempo inferiores a un segundo, el módulo Time::HiRes (en CPAN, y a partir de Perl 5.8 como parte de la distribución estándar) ofrece usleep. Puede también usar la versión de select de cuatro argumentos, dejando los tres primeros indefinidos, o puede usar la interfaz syscall para acceder a setitimer(2) si su sistema lo soporta. Vea perlfaq8 para más detalles.

Vea también la función pause del módulo POSIX.

socket SOCKET,DOMINIO,TIPO,PROTOCOLO

Abre un socket de la clase especificada y lo adhiere al identificador de archivo SOCKET. DOMINIO, TIPO y PROTOCOLO se especifican de la misma manera que la llamada del sistema del mismo nombre. Debe usar use Socket primero para obtener las apropiadas definiciones. Ver los ejemplos en "Sockets: Comunicación Cliente/Servidor" in perlipc.

En sistemas que soportan el indicador close-on-exec (cerrar en ejecución) en archivos, este indicador se establecerá para el descriptor de archivo abierto más recientemente según lo determinado por el valor de $^F. Ver "$^F" in perlvar.

socketpair SOCKET1,SOCKET2,DOMINIO,TIPO,PROTOCOLO

Crea un par de sockets anónimos en el dominio especificado, del tipo especificado. DOMINIO, TIPO y PROTOCOLO se especifican de la misma manera que la llamada del sistema del mismo nombre. Si no está implementada, lanza una excepción. Devuelve verdadero si tuvo éxito.

En sistemas que soportan el indicador close-on-exec (cerrar en ejecución) en archivos, este indicador se establecerá para los descriptores de archivo abierto más recientemente según lo determinado por el valor de $^F. Ver "$^F" in perlvar.

Algunos sistemas definen pipe en términos de socketpair, en el que una llamada a pipe($rdr, $wtr) es esencialmente:

    use Socket;
    socketpair(my $rdr, my $wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC);
    shutdown($rdr, 1);        # no más escrituras para el lector
    shutdown($wtr, 0);        # no más lecturas para el escritor

Ver perlipc para un ejemplo de uso de socketpair. Perl 5.8 y siguientes emularán socketpair usando sockets IP a localhost si el sistema implementa sockets pero no socketpair.

Cuestiones de portabilidad: "socketpair" in perlport.

sort NOMBRE_SUB LISTA
sort BLOQUE LISTA
sort LISTA

En contexto lista, ordena la LISTA y devuelve los valores de la lista ordenados. En contexto escalar, el comportamiento de sort es indefinido.

Si se omite NOMBRE_SUB O BLOQUE, se ordena siguiendo una comparación estándar de cadenas de caracteres. Si se ha especificado NOMBRE_SUB, da el nombre de la subrutina que devuelve un entero menor que, igual que, o mayor que 0, dependiendo de cómo los elementos de la lista tienen que ordenarse. (Los operadores <=> y cmp son muy útiles en este tipo de rutinas). NOMBRE_SUB puede ser el nombre de una variable escalar, en cuyo caso el valor provee el nombre de (o la referencia a) la subrutina real a usar. En lugar de un NOMBRE_SUB, puede proporcionar un BLOQUE como si fuera una subrutina de ordenación anónima.

Si el prototipo de la subrutina es ($$), los elementos a compararse se pasan por referencia en @_, como en una subrutina normal. Esto es más lento que las subrutinas no prototipadas, donde los elementos a comparar se pasan a la subrutina en las variables globales del paquete actual $a y $b (ver ejemplo más abajo). Tenga en cuenta que en el último caso, suele ser altamente contraproducente declarar $a y $b como léxicas.

Si la subrutina es un XSUB, los elementos que deben compararse son metidos en la pila, que es la forma normal en que los argumentos son pasados a las XSUB. $a y $b no se establecen.

Los valores a compararse siempre se pasan por referencia y no deben modificarse.

También no puede salir fuera del bloque de ordenación o de la subrutina utilizando cualquiera de los operadores de control de bucle descritos en perlsyn o con goto.

Cuando use locale está activo (pero no use locale ':not_characters'), sort LISTA ordena LISTA de acuerdo con la actual configuración regional de cotejo. Vea perllocale.

sort devuelve alias en la lista original, como lo hace la variable de índice de los bucles for(), que hace un alias de los elementos de la lista. Es decir, modificar un elemento de la lista devuelto por sort (por ejemplo, en un foreach, map u otro grep) realmente modifica el elemento en la lista original. Esto suele ser algo que debe evitarse cuando se está escribiendo código claro.

Perl v5.6 y anteriores usaban un algoritmo quicksort para implementar sort. Este algoritmo no era estable, y podría ser cuadrático. (Un sort estable preserva el orden de los elementos de entrada que sean iguales en la comparación. Aunque el tiempo de ejecución de quicksort es O(NlogN) de promedio de todos los arrays de longitud N, el tiempo puede ser O(N**2), comportamiento cuadrático, para algunas entradas). En v5.7 la implementación de quicksort fue reemplazada con un algoritmo estable mergesort cuyo peor comportamiento es O(NlogN). Pero los benchmarks indicaron que, para algunas entradas, en algunas plataformas, el quicksort original era más rápido. 5,8 tiene un pragma para sort, para un control limitado de la ordenación. Su contundente control del algoritmo subyacente quizás no persista en versiones futuras de Perl, pero la capacidad para caracterizar la entrada o salida en implementaciones independientes muy probablemente lo hará.

Ejemplos:

    # ordenación léxica
    my @articulos = sort @archivos;

    # lo mismo, pero con una rutina de ordenación explícita
    my @articulos = sort {$a cmp $b} @archivos;

    # ahora, independiente del tamaño de caja
    my @articulos = sort {fc($a) cmp fc($b)} @archivos;

    # lo mismo, en orden inverso
    my @articulos = sort {$b cmp $a} @archivos;

    # ordenación numérica ascendente
    my @articulos = sort {$a <=> $b} @archivos;

    # ordenación numérica descendente
    my @articulos = sort {$b <=> $a} @archivos;

    # esto ordena el hash %edad por valor en lugar de por clave
    # usando una función incluida
    my @eldest = sort { $edad{$b} <=> $edad{$a} } keys %edad;

    # ordena usando un nombre de una subrutina explícita
    sub por_edad {
        $edad{$a} <=> $edad{$b};  # presumimos numéricos
    }
    my @claseordenada = sort por_edad @clase;

    sub al_reves { $b cmp $a }
    my @harry  = qw(dog cat x Cain Abel);
    my @george = qw(gone chased yz Punished Axed);
    print sort @harry;
        # prints AbelCaincatdogx
    print sort al_reves @harry;
        # prints xdogcatCainAbel
    print sort @george, 'to', @harry;
        # prints AbelAxedCainPunishedcatchaseddoggonetoxyz

    #  ordenación ineficiente por comparación numérica descendente usando
    # el primer entero después del signo =, o, de otra forma, todo
    # el registro, independientemente del tamaño de caja

    my @nuevo = sort {
        ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
                            ||
                    fc($a)  cmp  fc($b)
    } @viejo;

    # lo mismo, pero mucho más eficiente;
    # construiremos índices auxiliares
    # para aumentar la velocidad
    my (@numeros, @mayusculas);
    for (@viejo) {
        push @numeros, ( /=(\d+)/ ? $1 : undef );
        push @mayusculas, fc($_);
    }

    my @nuevo = @viejo[ sort {
                           $numeros[$b] <=> $numeros[$a]
                                    ||
                           $mayusculas[$a] cmp $mayusculas[$b]
                         } 0..$#viejo
                  ];

    # lo mismo, pero sin usar ninguna variable temporal
    my @new = map { $_->[0] }
           sort { $b->[1] <=> $a->[1]
                           ||
                  $a->[2] cmp $b->[2]
           } map { [$_, /=(\d+)/, fc($_)] } @viejo;

    # usando un prototipo permite usar cualquier subrutina de comparación
    # como una subrutina para sort (incluyendo subrutinas de otros paquetes)
    package Otro;
    sub al_reves ($$) { $_[1] cmp $_[0]; }   # $a y $b
                                             # no se usan aquí
    package main;
    my @new = sort Otro::backwards @old;

    # garantiza estabilidad, sin importar el algoritmo
    use sort 'stable';
    my @nuevo = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @viejo;

    # fuerza el uso del mergesort (no portátil fuera de Perl v5.8)
    use sort '_mergesort';  # note el desalentador _
    my @nuevo = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @viejo;

Advertencia: es requerido un cuidado sintáctico cuando se ordena la lista devuelta desde una función. Si quiere ordenar la lista devuelta por la llamada a la función find_records(@key), puede usar:

    my @contacto = sort { $a cmp $b } busca_registros @claves;
    my @contacto = sort +busca_registros(@claves);
    my @contacto = sort &busca_registros(@claves);
    my @contacto = sort(busca_registros(@claves));

Si, en cambio, quiere ordenar el array @claves con la rutina de comparación busca_registros() entonces puede usar:

    my @contacto = sort { busca_registros() } @claves;
    my @contacto = sort busca_registros(@claves);
    my @contacto = sort(busca_registros @claves);
    my @contacto = sort(busca_registros (@claves));

No debe declarar $a y $b como léxicas. Son variables globales del paquete. Esto significa que si usted está en el paquete main y escribe

    my @articulos = sort {$b <=> $a} @archivos;

entonces $a y $b son $main::a y $main::b (o $::a y $::b), pero si está en el paquete FooPack, es lo mismo que escribir

    my @articulos = sort {$FooPack::b <=> $FooPack::a} @archivos;

Se requiere que la función de comparación se comporte de forma correcta. Si devuelve resultados inconsistentes (algunas veces diciendo que $x[1] es menor que $x[2] y otras veces diciendo lo opuesto, por ejemplo) los resultados no están definidos.

Dado que <=> devuelve undef cuando alguno de los operandos es NaN (not-a-number, "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. En el ejemplo siguiente se aprovecha de que NaN != NaN para eliminar cualquier NaN de la lista de entrada.

    my @resultado = sort { $a <=> $b } grep { $_ == $_ } @entrada;
splice ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA
splice ARRAY,DESPLAZAMIENTO,LONGITUD
splice ARRAY,DESPLAZAMIENTO
splice ARRAY

Elimina los elementos designados por DESPLAZAMIENTO y LONGITUD de un array, y los sustituye por los elementos de LISTA, si los hubiere. En contexto lista, devuelve los elementos retirados del array. En contexto escalar, devuelve el último elemento eliminado, o undef si no hay elementos eliminados. El array crece o se reduce según sea necesario. Si el DESPLAZAMIENTO es negativo, se cuenta la posición desde el final del array. Si se omite LONGITUD, se suprime todo desde DESPLAZAMIENTO en adelante. Si LONGITUD es negativa, elimina los elementos desde DESPLAZAMIENTO hacia adelante, excepto -LONGITUD elementos al final del array. Si ambos DESPLAZAMIENTO y LONGITUD se omiten, quita todo. Si el DESPLAZAMIENTO está más allá del final del array y se indica una LONGITUD, Perl lanza una advertencia, y extrae al final del array.

Las siguientes equivalencias se mantienen (suponiendo que $#a >= $i)

    push(@a,$x,$y)      splice(@a,@a,0,$x,$y)
    pop(@a)             splice(@a,-1)
    shift(@a)           splice(@a,0,1)
    unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)
    $a[$i] = $y         splice(@a,$i,1,$y)

Se puede usar splice, por ejemplo, para implementar una cola de procesamiento de aridad n:

    sub print_n_ario {
      my $n = shift;
      while (my @siguiente_n = splice @_, 0, $n) {
        say join q{ -- }, @siguiente_n;
      }
    }

    print_n_ario(3, qw(a b c d e f g h));
    # imprime:
    #   a -- b -- c
    #   d -- e -- f
    #   g -- h

A partir de 5.14, una característica experimental permitía a splice tomar una expresión escalar. Se ha considerado que este experimento no ha funcionado, y se quitó a partir de Perl 5.24.

split /PATRÓN/,EXPR,LÍMITE
split /PATRÓN/,EXPR
split /PATRÓN/
split

Divide la cadena EXPR en una lista de cadenas y devuelve esa lista en contexto lista, o el tamaño de la lista en contexto escalar.

Si sólo se indica PATRÓN, EXPR es, por defecto, $_.

Cualquier cosa en EXPR concordante con el PATRÓN se toma como un delimitador que divide EXPR en subcadenas (llamadas "campos") que no incluyen al separador. Observe que un separador puede ser más largo que un carácter o incluso no tener ningún carácter en absoluto (la cadena vacía, que es una coincidencia de ancho cero).

El PATRÓN no necesita ser una constante; se puede usar una expresión para especificar un patrón que varía durante la ejecución.

Si el PATRÓN coincide con la cadena vacía, la EXPR es dividida en las posiciones coincidentes (entre los caracteres). Como ejemplo, los siguientes:

    print join(':', split(/b/, 'abc')), "\n";

usa la b en 'abc' como separador para producir la salida a:c. Sin embargo, esto:

    print join(':', split(//, 'abc')), "\n";

utiliza las coincidencias de cadena vacía como separadores para producir la salida a:b:c, por lo que la cadena vacía puede utilizarse para dividir EXPR en una lista de los caracteres que lo componen.

Como un caso especial para split, el patrón vacío indicado en la sintaxis del operador de coincidencia (//), coincide específicamente con la cadena vacía, que es lo contrario de la interpretación usual de ser igual a la última coincidencia exitosa.

Si PATRÓN es /^/, entonces se trata como si estuviera presente el modificador multilínea (/^/m), ya que de lo contrario no serviría de mucho.

Como otro caso especial, split emula el comportamiento predeterminado de la herramienta de línea de comando awk cuando el PATRÓN se omite o es una cadena literal compuesta de un único carácter de espacio (tal como ' ' o "\x20", pero no, por ejemplo, / /). En este caso, cualquier espacio en blanco que rodee a EXPR es eliminado antes de que ocurra la división, y el PATRÓN es tratado como si fuera /\s+/; en particular, esto significa que cualquier espacio en blanco contiguo (no sólo un carácter de espacio) es utilizado como separador. Sin embargo, este tratamiento especial puede evitarse especificando el patrón / / en lugar de la cadena " ", permitiendo así que sólo un único carácter de espacio sea el separador. En versiones anteriores de Perl, este caso especial estuvo restringido al uso de un sencillo " " como el argumento de patrón para split; en Perl 5.18.0 y siguientes, este caso especial se activa por cualquier expresión que evalúe a la cadena de caracteres " ".

Si se omite, el PATRÓN por defecto es un único espacio, " ", lo que provoca el comportamiento de la emulación awk descrita anteriormente.

Si se ha especificado un LÍMITE, y es positivo, representa el máximo número de campos en que EXPR puede ser dividido; en otras palabras, LÍMITE es uno mayor que el máximo número de veces que EXPR puede ser dividido. Por lo tanto, el valor LÍMITE 1 significa que EXPR puede dividirse un máximo de cero veces, produciendo un máximo de un campo (es decir, el valor total de EXPR). Por ejemplo:

    print join(':', split(//, 'abc', 1)), "\n";

produce la salida abc, y esto:

    print join(':', split(//, 'abc', 2)), "\n";

produce la salida a:bc, y cada uno de estos:

    print join(':', split(//, 'abc', 3)), "\n";
    print join(':', split(//, 'abc', 4)), "\n";

produce la salida a:b:c.

Si LÍMITE es negativo, se trata como si se hubiera especificado un LÍMITE arbitrariamente grande; se producen tantos campos como sea posible.

Si LÍMITE es omitido (o, de forma equivalente, cero), entonces es tratado como si fuera negativo, pero con la salvedad de que los campos vacíos son eliminados (los campos vacíos limítrofes siempre son conservados); si todos los campos están vacíos, entonces todos los campos son considerados que son pertenecientes del final (y por lo tanto, en este caso, son eliminados). 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 críticas con el tiempo, no es conveniente dividir en más campos de los que realmente se necesita. Por lo tanto, cuando se asigna a una lista, si LÍMITE se omite (o es cero), entonces LÍMITE se trata como si fuera uno más que el número de variables que hay en la lista; para lo siguiente, LÍMITE es implícitamente 3:

    my ($login, $contraseña) = split(/:/);

Tenga en cuenta que la división de una EXPR que evalúe a una cadena vacía siempre produce cero campos, sin importar qué LÍMITE se haya especificado.

Se produce un campo limítrofe vacío cuando hay una coincidencia de ancho positivo al comienzo de EXPR. Por ejemplo:

    print join(':', split(/ /, ' abc')), "\n";

produce la salida :abc. Sin embargo, una coincidencia de ancho cero al comienzo de EXPR nunca produce un campo vacío, de modo que:

    print join(':', split(//, ' abc'));

produce la salida :a:b:c (en lugar de : :a:b:c).

Se produce un campo vacío posterior, por el contrario, cuando existe una coincidencia al final de EXPR, independientemente de la longitud de la coincidencia (por supuesto, a menos que un LÍMITE distinto de cero se haya indicado explícitamente, porque si no, tales campos son eliminados, como en el último ejemplo). Por lo tanto:

    print join(':', split(//, ' abc', -1)), "\n";

produce la salida :a:b:c:.

Si el PATRÓN contiene grupos de captura, entonces, por cada separador, se produce un campo adicional para cada subcadena capturada por un grupo (en el orden en que los grupos se especifican, como lo hacen las retrorreferencias); si algún grupo no coincide, entonces captura el valor undef en lugar de una subcadena. Además, note que se produce un campo adicional cada vez que exista un separador (es decir, cuando se produce una división), y tales campos adicionales no cuentan para el LÍMITE. Considere las siguientes expresiones evaluadas en contexto de lista (se indica cada lista devuelta en el comentario correspondiente):

    split(/-|,/, "1-10,20", 3)
    # ('1', '10', '20')

    split(/(-|,)/, "1-10,20", 3)
    # ('1', '-', '10', ',', '20')

    split(/-|(,)/, "1-10,20", 3)
    # ('1', undef, '10', ',', '20')

    split(/(-)|,/, "1-10,20", 3)
    # ('1', '-', '10', undef, '20')

    split(/(-)|(,)/, "1-10,20", 3)
    # ('1', '-', undef, '10', undef, ',', '20')
sprintf FORMATO, LISTA

Devuelve una cadena formateada por los habituales convenios de printf de la función de biblioteca sprintf. Vea más abajo para detalles y vea sprintf(3) o printf(3) en su sistema para obtener una explicación de los principios generales.

Por ejemplo:

        # Formatea número con un máximo de 8 ceros iniciales
        my $resultado = sprintf("%08d", $numero);

        # Redondea número a 3 dígitos después del punto decimal
        my $redondeo = sprintf("%.3f", $numero);

Perl hace su propio formateo sprintf: emula la función del C sprintf(3), pero no la usa, excepto para los números en coma flotante, y aún entonces sólo se admiten modificadores estándares. Extensiones no estándares en su sprintf(3) regional, por lo tanto, no estarán disponibles desde Perl.

A diferencia de printf, sprintf no hace lo que probablemente quiere decir cuando se le pasa un array como primer argumento. El array se le da en contexto escalar, y en lugar de utilizar el elemento 0 del array como el formato, Perl usará el número de elementos del array como el formato, que casi nunca es útil.

El sprintf de Perl permite las siguientes conversiones universalmente conocidas:

   %%    un signo de por ciento
   %c    un carácter del numero indicado
   %s    una cadena
   %d    un 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
   %e    un número en punto flotante, en notación científica
   %f    un número en punto flotante, en notación decimal fija
   %g    un número en punto flotante, en notación %e o %f

Además, Perl permite las siguientes conversiones ampliamente soportadas:

   %X    como %x, pero usando mayúsculas
   %E    como %e, pero usando una letra "E" mayúscula
   %G    como %g, pero con una letra letra "E" mayúscula (si es aplicable)
   %b    un entero sin signo, en binario
   %B    como %b, pero usando una letra "B" mayúscula con el indicador #
   %p    un puntero (sale la dirección del valor Perl en hexadecimal)
   %n    especial: *almacena* el número de caracteres de la salida hasta el momento
         en el siguiente argumento en la lista de parámetros
   %a    punto flotante hexadecimal
   %A    como %a, pero usando letras en mayúscula

Por último, para compatibilidad anterior (y nos referimos a "hacia atrás"), Perl permite estas innecesarias, pero ampliamente soportadas conversiones:

   %i    un sinónimo para %d
   %D    un sinónimo para %ld
   %U    un sinónimo para %lu
   %O    un sinónimo para %lo
   %F    un sinónimo para %f

Tenga en cuenta que el número de dígitos del exponente en notación científica producida por %e, %E, %g y %G para los números con el módulo del exponente menor de 100 es dependiente del sistema: puede ser de tres o menos (con relleno de ceros según sea necesario). En otras palabras, 1.23 por diez elevado a 99 puede ser "1.23e99" o "1.23e099". De modo parecido para %a y %A: el exponente o los dígitos hexadecimales pueden flotar: especialmente la opción de configuración Perl para los "dobles largos" puede causar sorpresas.

Entre el % y la letra de formato, puede especificar varios atributos adicionales controlando la interpretación del formato. En fin, estos son:

índice de parámetro de formato

Un explícito índice de parámetros de formato, tales como 2$. Por defecto sprintf formateará el siguiente argumento no utilizado en la lista, pero esto le permite tomar los argumentos fuera de orden:

  printf '%2$d %1$d', 12, 34;      # imprime "34 12"
  printf '%3$d %d %1$d', 1, 2, 3;  # imprime "3 1 1"
indicadores

uno o más de:

   espacio prefija un número no negativo con un espacio
   +       prefija un número no negativo con un signo más
   -       justifica a la izquierda dentro del campo
   0       usa ceros, no espacios, justificados a la derecha
   #       asegura el precedente "0" para cualquier octal,
           prefija hexadecimales no ceros con "0x" o "0X",
           prefija binarios no cero con "0b" o "0B"

Por ejemplo:

  printf '<% d>',  12;   # imprime "< 12>"
  printf '<% d>',   0;   # imprime "< 0>"
  printf '<% d>', -12;   # imprime "<-12>"
  printf '<%+d>',  12;   # imprime "<+12>"
  printf '<%+d>',   0;   # imprime "<+0>"
  printf '<%+d>', -12;   # imprime "<-12>"
  printf '<%6s>',  12;   # imprime "<    12>"
  printf '<%-6s>', 12;   # imprime "<12    >"
  printf '<%06s>', 12;   # imprime "<000012>"
  printf '<%#o>',  12;   # imprime "<014>"
  printf '<%#x>',  12;   # imprime "<0xc>"
  printf '<%#X>',  12;   # imprime "<0XC>"
  printf '<%#b>',  12;   # imprime "<0b1100>"
  printf '<%#B>',  12;   # imprime "<0B1100>"

Cuando se dan como indicadores un espacio y un signo más, de forma simultánea, se usa un signo más para prefijar un número positivo.

  printf '<%+ d>', 12;   # imprime "<+12>"
  printf '<% +d>', 12;   # imprime "<+12>"

Cuando el indicador # y una precisión se dan en la conversión %o, la precisión es incrementada si es necesario para el "0" inicial.

  printf '<%#.5o>', 012;      # imprime "<00012>"
  printf '<%#.5o>', 012345;   # imprime "<012345>"
  printf '<%#.0o>', 0;        # imprime "<0>"
vector de indicadores

Este indicador le dice a Perl que interprete la cadena indicada como un vector de enteros, uno para cada carácter en la cadena. Perl aplica el formato a cada entero por turno, luego une las cadenas resultantes con un separador (un punto . por defecto). Esto puede ser útil para mostrar los valores ordinales de caracteres en cadenas arbitrarias:

  printf "%vd", "AB\x{100}";           # imprime "65.66.256"
  printf "versión es v%vd\n", $^V;     # Versión de Perl

Pone un asterisco * antes de v para reemplazar la cadena a utilizar para separar los números:

  printf "dirección es %*vX\n", ":", $addr;   # dirección IPv6
  printf "bits son %0*v8b\n", " ", $bits;     # cadena de bits aleatoria

También puede especificar, explícitamente, el número de argumento a utilizar para la combinación de cadena usando algo como *2$v; por ejemplo:

  printf '%*4$vX %*4$vX %*4$vX',       # 3 direcciones IPv6
          @addr[1..3], ":";
ancho (mínimo)

Los argumentos son por lo general formateados para ser sólo tan amplios como para mostrar el valor dado. Puede reemplazar el ancho al anteponer un número, u obteniendo la anchura del siguiente argumento (con *) o de un argumento determinado (por ejemplo, con *2$):

 printf "<%s>", "a";       # imprime "<a>"
 printf "<%6s>", "a";      # imprime "<     a>"
 printf "<%*s>", 6, "a";   # imprime "<     a>"
 printf '<%*2$s>', "a", 6; # imprime "<     a>"
 printf "<%2s>", "long";   # imprime "<long>" (no lo trunca)

Si un ancho de campo obtenido a través de * es negativo, tiene el mismo efecto que el indicador -: alineación a la izquierda.

precisión, o ancho máximo

Puede especificar una precisión (para las conversiones numéricas) o una anchura máxima (para las conversiones de cadena) mediante la especificación de un . seguido de un número. Para formatos en punto flotante excepto g y G, especifica cuántos lugares a la derecha del punto decimal debe mostrar (el valor predeterminado es 6). Por ejemplo:

  # estos ejemplos están sujetos a variaciones específicas del sistema
  printf '<%f>', 1;    # imprime "<1.000000>"
  printf '<%.1f>', 1;  # imprime "<1.0>"
  printf '<%.0f>', 1;  # imprime "<1>"
  printf '<%e>', 10;   # imprime "<1.000000e+01>"
  printf '<%.1e>', 10; # imprime "<1.0e+01>"

Para "g" y "G", especifica el número máximo de dígitos a mostrar, incluyendo los anteriores al punto decimal y los posteriores a él; por ejemplo:

  # Estos ejemplos están sujetos a variaciones específicas del sistema.
  printf '<%g>', 1;        # imprime "<1>"
  printf '<%.10g>', 1;     # imprime "<1>"
  printf '<%g>', 100;      # imprime "<100>"
  printf '<%.1g>', 100;    # imprime "<1e+02>"
  printf '<%.2g>', 100.01; # imprime "<1e+02>"
  printf '<%.5g>', 100.01; # imprime "<100.01>"
  printf '<%.4g>', 100.01; # imprime "<100>"

Para las conversiones de entero, especificando una precisión implica que la salida del número en sí mismo debería rellenarse con ceros a este ancho, donde se pasa por alto a el indicador 0:

  printf '<%.6d>', 1;      # imprime "<000001>"
  printf '<%+.6d>', 1;     # imprime "<+000001>"
  printf '<%-10.6d>', 1;   # imprime "<000001    >"
  printf '<%10.6d>', 1;    # imprime "<    000001>"
  printf '<%010.6d>', 1;   # imprime "<    000001>"
  printf '<%+10.6d>', 1;   # imprime "<   +000001>"

  printf '<%.6x>', 1;      # imprime "<000001>"
  printf '<%#.6x>', 1;     # imprime "<0x000001>"
  printf '<%-10.6x>', 1;   # imprime "<000001    >"
  printf '<%10.6x>', 1;    # imprime "<    000001>"
  printf '<%010.6x>', 1;   # imprime "<    000001>"
  printf '<%#10.6x>', 1;   # imprime "<  0x000001>"

Para las conversiones de cadena, especificando una precisión trunca la cadena a la anchura especificada:

  printf '<%.5s>', "truncado";   # imprime "<trunc>"
  printf '<%10.5s>', "truncado"; # imprime "<     trunc>"

También puede obtener la precisión del siguiente argumento usando .* o de un argumento específico (ejemplo, con .*2$):

  printf '<%.6x>', 1;       # imprime "<000001>"
  printf '<%.*x>', 6, 1;    # imprime "<000001>"

  printf '<%.*2$x>', 1, 6;  # imprime "<000001>"

  printf '<%6.*2$x>', 1, 4; # imprime "<  0001>"

Si una precisión obtenida a través de * es negativa, se cuenta como no tener precisión en absoluto.

  printf '<%.*s>',  7, "cadena";   # imprime "<cadena>"
  printf '<%.*s>',  3, "cadena";   # imprime "<cad>"
  printf '<%.*s>',  0, "cadena";   # imprime "<>"
  printf '<%.*s>', -1, "cadena";   # imprime "<cadena>"

  printf '<%.*d>',  1, 0;   # imprime "<0>"
  printf '<%.*d>',  0, 0;   # imprime "<>"
  printf '<%.*d>', -1, 0;   # imprime "<0>"
size

Para conversiones numéricas, se puede especificar el tamaño del número a interpretar usando l, h, V, q, L, o ll. Para las conversiones de entero (d u o x X b i D U O), se asume que los números son, por lo general, de un tamaño, por defecto, de un entero de su plataforma (normalmente 32 or 64 bits), pero esto se puede reemplazar usando en su lugar uno de los tipos estándares de C, soportados por el compilador usado para construir Perl:

   hh          interpreta un entero como un "char" o "unsigned
               char" en Perl 5.14 o siguientes
   h           interpreta un entero como un "short" o
               "unsigned short"
   j           interpreta un entero como un tipo C "intmax_t" en Perl
               5.14 o superior, y solo con un compilador C99
               (no portable)
   l           interpreta un entero como un "long" o
               "unsigned long"
   q, L, o ll  interpreta un entero como un tipo C "long long",
               "unsigned long long", o "quad" (típicamente
               enteros 64-bit)
   t           interpreta un entero como "ptrdiff_t" del C en Perl
               Perl 5.14 o superior
   z           interpreta un entero como "size_t" del C en Perl 5.14
               o superior

A partir de 5.14, ninguno de estos produce una excepción si no están suportados en su plataforma. Sin embargo, si las advertencias están habilitadas, una advertencia de la clase printf se emite cuando no esté soportado el indicador de conversión. Si en vez de eso, prefiere una excepción, haga lo siguiente:

    use warnings FATAL => "printf";

Si quiere saber acerca de las dependencias de la versión antes de empezar a ejecutar el programa, poner algo como esto en su parte superior:

    use 5.014;  # para los modificadores hh/j/t/z/ en printf

Puede averiguar si su Perl soporta quads a través de Config:

    use Config;
    if ($Config{use64bitint} eq "define"
        || $Config{longsize} >= 8) {
        print "¡quads divertidos!\n";
    }

Para las conversiones de punto flotante (e f g E F G), se asume que los números son por lo general de punto flotante del tamaño de su plataforma (doble o doble largo), pero se puede forzar "long double" con q, L, o ll si la plataforma es compatible con ellas. Puede averiguar si su Perl soporta dobles a través de Config:

    use Config;
    print "long doubles\n" if $Config{d_longdbl} eq "define";

puede averiguar si Perl considera "long double" como el valor por defecto para el tamaño del punto flotante para su plataforma a través de Config:

    use Config;
    if ($Config{uselongdouble} eq "define") {
        print "long doubles por defecto\n";
    }

También puede ser que los long doubles y doubles sean la misma cosa:

        use Config;
        ($Config{doublesize} == $Config{longdblsize}) &&
                print "doubles son long doubles\n";

La especificación de tamaño V no tiene ningún efecto en el código Perl, pero se admite para la compatibilidad con el código XS. Esto significa "usar el tamaño estándar de un entero Perl o punto de número de coma flotante", que es el predeterminado.

orden de los argumentos

Normalmente, sprintf toma el siguiente argumento utilizado como el valor de formato para cada especificación de formato. Si la especificación de formato utiliza * para exigir argumentos adicionales, estos se consumen de la lista de argumentos en el orden en que aparecen en la especificación del formato antes del valor a dar formato. Cuando se especifica un argumento por un índice explícito, esto no afecta el orden normal de los argumentos, incluso cuando el índice especificado explícitamente habría sido el siguiente argumento.

Así:

    printf "<%*.*s>", $a, $b, $c;

usa $a para el ancho, $b para la precisión, y $c como el valor a formatear; mientras:

  printf '<%*1$.*s>', $a, $b;

usaría $a para el ancho y precisión, y $b como el valor a formatear.

Éstos son algunos ejemplos más; sea consciente de que cuando se utiliza un índice explícito, el $ puede ser necesario escaparlo:

 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"
 printf "%*1\$.*f\n",       4,  5, 10; # imprimirá "5.0000\n"

Si use locale (incluyendo use locale ':not_characters') está en activo y se ha llamado a POSIX::setlocale, el carácter utilizado para el separador decimal en números formateados en punto flotante se ve afectado por la configuración regional de LC_NUMERIC. Ver perllocale y POSIX.

sqrt EXPR
sqrt

Devuelve la raíz cuadrada positiva de EXPR. Si se omite EXPR, usa $_. Sólo funciona para operandos no negativos a menos que haya cargado el módulo Math::Complex.

    use Math::Complex;
    print sqrt(-4);    # imprime 2i
srand EXPR
srand

Establece y devuelve la semilla de números aleatorios para el operador rand.

La misión de la función es "alimentar" a la función rand para que pueda producir una secuencia diferente cada vez que ejecute su programa. Cuando se llama con un parámetro, srand la usa para la semilla; de lo contrario la elige (semi)-aleatoriamente. En cualquier caso, a partir de Perl 5.14, devuelve la semilla. Para indicar que su código funciona solo en un Perl de una cosecha reciente:

    use 5.014;  # así srand devuelve la semilla

Si srand no se llama de forma explícita, se llama implícitamente en el primer uso del operador rand. Hay, sin embargo, unas pocas situaciones donde es probable que desee llamar a srand. Una de ellas es para la generación de resultados predecibles, generalmente para pruebas o depuraciones. Así, puede utilizar srand($semilla), con la misma $semilla cada vez. Otro caso es que puede llamar a srand después de un fork para evitar que los procesos hijos compartan el mismo valor de semilla que la del padre (y por lo tanto, entre sí).

No llame a srand() (e.d., sin un argumento) más de una vez por proceso. El estado interno del generador de números aleatorios debería contener más entropía que la ofrecida por cualquier semilla, así que volver a llamar a srand realmente hace perder la aleatoriedad.

La mayoría de las implementaciones de srand toman un número entero y silenciosamente truncará los números decimales. Esto significa que srand(42) produce los mismos resultados, generalmente, que srand(42.1). Para estar seguros, siempre pase un entero a srand.

Un uso típico de la semilla devuelta es para un programa de prueba que tiene demasiadas combinaciones que probar, exhaustivamente, en el tiempo disponible para cada ejecución. Se puede probar un subconjunto aleatorio cada vez, y si ocurre un fallo, registre las semillas utilizadas para las que se ha ejecutado a fin de que más adelante se puedan utilizar para reproducir los mismos resultados.

rand no es criptográficamente seguro. No debe confiar en él en situaciones delicadas de seguridad. Al escribir estas líneas, una serie de módulos de 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.

stat IDENTIFICADOR_ARCHIVO
stat EXPR
stat IDENTIFICADOR_DIR
stat

Devuelve una lista de 13 elementos dando la información de estado de un archivo, tanto si el archivo ha sido abierto a través de IDENTIFICADOR_ARCHIVO o IDENTIFICADOR_DIR, o nombrado por la EXPR. Si se omite EXPR, usa $_ (¡no _!). Devuelve la lista vacía si stat falla. Típicamente se usa como sigue:

    my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
        $atime,$mtime,$ctime,$blksize,$blocks)
           = stat($nombre_de_archivo);

No todos los campos están soportados por todos los sistemas de archivos. Aquí están los significados de los campos:

  0 dev      número de dispositivo del sistema de archivos
  1 ino      número de inodo
  2 mode     modo de archivo (tipo y permisos)
  3 nlink    número de enlaces (duros) al archivo
  4 uid      ID numérico del usuario propietario del archivo
  5 gid      ID numérico del grupo del propietario del archivo
  6 rdev     identificador del dispositivo (solo archivos especiales)
  7 size     tamaño total del archivo, en bytes
  8 atime    tiempo último acceso, en segundos, desde el epoch
  9 mtime    tiempo última modificación, en segundos desde el epoch
 10 ctime    tiempo cambio inodo, en segundos desde el (*)
 11 blksize  tamaño preferido de E/S en bytes para interactuar con el
             archivo (puede variar de archivo en archivo)
 12 blocks   número actual de bloques, específicos del sistema, reservados
             en disco (a menudo, pero no siempre, de 512 bytes cada uno)

(El epoch fue a las 00:00 GMT del 1 de enero de 1970)

(*) No todos los campos están soportados por todos los sistemas de archivos. En particular, el campo ctime no es portátil. En particular, no puede esperar que sea el "tiempo de creación"; vea "Archivos y sistemas de archivos" in perlport para más detalles.

Si a stat se le pasa el identificador de archivo especial consistente en un subrayado, no se hacen estadísticas, sino que se devuelve el contenido actual de la estructura de estadísticas de la última llamada stat, lstat, o test de archivos. Ejemplo:

    if (-x $archivo && (($d) = stat(_)) && $d < 0) {
        print "$archivo es un archivo NFS ejecutable\n";
    }

(Esto funciona solo en máquinas en las cuales el número de dispositivo es negativo para NFS)

Dado que el modo contiene el tipo de archivo y sus permisos, debe desenmascarar la porción de tipo de archivo y usar (s)printf con "%o" si desea ver los permisos reales.

    my $modo = (stat($archivo))[2];
    printf "Permisos son %04o\n", $modo & 07777;

En contexto escalar, stat devuelve un valor booleano que indica el éxito o el 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;
    my $sb = stat($archivo);
    printf "Archivo es %s, tamaño es %s, perm %04o, mtime %s\n",
           $archivo, $sb->size, $sb->mode & 07777,
           scalar localtime $sb->mtime;

Puede importar constantes simbólicas (S_IF*) y funciones (S_IS*) desde el módulo Fcntl:

    use Fcntl ':mode';

    my $modo = (stat($archivo))[2];

    my $usuario_rwx    = ($modo & S_IRWXU) >> 6;
    my $grupo_lectura  = ($modo & S_IRGRP) >> 3;
    my $otros_ejecutar =  $modo & S_IXOTH;

    printf "Permisos son %04o\n", S_IMODE($modo), "\n";

    my $es_setuid      =  $modo & S_ISUID;
    my $es_directorio  =  S_ISDIR($modo);

Podría escribir las dos últimas utilizando los operadores -u y -d. Comúnmente disponibles las constantes S_IF* son:

    # Permisos: leer, escribir, ejecutar, por 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 esto es dependiente del sistema.

    S_ISUID S_ISGID S_ISVTX S_ISTXT

    # Tipos de archivo. No necesariamente todos estarán disponibles en
    # su sistema.

    S_IFREG S_IFDIR S_IFLNK S_IFBLK S_IFCHR
    S_IFIFO S_IFSOCK S_IFWHT S_ENFMT

    # Los siguientes son los alias compatibles para S_IRUSR,
    # S_IWUSR y S_IXUSR.

    S_IREAD S_IWRITE S_IEXEC

y las funciones S_IF* son

    S_IMODE($modo)    la parte de $modo conteniendo los bits de permiso
                      y los bits setuid/setgid/sticky

    S_IFMT($modo)    la parte de $modo conteniendo los bits del tipo de archivo
                      que pueden ser bit-andeados 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)

    # No tiene un operador -X parejo, pero para el primero
    # el operador -g es, a menudo, equivalente. El ENFMT significa
    # bloqueo forzado de registro, una característica dependiente de la plataforma.

    S_ISENFMT($modo) S_ISWHT($modo)

Consulte su documentación de las nativas chmod(2) y stat(2) para obtener más detalles acerca de las constantes S_*. Para obtener información de estado de un enlace simbólico en lugar del archivo de destino tras el enlace, utilice la función lstat.

Cuestiones de portabilidad: "stat" in perlport.

state LISTAVAR
state TIPO LISTAVAR
state LISTAVAR: ATRIBUTOS
state TIPO LISTAVAR : ATRIBUTOS

state declara una variable de ámbito léxico, como lo hace my. Sin embargo, estas variables no se reinicializan, a diferencia de las variables léxicas que se reinicializan cada vez que entran en un bloque. Vea "Variables privadas persistentes" in perlsub para los detalles.

Si se lista más de una variable, la lista debe ser puesta entre paréntesis. Con una lista entre paréntesis, se puede utilizar undef como un marcador de posición. Sin embargo, debido a que actualmente la inicialización de las variables state en contexto de lista no es posible, esto no sirve para nada.

state sólo está disponible si la característica "state" feature está habilitada o si está prefijada con CORE::. La característica "state" feature se activa automáticamente con una declaración use v5.10 (o superior) en el ámbito actual.

study ESCALAR
study

Note que desde la versión Perl 5.16 esta función es una no-operación, pero puede cambiar en una futura versión.

Toma tiempo extra para estudiar ESCALAR ($_ si no se especifica) en previsión de hacer muchos patrones de coincidencia en la cadena antes de una posterior modificación. Esto puede o no ahorrar tiempo, dependiendo de la naturaleza y el número de patrones que esté buscando y sobre la distribución de frecuencias de caracteres de la cadena a buscar; probablemente querrá comparar los tiempos de funcionamiento con y sin él para ver qué funciona más rápido. Los bucles que escanean por muchas cadenas constantes cortas (incluidas las partes constante de patrones más complejos) serán los más beneficiados.

(La forma en que study funciona es la siguiente: se crea una lista enlazada de todos los caracteres en la cadena que se deben buscar, y así sabremos, por ejemplo, donde están todos los caracteres 'k'. De cada cadena de búsqueda, se selecciona el carácter más raro, en función de algunas tablas de frecuencia estática construidas a partir de algunos programas en C y texto en inglés. Sólo son examinados estos lugares que contienen este "carácter" más raro).

Por ejemplo, aquí hay un bucle que inserta índices de entradas antes de cualquier línea que contenga un cierto patrón:

    while (<>) {
        study;
        print ".IX foo\n"    if /\bfoo\b/;
        print ".IX bar\n"    if /\bbar\b/;
        print ".IX blurfl\n" if /\bblurfl\b/;
        # ...
        print;
    }

En la búsqueda de /\bfoo\b/, los únicos lugares que se examinarán de $_ serán los que contengan una f, debido a que f es más rara que una o. En general, esto es un gran ahorro, salvo en casos patológicos. La única pregunta es si ahorra más tiempo que en lo que se tardó en construir la lista enlazada, al principio.

Tenga en cuenta que si tiene que buscar en cadenas que no conoce hasta el tiempo de ejecución, puede crear un bucle completo como una cadena y luego hacerle un eval, para evitar tener que volver a recompilar todos los patrones todo el tiempo. Junto con la indefinición de $/ para la entrada de archivos completos como un único registro, esto puede ser bastante rápido, a menudo más rápido que los programas especializados como fgrep(1). Lo siguiente examina una lista de archivos (@archivos) por una lista de palabras (@palabras), e imprime los nombres de los archivos que contienen una coincidencia:

    my $buscar = 'local $/; while (<>) { study;';
    foreach my $palabra ( @palabras ) {
        $buscar .= "++\$visto{\$ARGV} if /\\b$palabra\\b/;\n";
    }
    $buscar .= "}";
    @ARGV = @archivos;
    my %visto;
    eval $buscar;        # esto aúlla
    foreach my $archivo (sort keys(%visto)) {
        print $archivo, "\n";
    }
sub NOMBRE BLOQUE
sub NOMBRE (PROTO) BLOQUE
sub NOMBRE : ATRIBS BLOQUE
sub NOMBRE (PROTO) : ATRIBS BLOQUE

Esta es la definición de subrutina, no una función real per se. Sin un BLOQUE es sólo una declaración previa. Sin un NOMBRE, es una declaración de una función anónima, y devuelve un valor: la referencia al CÓDIGO de la clausura que acaba de crear.

Vea perlsub y perlref para los detalles acerca de subrutinas y referencias; vea attributes y Attribute::Handlers para obtener más información acerca de los atributos.

__SUB__

Un token especial que devuelve una referencia a la subrutina actual, o undef si está fuera de una subrutina.

El comportamiento de __SUB__ dentro de un bloque de código con una expresión regular (como en /(?{...})/) está sujeto a cambio.

Este token sólo está disponible bajo use v5.16 o la característica "current_sub" feature. Ver feature.

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 el DESPLAZAMIENTO es negativo, se comienza a contar desde el final de la cadena. Si se omite LONGITUD, devuelve todo hasta el final de la cadena. Si LONGITUD es negativa, deja fuera a tantos caracteres del final de la cadena.

    my $s = "El gato negro subió el árbol verde";
    my $color  = substr $s, 8, 5;      # negro
    my $middle = substr $s, 3, -12;    # gato negro subió el
    my $end    = substr $s, 14;        # subió el árbol verde
    my $tail   = substr $s, -5;        # verde
    my $z      = substr $s, -5, 2;     # ve

Puede utilizar la función substr como un valor-izquierda, en cuyo caso la EXPR debe ser en si mismo un valor-izquierda. Si asigna algo más corto que LONGITUD, la cadena se reducirá, y si asigna algo más largo que LONGITUD, la cadena crecerá para acogerlo. Para mantener la cadena de la misma longitud, puede ser necesario rellenar o recortar su valor con sprintf.

Si DESPLAZAMIENTO y LONGITUD especifican una subcadena que está parcialmente fuera de la cadena, sólo la parte de dentro de la cadena se devuelve. Si la subcadena está más allá de cada extremo de la cadena, substr devuelve el valor indefinido y produce una advertencia. Cuando se utiliza como un valor-izquierda, especificando una subcadena que está totalmente fuera de la cadena lanza una excepción. Aquí un ejemplo que muestra el comportamiento para los casos límite:

    my $nombre = 'pedro';
    substr($nombre, 4) = 'ito';       # $nombre es ahora 'pedrito'
    my $nulo = substr $nombre, 7, 2;  # devuelve "" (sin advertencia)
    my $oops = substr $nombre, 7;     # devuelve undef, con advertencia
    substr($nombre, 7) = 'gap';       # lanza una excepción

Una alternativa al uso substr como un valor-izquierda es especificar la cadena de reemplazo como el cuarto argumento. Esto le permite reemplazar partes de la EXPR y devolver lo que había antes, en una operación, tal como se puede hacer con splice.

    my $s = "El gato negro subió el árbol verde";
    my $z = substr $s, 14, 5, "saltó desde";    # subió
    # $s es ahora "El gato negro saltó desde el árbol verde"

Tenga en cuenta que el valor-izquierda devuelto por la versión de tres argumentos de substr actúa como una 'bala mágica'; cada vez que se le asigna, recuerda qué parte de la cadena original se ha modificado; por ejemplo:

    my $x = '1234';
    for (substr($x,1,2)) {
        $_ = 'a';   print $x,"\n";    # imprime 1a4
        $_ = 'xyz'; print $x,"\n";    # imprime 1xyz4
        $x = '56789';
        $_ = 'pq';  print $x,"\n";    # imprime 5pq9
    }

Con desplazamientos negativos, recuerda su posición desde el final de la cadena cuando la cadena destino es modificada:

    my $x = '1234';
    for (substr($x, -3, 2)) {
        $_ = 'a';   print $x,"\n";    # imprime 1a4, como antes
        $x = 'abcdefg';
        print $_,"\n";                # imprime f
    }

Antes de la versión Perl 5.10, no estaba especificado el resultado de usar varias veces un valor-izquierda. Antes de 5,16, el resultado con desplazamientos negativos no estaba especificado.

Crea un nuevo nombre de archivo vinculado simbólicamente al nombre del archivo antiguo. Devuelve 1 en caso de éxito; de otra manera, 0. En los sistemas que no admiten los enlaces simbólicos, produce una excepción. Para comprobar esto, use eval:

    my $symlink_existe = eval { symlink("",""); 1 };

Cuestiones de portabilidad: "symlink" in perlport.

syscall NÚMERO, LISTA

Llama a la llamada del sistema especificado en el primer elemento de la lista, pasando el resto de elementos como argumentos para la llamada al sistema. Si no está implementada, lanza una 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 la cadena. Es responsable de asegurarse de que una cadena sea pre-extendida el largo suficiente como para recibir cualquier resultado que pueda ser escrito en una cadena. No puede utilizar una cadena literal (u otras cadenas de sólo lectura) como un argumento a syscall porque Perl tiene que asumir que cualquier puntero de cadena se puede escribir a través de ella. Si sus argumentos enteros no son enteros, y nunca se han interpretado en un contexto numérico, es posible que deba agregarles 0 para obligarles a que se parezcan a números. Esto emula la función syswrite (o viceversa):

    require 'syscall.ph';        # puede necesitar ejecutar h2ph
    my $s = "hola por aquí\n";
    syscall(SYS_write(), fileno(STDOUT), $s, length $s);

Tenga en cuenta que Perl soporta pasar sólo hasta 14 argumentos a su syscall, que en la práctica debería (generalmente) ser suficiente.

Syscall devuelve cualquier valor devuelto por la llamada al sistema que llama. Si la llamada al sistema falla, syscall devuelve -1 y establece $! (errno). Tenga en cuenta que algunas llamadas al sistema pueden legalmente devolver -1. La forma correcta de gestionar llamadas de ese tipo es el de asignar $! = 0 antes de la llamada, y comprobar 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 tubería que crea, pero no hay manera de recuperar el número de archivo del otro extremo. Puede evitar este problema mediante el uso, en su lugar, de pipe.

Cuestiones de portabilidad: "syscall" in perlport.

sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO
sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO,PERMISOS

Abre el archivo cuyo nombre viene dado por ARCHIVO, y lo asocia con IDENTIFICADOR_ARCHIVO. Si IDENTIFICADOR_ARCHIVO es una expresión, el valor es tomado como el nombre real del identificador de archivo buscado; un escalar indefinido será autovivificado adecuadamente. Esta función llama a la función subyacente del sistema operativo open(2) con los parámetros ARCHIVO, MODO y PERMISOS.

Devuelve verdadero cuando tiene éxito, y undef en cualquier otro caso.

Los valores posibles y bits de indicador del parámetro MODO son dependientes del sistema; están disponibles en el módulo estándar Fcntl. Consulte la documentación de la llamada del sistema open(2) de su sistema operativo para ver qué valores y bit de indicadores están disponibles. Puede combinar varios indicadores con el operador |.

Algunos de los valores más comunes son O_RDONLY para abrir el archivo en modo de sólo lectura, O_WRONLY para abrir el archivo en modo de sólo escritura, y O_RDWR para abrir el archivo en modo lectura-escritura.

Por razones históricas, algunos valores funcionan en casi todos los sistemas soportados por Perl: 0 significa solo lectura, 1 significa sólo escritura y 2 significa lectura y escritura. Sabemos que estos valores no funcionan bajo OS/390 y el Macintosh; es probable que no desee utilizarlos en nuevos programas.

Si el archivo con el nombre ARCHIVO no existe y la llamada open lo crea (por lo general porque el modo incluye el indicador O_CREAT), entonces el valor de PERMISOS especifica los permisos del archivo recién creado. Si se omite el argumento PERMISOS a sysopen, Perl utiliza el valor octal 0666. Estos valores de permisos tiene que estar en octal, y se modifican por el valor de umask de su proceso actual.

En muchos sistemas el indicador O_EXCL está disponible para abrir archivos en modo exclusivo. Esto no es bloquear: la exclusividad significa aquí que si el archivo ya existe, sysopen falla. O_EXCL quizás no funcione en sistemas de archivos en red, y no tiene ningún efecto a menos que el indicador O_CREAT también esté establecido. Estableciendo O_CREAT|O_EXCL impide que el archivo sea abierto si es un enlace simbólico. No protege contra enlaces simbólicos en la ruta del archivo.

A veces puede querer truncar un archivo ya existente. Esto se puede hacer con el uso del indicador O_TRUNC. El comportamiento de O_TRUNC con O_RDONLY no está definido.

Rara vez o nunca debe utilizar 0644 como argumento a sysopen, porque eso le quita al usuario la opción de tener un umask más permisivo. Es mejor omitirlo. Vea umask para más detalles sobre esto.

Tenga en cuenta que bajo Perl anteriores a 5.8.0, sysopen depende de la función de biblioteca C fdopen(3). En muchos sistemas Unix, fdopen(3) se sabe que falla cuando los descriptores de archivo exceden un valor determinado, por lo general, 255. Si necesita más descriptores de archivo que esa cantidad, contemple la posibilidad de usar la función POSIX::open. Para las versiones de Perl 5.8.0 y posteriores, PerlIO es (casi siempre) el valor predeterminado.

Ver perlopentut para una más amable, más suave explicación de apertura de los archivos.

Cuestiones de portabilidad: "sysopen" in perlport.

sysread IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO
sysread IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD

Intenta leer LONGITUD bytes de datos en la variable ESCALAR desde el IDENTIFICADOR_ARCHIVO especificado, utilizando read(2). Omite E/S con búfer, por lo que mezclar esto con otros tipos de lecturas, print, write, seek, tell o eof puede causar confusión porque las capas Perlio o stdio por lo general usan búfer de datos. Devuelve el número de bytes realmente leídos, 0 al final del archivo, o undef si hubo un error (en este último caso se actualiza el valor de $!). ESCALAR crecerá o se reducirá de manera que el último byte realmente leído sea el último byte del escalar después de la lectura.

Un DESPLAZAMIENTO se puede especificar para colocar los datos leídos en algún otro lugar de la cadena, distinto del principio. Un DESPLAZAMIENTO negativo especifica el desplazamiento en número de caracteres contando desde el final de la cadena. Un DESPLAZAMIENTO positivo mayor que la longitud de ESCALAR resulta en un cadena rellenada al tamaño requerido con bytes "\0" antes de que el resultado de la lectura sea añadido.

No existe la función syseof(), que está bien, ya que, de todos modos, eof no funciona bien con los archivos de dispositivo (como los ttys). Use sysread y compruebe si el valor devuelto es 0 para decidir si ha llegado al final.

Tenga en cuenta que si el identificador de archivo se ha marcado como :utf8, se leen caracteres Unicode en lugar de bytes (la LONGITUD, el DESPLAZAMIENTO y el valor de retorno de sysread están descritos en forma de número de caracteres Unicode). La capa :encoding(...) introduce, implícitamente, la capa :utf8. Vea binmode, open y el pragma open

sysseek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE

Establece la posición del IDENTIFICADOR_ARCHIVO en bytes usando lseek(2). IDENTIFICADOR_ARCHIVO puede ser una expresión cuyo valor da el nombre del identificador de archivo. Los valores de DÓNDE son 0 para establecer la nueva posición a POSICIÓN; 1 para establecerla a la actual más POSICIÓN; y 2 para establecerla a EOF más POSICIÓN, normalmente negativa.

Nota sobre lo de en bytes: incluso si el identificador de archivo se ha establecido para operar en caracteres (por ejemplo usando la capa de open :encoding(utf8)), tell devolverá desplazamientos en bytes, no en caracteres (porque implementando esto convertirían en inaceptablemente lentas a seek y tell).

sysseek omite el búfer normal de E/S, por lo que mezclar esto con otros tipos de lecturas distintas de sysread (por ejemplo readline o read), print, write, seek, tell, o eof pueden causar confusión.

Para DÓNDE puede usar también las constantes SEEK_SET, SEEK_CUR y SEEK_END (inicio del archivo, posición actual y fin de archivo) desde el módulo Fcntl. El 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';
    sub systell { 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 but true" ("0 pero verdadero"), por lo que sysseek devuelve verdadero o falso en caso de error, sin embargo, usted puede determinar fácilmente la nueva posición.

system LISTA
system PROGRAMA LISTA

Hace exactamente lo mismo que exec, excepto que se hace primero un fork y el proceso padre espera a que el proceso hijo termine. Tenga en cuenta que el tratamiento de los argumentos varía en función del número de argumentos. Si hay más de un argumento en LISTA, o si la lista es un array con más de un valor, se inicia el programa indicado en el primer elemento de la lista, con los argumentos indicados por el resto de la lista. Si sólo hay un argumento escalar, se comprueba si el argumento tiene metacaracteres, y si hay alguno, el argumento entero es pasado al shell de comandos para interpretarse (suele ser /bin/sh -c en plataformas Unix, pero varía en otras plataformas). Si no hay metacaracteres shell en el argumento, es dividido en palabras y pasadas directamente a execvp, que es más eficiente. En Windows, solo la sintaxis de objetos indirecto en system PROGRAMA LISTA evitará, de forma efectiva, evitar usar la shell; system LISTA, incluso con más de un elemento, volverá a usar la shell si falla el primer intento de lanzamiento.

Perl intentará vaciar todos los archivos abiertos para la salida antes de cualquier operación que pueda hacer un fork, pero esto quizás no esté soportado en algunas plataformas (vea perlport). Para estar seguros, puede necesitar establecer $| ($AUTOFLUSH en el módulo English) o llamar el método autoflush de IO::Handle en cualquiera de los identificadores de archivo abiertos para evitar la pérdida de datos en la salida.

El valor devuelto es el estado de salida del programa devuelto por la llamada wait. Para obtener el valor real de la salida, se debe desplazar ocho a la derecha (ver más abajo). Vea también exec. Esto no es lo que desea utilizar para capturar la salida de un comando; para ello debería utilizar solamente las comillas invertidas o qx/, como se describe en "`CADENA`" in perlop. El valor de retorno de -1 indica un error en el arranque del programa o un error de la llamada al sistema wait(2) (inspeccionar $! para saber la razón).

Si desea hacer que system (y muchos otros fragmentos de Perl) mueran en caso de error, eche un vistazo al pragma autodie.

Al igual que exec, system permite reposar a un programa bajo un nombre, si se utiliza la sintaxis system PROGRAMA LISTA. De nuevo, vea también exec.

Puesto que SIGINT y SIGQUIT se ignoran durante la ejecución de system, si espera que su programa termina a la recepción de estas señales tendrá que disponer lo necesario para hacerlo usted mismo en función del valor de retorno.

    my @args = ("comando", "arg1", "arg2");
    system(@args) == 0
        or die "system @args falló: $?";

Si desea inspeccionar manualmente el error de system, puede comprobar todas las posibles causas del error mediante la inspección de $? como esto:

    if ($? == -1) {
        print "error al ejecutar: $!\n";
    }
    elsif ($? & 127) {
        printf "hijo muerto con señal %d, %s coredump\n",
            ($? & 127),  ($? & 128) ? 'con' : 'sin';
    }
    else {
        printf "hijo terminó con valor %d\n", $? >> 8;
    }

De forma alternativa, puede inspeccionar el valor de ${^CHILD_ERROR_NATIVE} con las llamadas W*() desde el módulo POSIX.

Cuando los argumentos de system se ejecutan indirectamente por el shell, los resultados y los códigos de retorno están sujetos a sus caprichos. Vea "`CADENA`" in perlop y exec para más detalles.

Debido a que system hace un fork y un wait puede afectar al controlador SIGCHLD. Vea perlipc para más detalles.

Cuestiones de portabilidad: "system" in perlport.

syswrite IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO
syswrite IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD
syswrite IDENTIFICADOR_ARCHIVO,ESCALAR

Intenta escribir LONGITUD bytes de datos desde la variable ESCALAR al IDENTIFICADOR_ARCHIVO especificado, utilizando write(2). Si LONGITUD no se especifica, escribe todo el ESCALAR. Omite el uso del búfer de E/S, así que mezclarlo con otras lecturas (distintas de sysread)), print, write, seek, tell, o eof pueden provocar confusión porque las capas perlio y stdio normalmente almacenan datos. Devuelve el número de bytes realmente escritos, o undef si hubo un error (en este caso, también se establece la variable $!). Si LONGITUD es mayor que los datos disponibles en ESCALAR después del DESPLAZAMIENTO, sólo se escribirán los datos que estén disponibles.

Un DESPLAZAMIENTO puede especificarse para escribir datos desde algún otro lugar de la cadena distinto del principio. Un DESPLAZAMIENTO negativo especifica escribir tantos caracteres contando desde el final de la cadena. Si ESCALAR es de longitud cero, sólo se puede utilizar un DESPLAZAMIENTO de 0.

ADVERTENCIA: Si el identificador de archivo está marcado como :utf8, se escriben caracteres Unicode codificados en UTF-8 en lugar de bytes, y la LONGITUD, DESPLAZAMIENTO y el valor de retorno de syswrite se basarán en caracteres (Unicode codificados en UTF-8). La capa :encoding(...) implícitamente introduce la capa :utf8. De forma alternativa, si el identificador no está marcado con una codificación pero intenta escribir caracteres con códigos de carácter superiores a 255, se genera una excepción. Vea binmode, open y el pragma open.

tell IDENTIFICADOR_ARCHIVO
tell

Devuelve la posición actual en bytes para IDENTIFICADOR_ARCHIVO, o -1 en caso de error. IDENTIFICADOR_ARCHIVO puede ser una expresión cuyo valor da el nombre del identificador de archivo real. Si IDENTIFICADOR_ARCHIVO se omite, se asume que es el último archivo leído.

Nota sobre lo de en bytes: incluso si el identificador de archivo se ha establecido para operar en caracteres (por ejemplo usando la capa de open :encoding(utf8)), tell devolverá desplazamientos en bytes, no en caracteres (porque esto convertirían en lentas a seek y tell).

El valor de retorno de tell para los flujos estándares como STDIN depende del sistema operativo: puede devolver -1 o algo más. tell en tuberías, colas, y sockets, por lo general, devuelve -1.

No existe la función systell. Use sysseek($fh, 0, 1) para eso.

No utilice tell (u otras operaciones de E/S con búfer) en un identificador de archivo que se ha manipulado con sysread, syswrite o sysseek. Esas funciones ignoran el sistema de búfer, mientras que tell, no.

telldir IDENTIFICADOR_DIR

Devuelve la posición actual de las rutinas readdir en IDENTIFICADOR_DIR. El valor se puede indicar a seekdir para acceder a un lugar determinado en un directorio. telldir también tiene las mismas advertencias sobre la posible compactación del directorio como la correspondiente rutina del sistema.

tie VARIABLE,NOMBRE_CLASE,LISTA

Esta función une una variable a una clase de paquete que ofrecerá la implementación para esa variable. VARIABLE es el nombre de la variable que será enlazada. CLASE es el nombre de la clase que implementa objetos del tipo correcto. Cualesquiera argumentos adicionales son pasados al método constructor apropiado de la clase (es decir, TIESCALAR, TIEHANDLE, TIEARRAY, o TIEHASH). Por lo general estos son argumentos que se podrían transmitir a la función del C dbm_open(3). El objeto devuelto por el constructor también se devuelve por la función tie, que será útil si desea tener acceso a otros métodos en CLASE.

Note que las funciones como keys y values pueden devolver listas largas cuando se usan con grandes objetos, como los archivos DBM. Puede preferir usar la función each para iterar sobre tales objetos. Ejemplo:

    # imprime los desplazamientos en el archivo histórico
    use NDBM_File;
    tie(my %HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
    while (my ($key,$val) = each %HIST) {
        print $key, ' = ', unpack('L', $val), "\n";
    }

Una clase que implementa un hash debe tener los siguientes métodos:

    TIEHASH clase, LISTA
    FETCH este, clave
    STORE este, clave, valor
    DELETE este, clave
    CLEAR este
    EXISTS este, clave
    FIRSTKEY este
    NEXTKEY este, últimaclave
    SCALAR este
    DESTROY este
    UNTIE este

Una clase implementando un array ordinario común debe tener los siguientes métodos:

    TIEARRAY clase, LISTA
    FETCH este, clave
    STORE este, clave, valor
    FETCHSIZE este
    STORESIZE este, contador
    CLEAR este
    PUSH este, LISTA
    POP este
    SHIFT este
    UNSHIFT este, LISTA
    SPLICE este, desplazamiento, longitud, LISTA
    EXTEND este, contador
    DELETE este, clave
    EXISTS este, clave
    DESTROY este
    UNTIE este

Una clase que implementa un identificador de archivo debe tener los siguientes métodos:

    TIEHANDLE clase, LISTA
    READ este, escalar, longitud, desplazamiento
    READLINE este
    GETC este
    WRITE este, escalar, longitud, desplazamiento
    PRINT este, LISTA
    PRINTF este, formato, LISTA
    BINMODE este
    EOF este
    FILENO este
    SEEK este, posición, desde_donde
    TELL este
    OPEN este, modo, LISTA
    CLOSE este
    DESTROY este
    UNTIE este

Una clase que implementa un escalar debe tener los siguientes métodos:

    TIESCALAR clase, LISTA
    FETCH este,
    STORE este, valor
    DESTROY este
    UNTIE este

No todos los métodos indicados es necesario implementarlos. Ver perltie, Tie::Hash, Tie::Array, Tie::Scalar, y Tie::Handle.

A diferencia de dbmopen, la función tie no usará use o require de un módulo por usted; necesitará hacerlo de forma explícita. Vea DB_File o el módulo Config para implementaciones interesantes de tie.

Para más detalles, vea perltie, tied.

tied VARIABLE

Devuelve una referencia al objeto subyacente en VARIABLE (el mismo valor que fue devuelto originalmente por la llamada tie que enlazaba la variable a un paquete). Devuelve el valor indefinido si la VARIABLE no está atada a un paquete.

time

Devuelve el número de segundos no bisiestos desde el momento en que el sistema considera que es el epoch, apto para alimentar a gmtime y localtime. En la mayoría de los sistemas el epoch son las 00:00:00 UTC, del 1 de enero de 1970; una prominente excepción es el Mac OS Classic que utiliza las 00:00:00 del 1 de enero de 1904, en la zona horaria actual.

Para medir el tiempo con una granularidad mayor de un segundo, use el módulo Time::HiRes de Perl 5.8 (o desde CPAN antes de él), o si tiene gettimeofday(2), puede utilizar el interfaz syscall de Perl. Vea perlfaq8 para más detalles.

Para el procesado de fechas y tiempos mire en los módulos relaccionados en CPAN. Para una completa y actualizada representación del tiempo mire el módulo DateTime.

times

Devuelve una lista de cuatro elementos dando los tiempos de usuario y sistema en segundos, para este proceso y cualquier hijo de este proceso que haya terminado.

    my ($usuario,$sistema,$husuario,$hsistema) = times;

En contexto escalar, times devuelve $usuario.

Los tiempos de los hijos solo se incluyen de los hijos terminados.

Cuestiones de portabilidad: "times" in perlport.

tr///

El operador de transliteración. Lo mismo que y///. Vea "Operadores entrecomillados" in perlop.

truncate IDENTIFICADOR_ARCHIVO,LONGITUD
truncate EXPR,LONGITUD

Trunca el archivo abierto en IDENTIFICADOR_ARCHIVO, o nombrado por EXPR, a la longitud especificada. Lanza una excepción si truncate no está implementada en el sistema. Devuelve verdadero cuando tiene éxito, y undef en cualquier otro caso.

El comportamiento no está definido si LONGITUD es mayor que la longitud del archivo.

La posición en el archivo de IDENTIFICADOR_ARCHIVO no cambia. Puede llamar a seek antes de escribir al archivo.

Cuestiones de portabilidad: "truncate" in perlport.

uc EXPR
uc

Devuelve una versión de EXPR, en mayúsculas. Esta es la función interna del escapado \U en las cadenas doblemente entrecomilladas. No intentará hacer un mapeo de mayúsculas con tilder en las letras iniciales. Vea ucfirst para eso.

Si se omite EXPR, usa $_.

Esta función se comporta de la misma manera bajo varios pragmas, como por ejemplo en una configuración regional, como lo hace lc.

ucfirst EXPR
ucfirst

Devuelve el valor de EXPR con el primer carácter en mayúsculas. Esta es la función interna del escapado \u en las cadenas doblemente entrecomilladas.

Si se omite EXPR, usa $_.

Esta función se comporta de la misma manera bajo varios pragmas, como por ejemplo en una configuración regional, como lo hace lc.

umask EXPR
umask

Establece la umask para el proceso a EXPR y devuelve el valor anterior. Si EXPR se omite, simplemente devuelve la umask actual.

Los permisos Unix rwxr-x--- son representados como tres conjuntos de tres bits, o tres dígitos octales: 0750 (el 0 precedente indica que es octal, y que no es uno de los dígitos). El valor de umask es un número que representa los bits de los permisos que quedan desactivados. El valor de permiso (o "modo") que se pasa a mkdir o sysopen se modifican por su umask, así que incluso si usted le pide a sysopen crear un archivo con permisos 0777, y su umask es 0022, entonces el archivo realmente se crea con permisos 0755. Si su umask fuera 0027 (el grupo no puede escribir; los otros no pueden leer, escribir o ejecutar), entonces pasando a sysopen 0666 creará un archivo con el modo 0640 (porque 0666 &~ 027 es 0640).

Aquí, un consejo: suministre un modo de creación de 0666 para archivos regulares (en sysopen) y uno de 0777 para directorios (en mkdir) y los archivos ejecutables. Esto ofrece a los usuarios la libertad de elección: si quieren archivos protegidos, podrían elegir un umasks para el proceso de 022, 027, o incluso la máscara, particularmente antisocial, de 077. Los programas rara vez o nunca deben tomar decisiones políticas, que es mejor dejar al usuario. La excepción a esto es cuando se escriben archivos que deben mantenerse de forma privada: archivos de correo, las cookies del navegador web, archivos .rhosts, y así sucesivamente.

Si umask(2) no está implementada en su sistema y está tratando de restringir el acceso por sí mismo (es decir, (EXPR & 0700) > 0), se lanza una excepción. Si umask(2) no está implementado y usted no está tratando de restringir el acceso por sí mismo, devuelve undef.

Recuerde que un umask es un número, generalmente indicado en octal; no es una cadena de dígitos octales. Vea también oct si todo lo que tiene es una cadena.

Cuestiones de portabilidad: "umask" in perlport.

undef EXPR
undef

Indefine el valor de EXPR, que debe ser un valor-izquierda. Use solamente sobre un valor escalar, un array (usando @), un hash (con %), una subrutina (con &), o un typeglob (usando *). Decir undef $hash{$key} probablemente no vaya a hacer lo que usted espera en la mayoría de las variables predefinidas o lista de valores DBM, así que no lo haga; vea delete. Siempre devuelve el valor indefinido. Puede omitir la EXPR, en tal caso, nada queda indefinido, pero aún obtiene un valor indefinido que podría, por ejemplo, devolver de una subrutina, asignar a una variable, o pasar como un parámetro. Ejemplos:

    undef $foo;
    undef $bar{'blurfl'};      # Comparar a: delete $bar{'blurfl'};
    undef @ary;
    undef %hash;
    undef &mysub;
    undef *xyz;       # destruye $xyz, @xyz, %xyz, &xyz, etc.
    return (wantarray ? (undef, $errmsg) : undef) if $lo_hizo_estallar;
    select undef, undef, undef, 0.25;
    my ($a, $b, undef, $c) = foo();    # Ignora el tercer valor devuelto

Tenga en cuenta que se trata de un operador unario, no un operador de lista.

Elimina una lista de archivos. En caso de éxito, devuelve el número de archivos que se han eliminado correctamente. En caso de fallo, devuelve falso y establece $! (errno):

    my $unlinked = unlink 'a', 'b', 'c';
    unlink @goners;
    unlink glob "*.bak";

En caso de error, unlink no le dirá qué archivos no se han podido borrar. Si quiere saber qué archivos no pudo eliminar, trátelos de uno en uno:

     foreach my $archivo ( @muertos ) {
         unlink $archivo or warn "No puedo eliminar $archivo: $!";
     }

Nota: unlink no intentará eliminar directorios a menos que usted sea superusuario y se suministre a Perl el indicador -U. Incluso si se cumplen estas condiciones, se advierte que desvincular un directorio puede causar daños a su sistema de archivos. Por último, con unlink en directorios no está soportado en muchos sistemas operativos. Use en su lugar rmdir.

Si LISTA se omite, unlink utiliza $_.

unpack PLANTILLA,EXPR
unpack PLANTILLA

unpack hace lo contrario de pack: toma una cadena y se expande hacia fuera en una lista de valores. (En contexto escalar, devuelve sólo el primer valor producido).

Si se omite EXPR, desempaqueta la cadena $_. Vea perlpacktut para una introducción a esta función.

La cadena se rompe en trozos descritos por la PLANTILLA. Cada fragmento se convierte en un valor por separado. Por lo general, la cadena es un resultado de pack, o los caracteres de la cadena representan una estructura de C de alguna clase.

La PLANTILLA tiene el mismo formato que en la función pack. Aquí hay una subrutina que parte cadenas:

    sub substr {
        my ($que, $donde, $cuanto) = @_;
        unpack("x$donde a$cuanto", $que);
    }

y luego está

    sub ordinal { unpack("W",$_[0]); } # lo mismo que ord()

Además de los campos permitidos en pack, puede prefijar un campo con un %<número> para indicar que desea una suma de control a nivel de bit de los elementos en lugar de los propios elementos. El valor predeterminado es una suma de comprobación de 16-bit. La suma de comprobación se calcula sumando los valores numéricos de los valores expandidos (para los campos de cadena se toma la suma de ord($char); para los campos de bits, la suma de ceros y unos).

Por ejemplo, lo siguiente calcula el mismo número que el programa sum de System V:

    my $checksum = do {
        local $/;  # ¡sorber!
        unpack("%32W*", readline) % 65535;
    };

A continuación, de manera eficiente, cuenta el número de bits establecidos en un vector de bits:

    my $setbits = unpack("%32b*", $selectmask);

Los formatos p y P deben utilizarse con cuidado. Dado que Perl no tiene manera de comprobar si el valor pasado a unpack corresponde a una ubicación de memoria válida, pasando un valor de puntero que no se sabe de su validez, puede tener consecuencias desastrosas.

Si hay más códigos de empaquetado o si el número de repeticiones de un campo o un grupo es más grande que lo que el resto de la cadena de entrada permite, el resultado no está bien definido: el número de repeticiones puede ser reducido, o unpack puede producir cadenas vacías o ceros, o puede provocar una excepción. Si la cadena de entrada es superior a lo descrito por la PLANTILLA, el resto de la cadena de entrada se ignora.

Vea pack para más ejemplos y notas.

unshift ARRAY,LISTA

Hace lo opuesto de un shift. O lo contrario de un push, dependiendo de cómo se mire. Antepone LISTA al principio del array, y devuelve el número de elementos en el array.

    unshift(@ARGV, '-e') unless $ARGV[0] =~ /^-/;

Note que la LISTA se antepone en su conjunto, no un elemento a la vez, por lo que los elementos añadidos se mantienen en el mismo orden. Utilice reverse para hacer lo contrario.

A partir de Perl 5.14, una característica experimental permitía a unshift tomar una expresión escalar. Se ha considerado que este experimento no ha funcionado, y se quitó a partir de Perl 5.24.

untie VARIABLE

Rompe el enlace entre una variable y un paquete. (Vea tie). No tiene efecto si la variable no está atada.

use Módulo VERSIÓN LISTA
use Módulo VERSIÓN
use Módulo LISTA
use Módulo
use VERSIÓN

Importa semántica en el paquete actual desde el módulo que se indica, generalmente por medio de alias de ciertas subrutinas o nombres de variables en su paquete. Es exactamente equivalente a

    BEGIN { require Módulo; Módulo->import( LISTA ); }

excepto que el módulo debe ser una palabra simple. La importación puede estar condicionada por medio del módulo if.

En la forma peculiar use VERSIÓN, VERSIÓN puede ser tanto un número fraccionario decimal positivo, como 5.006, que será comparado con $], o como una v-cadena de la forma v5.6.1, que se comparará con $^V (también conocido como $PERL_VERSION). Se genera una excepción si la VERSIÓN es mayor que la versión del intérprete actual de Perl; Perl no tratará de analizar el resto del archivo. Compare con require, que puede hacer un control similar en tiempo de ejecución. Simétricamente, no VERSIÓN le permite especificar que desea una versión de Perl más vieja que la especificada.

Especificando VERSIÓN como un literal de la forma v5.6.1, debe, generalmente, evitarse, porque lleva a crear mensajes de error equívocos en las versiones anteriores de Perl (esto es, anteriores a 5.6.0) que no admiten esta sintaxis. Se debe usar en su lugar la versión equivalente numérica.

    use v5.6.1;     # comprobación en tiempo de compilación
    use 5.6.1;      # ídem
    use 5.006_001;  # ídem; preferido para mantener la compatibilidad

Suele ser útil si necesita comprobar la versión actual de Perl antes de que use módulos que no funcionarán con versiones anteriores de Perl. (Tratamos de no hacer esto no más de lo necesario).

use VERSIÓN también activa léxicamente todas las características disponibles en la versión solicitada tal como son definidas por el pragma feature, desactivando cualquier característica no incluida en la versión solicitada. Ver feature. Del mismo modo, si la versión especificada de Perl es mayor o igual a 5.12.0, el modo de trabajo estricto quedará activado léxicamente, igual a como lo hace use strict. Cualquier uso explícito de use strict o no strict anula use VERSIÓN, incluso si se coloca antes de él. Uso posterior de use VERSION sobrecargará todos los comportamientos de un anterior use VERSION, posiblemente eliminando el strict y feature añadidos por use VERSION. use VERSION no carga los archivos feature.pm o strict.pm.

El BEGIN fuerza a ejecutar a require e import en tiempo de compilación. El require se asegura que el módulo esté cargado en memoria, si todavía no lo está. El import no es una función predefinida; es sólo una llamada al método estático ordinario en el paquete Módulo para indicar al módulo que importe la lista de características en el paquete actual. El módulo puede implementar su propio método import de la forma que desee, aunque la mayoría de los módulos sólo eligen derivar su método import vía herencia desde la clase Exporter que se define en el módulo Exporter. Ver Exporter. Si no se puede encontrar ningún método import entonces la llamada se pasa por alto, incluso si hay un método AUTOLOAD.

Si no desea llamar al método import del paquete (por ejemplo, para impedir que su espacio de nombres se altere), indique, de manera explícita, una lista vacía:

    use Modulo ();

Eso es exactamente equivalente a

    BEGIN { require Módulo }

Si el argumento VERSIÓN está presente entre el Módulo y la LISTA, entonces use llamará al método VERSIÓN en la clase Módulo con la versión dada como argumento.

    use Módulo 12.34;

es equivalente a:

    BEGIN { require Módulo; Módulo->VERSION(12.34) }

El método default VERSION method por defecto, heredado de la clase UNIVERSAL, croa si la versión dada es mayor que el valor de la variable $Módulo::VERSIÓN.

Una vez más, hay una distinción entre omitir LISTA (import llamado sin argumentos) y una explícita LISTA vacía () (import no se llama). ¡Tenga en cuenta que no hay ninguna coma después de VERSIÓN!

Debido a que esta es una interfaz ampliamente abierta, pragmas (directivas del compilador), también se implementan de esta manera. Las pragmas actualmente implementadas son:

    use constant;
    use diagnostics;
    use integer;
    use sigtrap  qw(SEGV BUS);
    use strict   qw(subs vars refs);
    use subs     qw(afunc blurfl);
    use warnings qw(all);
    use sort     qw(stable _quicksort _mergesort);

Algunos de estos pseudo-módulos importa semántica en el ámbito del bloque actual (como strict o integer, a diferencia de los módulos comunes, que importan los símbolos en el paquete actual (que son efectivos hasta el final del archivo).

Dado que use entra en vigor en tiempo de compilación, no respeta el control de flujo de operaciones del código compilado. En particular, poniendo un use dentro de la rama falsa de un condicional no impide que se procese. Si un módulo o pragma sólo necesita cargarse en forma condicional, se puede hacer uso del pragma if:

    use if $] < 5.008, "utf8";
    use if WANT_WARNINGS, warnings => qw(all);

Existe un correspondiente comando no que des-importa los significados importados por use, es decir, llama a Módulo->unimport(LISTA) en lugar de import. Se comporta igual que import lo hace con VERSIÓN, con una lista vacía o no, o se encuentra ningún método unimport.

    no integer;
    no strict 'refs';
    no warnings;

Se debe tener cuidado cuando se usa la forma no VERSIÓN de no. Sólo es para asegurarse de que el perl que se está ejecutando es de una versión anterior a su argumento y no para deshacer los efectos colaterales activados por use VERSION.

Ver perlmodlib para una lista de módulos y pragmas estándar. Vea perlrun para las opciones en línea de comandos -M y -m para Perl que dan la funcionalidad de use en la línea de comandos.

utime LISTA

Cambia los tiempos de acceso y modificación de cada archivo de una lista de archivos. Los dos primeros elementos de la lista deben ser los tiempos NUMÉRICOS de acceso y de modificación, y en ese orden. Devuelve el número de archivos cambiados 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 comando touch(1) de Unix cuando los archivos realmente existen y pertenecen al usuario que ejecuta el programa:

    #!/usr/bin/perl
    my $atime = my $mtime = time;
    utime $atime, $mtime, @ARGV;

Desde Perl 5.8.0, si los dos primeros elementos de la lista son undef, se llama a la biblioteca del sistema C utime(2) con un segundo argumento nulo. En la mayoría de los sistemas, esto hará que los tiempos de acceso y modificación del archivo se establezcan a la hora actual (es decir, equivalente al ejemplo anterior) y funcionará incluso en archivos de los cuales usted no tenga permisos de escritura:

    for my $archivo (@ARGV) {
        utime(undef, undef, $archivo)
            || warn "No puedo tocar $archivo: $!";
    }

Bajo NFS se utilizará la hora del servidor NFS, no el tiempo de la máquina local. Si hay un problema de sincronización de tiempos, el servidor NFS y el equipo local tendrán tiempos diferentes. El comando de Unix touch(1), de hecho, utilizará esta forma en lugar de la que se muestra en el primer ejemplo.

Pasando solo uno de los dos primeros elementos como undef es equivalente a pasar un 0 y no tendrá el efecto descrito cuando ambos son undef. Esto también desencadena una advertencia de datos no inicializados.

En sistemas que soporten futimes(2), puede pasar identificadores de archivo entre los archivos. En sistemas que no admiten futimes(2), pasar un identificador de archivo lanza una excepción. Identificadores de archivo se deben pasar como comodines o referencias a comodines para que sean reconocidos; las palabras sueltas se consideran como nombres de archivo.

Cuestiones de portabilidad: "utime" in perlport.

values HASH
values ARRAY

En contexto de lista, devuelve una lista que consta de todos los valores del hash indicado. En Perl 5.12 y superiores, también devolverá una lista de los valores de un array; Perl más antiguos considerarán esto como un error de sintaxis. En contexto escalar, devuelve el número de valores.

Las entradas de un hash son devueltas en un aparente orden aleatorio. El orden aleatorio real es específico a un hash dado; las mismas series de operaciones en dos hashes pueden resultar en diferentes órdenes para cada hash. Cualquier inserción en el hash puede cambiar el orden, así como cualquier eliminación, con la excepción de que la clave más reciente devuelta por each o keys se puede borrar sin que cambie el orden. Siempre y cuando no se modifique un determinado hash puede confiar en que keys, values y each devuelvan repetidamente lo mismo en el mismo orden. Vea "Ataques de complejidad algorítmica" in perlsec para los detalles de por qué el orden en un hash se aleatoriza. Aparte de las garantías proporcionadas aquí los detalles exactos de algoritmo que usa Perl para recorrer un hash está sujeto a cambio en cualquier lanzamiento de Perl. Hashes enlazados pueden comportarse diferentemente a los hashes de Perl con respecto a los cambios en el orden, en la inserción y borrado de los elementos.

Como efecto colateral, llamando a values reinicia el iterador interno del HASH o ARRAY (vea each). De forma particular, llamando a values en contexto nulo (void) reinicia el iterador sin otro efecto. Además de restablecer el iterador, values @array en contexto lista es lo mismo que un simple @array. (Le recomendamos que para esto utilice el contexto vacío keys @array, pero razonando que quitar values @array exigirá dar más explicaciones que dejarlo tal cual).

Tenga en cuenta que los valores no son copiados, lo que significa que al modificarles modificará el contenido del hash:

    for (values %hash)      { s/foo/bar/g }  # modifica los valores de %hash
    for (@hash{keys %hash}) { s/foo/bar/g }  # lo mismo

A partir de 5.14, una característica experimental permitía a values tomar una expresión escalar. Se ha considerado que este experimento no ha funcionado, y se quitó a partir de Perl 5.24.

Para no confundir a los posibles usuarios de su código, que ejecuten versiones anteriores de Perl, con errores de sintaxis misteriosos, ponga este tipo de cosas en la parte superior de su archivo para indicar que el código funciona sólo en versiones Perl de cosechas recientes:

    use 5.012;  # así keys/values/each trabajan sobre arrays

Vea también keys, each y sort.

vec EXPR,DESPLAZAMIENTO,BITS

Trata a la cadena en EXPR como un vector de bits compuesta de elementos de tantos BITS de ancho y devuelve el valor del elemento especificado por el DESPLAZAMIENTO como un entero sin signo. BITS, por tanto, especifica el número de bits que son reservados para cada elemento en el vector de bits. Esto debe ser una potencia de dos desde 1 a 32 (o 64, si la plataforma lo admite).

Si BITS es 8, los "elementos" coinciden con bytes de la cadena de entrada.

Si BITS es de 16 o más, los bytes de la cadena de entrada se agrupan en bloques de tamaño BITS/8, y cada grupo se convierte a un número como con pack/unpack con formatos big-endian n/N (Y, análogamente para BITS==64). Vea pack para más detalles.

Si bits son 4 o menos, la cadena se divide en bytes, y a continuación, los bits de cada byte se dividen en grupos de 8/BITS. Los bits de un byte se numeran de la forma little-endian, como en 0x01, 0x02, 0x04, 0x08, ;0x10, 0x20, 0x40; 0x80. Por ejemplo, rompiendo el byte de entrada chr(0x36) en dos grupos da una lista (0x6, 0x3); dividiéndolo en 4 grupos da (0x2, 0x1, 0x3, 0x0).

vec también se puede asignar, en cuyo caso los paréntesis son necesarios para dar a la expresión la correcta precedencia, como en

    vec($imagen, $max_x * $x + $y, 8) = 3;

Si el elemento seleccionado se fuera de la cadena, se devuelve el valor 0. Si se escribe un elemento al final de la cadena, Perl primero extenderá la cadena con una cantidad suficiente de bytes cero. Es un error tratar de cancelar el principio de la cadena (es decir, DESPLAZAMIENTO negativo).

Si la cadena pasa a ser codificada como UTF-8 de forma interna (y por tanto tiene el indicador UTF8 establecido), esto se ignora por vec, y opera en la cadena de bytes interna, no la cadena de caracteres conceptuales, incluso si sólo tiene caracteres con valores inferiores a 256.

Cadenas creadas con vec también se pueden manipular con los operadores lógicos |, &, ^, y ~. Estos operadores asumirán una operación de vector de bits cuando ambos operandos sean cadenas. Ver "Operadores de bit en cadenas" in perlop .

El código siguiente construirá una cadena ASCII diciendo 'PerlPerlPerl'. Los comentarios ponen de manifiesto la cadena después de cada etapa. Tenga en cuenta que este código funciona de la misma manera en máquinas big-endian que little-endian.

    my $foo = '';
    vec($foo,  0, 32) = 0x5065726C; # 'Perl'

    # $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits
    print 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 una lista de 0 y 1, utilice los siguientes:

    my $bits = unpack("b*", $vector);
    my @bits = split(//, unpack("b*", $vector));

Si conoce la longitud exacta en bits, puede utilizarse en lugar de la *.

Este es un ejemplo para ilustrar cómo los bits están realmente amparados en su lugar:

  #!/usr/bin/perl -wl

  print <<'EOT';
                                    0         1         2         3
                     unpack("V",$_) 01234567890123456789012345678901
  ------------------------------------------------------------------
  EOT

  for $w (0..3) {
      $ancho = 2**$w;
      for ($shift=0; $shift < $ancho; ++$shift) {
          for ($off=0; $off < 32/$ancho; ++$off) {
              $str = pack("B*", "0"x32);
              $bits = (1<<$shift);
              vec($str, $off, $ancho) = $bits;
              $res = unpack("b*",$str);
              $val = unpack("V", $str);
              write;
          }
      }
  }

  format STDOUT =
  vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  $despl, $ancho, $bits, $val, $res
  .
  __END__

Independientemente de la arquitectura de la máquina en la que se ejecuta, el ejemplo anterior debe imprimir el cuadro siguiente:

                                    0         1         2         3
                     unpack("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
wait

Se comporta como wait(2) de su sistema: espera a que un proceso hijo termine y devuelve el PID del proceso que ha fallecido, o -1 si no hay procesos hijos. El estado se devuelve en $? y ${^CHILD_ERROR_NATIVE}. Tenga en cuenta que un valor devuelto de -1 podría significar que los procesos hijos se están automáticamente desechando, como se describe en perlipc.

Si utiliza wait en su controlador de $SIG{CHLD}, puede esperar, accidentalmente, por el hijo creado por qx o system. Vea perlipc para más detalles.

Cuestiones de portabilidad: "wait" in perlport.

waitpid PID,INDICADORES

Espera que termine un proceso hijo en particular y devuelve el PID del proceso que ha fallecido, o -1 si no existe tal proceso hijo. Una espera no bloqueante (con WNOHANG en FLAGS) puede devolver 0 si existe algún proceso hijo coincidente con el PID, pero que aún no terminado. El estado se devuelve en $? y ${^CHILD_ERROR_NATIVE}.

Un PID de 0 indica esperar por cualquier proceso hijo cuyo ID de grupo de proceso es igual al del proceso actual. Un PID de menos que -1 indica esperar por cualquier proceso hijo cuyo ID de grupo de proceso es igual a -PID. Un PID de -1 indica esperar por cualquier proceso hijo.

Si dice

    use POSIX ":sys_wait_h";

    my $kid;
    do {
        $hijo = waitpid(-1, WNOHANG);
    } while $hijo > 0;

o bien

    1 while waitpid(-1, WNOHANG) > 0;

entonces puede hacer una espera no bloqueante para todos los procesos zombie pendientes (vea "WAIT" in POSIX). Espera no bloqueante está disponible en máquinas que soporten las llamadas del sistema, tanto waitpid(2) como wait4(2). Sin embargo, esperar por un particular pid con INDICADORES a 0 está implementado en todas partes. (Perl emula la llamada al sistema, recordando los valores de estado de los procesos que han salido, pero que todavía no se han recolectado por el script Perl).

Tenga en cuenta que en algunos sistemas, un valor devuelto de -1 podría significar que los procesos hijos se están automáticamente desechando. Ver perlipc para más detalles, y para otros ejemplos.

Cuestiones de portabilidad: "waitpid" in perlport.

wantarray

Devuelve verdadero si el contexto de ejecución de la subrutina actual o eval está buscando por una lista de valores. Devuelve falso si el contexto está buscando por un escalar. Devuelve el valor indefinido si el contexto está buscando por ningún valor (contexto void).

    return unless defined wantarray; # no nos molestamos más
    my @a = calculo_complejo();
    return wantarray ? @a : "@a";

El resultado de wantarray no está especificado en el nivel superior de un archivo, en un BEGIN, UNITCHECK, CHECK, INIT o bloque END, o en un método DESTROY.

Esta función debería haber sido nombrada wantlist().

warn LISTA

Imprime el valor de LISTA a STDERR. Si el último elemento de LISTA no termina en un salto de línea, se añade el archivo/número de línea de texto igual como lo hace die.

Si la salida está vacía y $@ ya contiene un valor (típicamente de un eval anterior) este valor se utiliza después de añadirle "\t...caught" a $@. Esto es útil para mantenerse casi, pero no del todo, similar a die.

Si $@ está vacía entonces se usa la cadena "Warning: Something's wrong".

Ningún mensaje se imprime si hay instalado un controlador $SIG{__WARN__}. Es responsabilidad del controlador tratar el mensaje como lo considere oportuno (como, por ejemplo, convertirlo en un die). La mayoría de los controladores, por lo tanto, deben hacer los arreglos necesarios para realmente mostrar las advertencias de las que no están preparados para hacer frente, llamando a warn de nuevo en el controlador. Tenga en cuenta que esto es bastante seguro y no producirá un bucle sin fin, puesto que los enganches __WARN__ no son llamados desde el interior de uno mismo.

Encontrará que este comportamiento es ligeramente diferente a la de los controladores $SIG{__DIE__} (que no suprimen el texto de error, pero puede llamar, en su lugar, a die de nuevo para cambiarlo).

El uso de un controlador __WARN__ proporciona una poderosa manera de silenciar a todas las advertencias (incluso las no menos llamadas obligatorias). Un ejemplo:

    # limpiar *todas* las advertencias en tiempo de compilación
    BEGIN { $SIG{'__WARN__'} = sub { warn $_[0] if $DOWARN } }
    my $foo = 10;
    my $foo = 20;          # no avisa de un my $foo duplicado,
                           # pero bueno, ¡tú lo has querido así!
    # no advertencias en compilación o ejecución antes de aquí
    $DOWARN = 1;

    # advertencias en ejecución activas desde aquí
    warn "\$foo está vivo y $foo!";     # lo muestra

Vea perlvar para más detalles sobre la configuración de las entradas %SIG y para ver más ejemplos. Vea el módulo Carp para otros tipos de avisos mediante sus funciones carp y cluck.

write IDENTIFICADOR_ARCHIVO
write EXPR
write

Escribe un registro formateado (posiblemente de varias líneas) al IDENTIFICADOR_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 (vea la función select) se puede establecer de forma explícita mediante la asignación del nombre del formato a la variable $~.

El procesado del comienzo del formulario se gestiona de forma automática: si no hay suficiente espacio en la página actual para el registro formateado, la página se desplaza escribiendo un avance de página y se utiliza un formato especial de principio de página para dar formato al encabezado de la nueva página antes de que el registro sea escrito. De manera predeterminada, el formato de la parte superior de la página es el nombre del identificador de archivo con el sufijo _TOP añadido, o top en el paquete actual si lo primero no existe. Esto podría ser un problema con identificadores de archivo autovivificados, pero puede ser configurada de forma dinámica con el formato de su elección mediante la asignación del nombre a la variable $^ mientras esté seleccionado el identificador de archivo. El número de líneas restantes de la página actual está en la variable $-, que se puede fijar a 0 para forzar una nueva página.

Si no se especifica IDENTIFICADOR_ARCHIVO, la salida va al canal predeterminado de salida actual, que suele ser STDOUT, pero puede se modificar por el operador select. Si el IDENTIFICADOR_ARCHIVO es una EXPR, entonces la expresión se evalúa y la cadena resultante se utiliza para buscar el nombre del IDENTIFICADOR_ARCHIVO en tiempo de ejecución. Para más información sobre formatos, vea perlform.

Tenga en cuenta que write no es lo contrario de read. Por desgracia.

y///

El operador de transliteración. Lo mismo que tr///. Vea "Operadores entrecomillados" in perlop.

Referencias externas a identificadores que no son funciones

perldata

__DATA__
__END__

Estas palabras clave están documentadas en "Literales especiales" in perldata.

perlmod

BEGIN
CHECK
END
INIT
UNITCHECK

Estas palabras clave de la fase de compilación están documentadas en "BEGIN, UNITCHECK, CHECK, INIT y END" in perlmod.

perlobj

DESTROY

Esta palabra clave de método está documentada en "Destructores" in perlobj.

perlop

and
cmp
eq
ge
gt
le
lt
ne
not
or
x
xor

Estos operadores están documentados en perlop.

perlsub

AUTOLOAD

Esta palabra clave está documentada en "Autocarga" in perlsub.

perlsyn

else
elsif
for
foreach
if
unless
until
while

Estas palabras clave de control de flujo están documentadas en "Instrucciones complejas" in perlsyn.

elseif

La palabra "else if" se escribe como elsif en Perl. No existe ni elif ni else if. Interpreta elseif, pero solo para avisarle de que no debe usarlo.

Vea la documentación sobre las palabras clave de control de flujo en "Instrucciones complejas" in perlsyn.

default
given
when

Estas palabras clave de control de flujo relacionadas con la función experimental switch están documentadas en "Instrucciones switch" in perlsyn.

TRADUCTORES

  • Joaquín Ferrero (Tech Lead)

  • Enrique Nell (Language Lead)