=encoding utf8

=head1 NAME
X<function>

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

=head1 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 L<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,
L<C<splice>|/splice ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA> tiene tres argumentos
escalares seguidos por una lista, mientras que
L<C<gethostbyname>|/gethostbyname NOMBRE> 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 I<se parece> a una función, I<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 L<C<use warnings>|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 L<C<time>|/time> y L<C<endpwent>|/endpwent>. Por ejemplo,
C<time+86_400> siempre significa C<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: B<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. X<contexto>

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 C<(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 L<chown(2)>, L<fork(2)>,
L<closedir(2)>, etc.) devuelven verdadero cuando tienen éxito, y
L<C<undef>|/undef EXPR> en otro caso, como se menciona en las siguientes
descripciones. Esto es diferente de las interfaces en C, que devuelven C<-1> en
caso de error. Excepciones a esta regla incluyen a L<C<wait>|/wait>,
L<C<waitpid>|/waitpid PID,INDICADORES> y L<C<syscall>|/syscall NÚMERO, LISTA>.
Llamadas al sistema también actualizan la variable especial
L<C<$!>|perlvar/$!> 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 L<perlapi/PL_keyword_plugin> 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.

=head2 Funciones Perl por categoría
X<function> X<función>

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.

=over 4

=item Functiones para ESCALARES o cadenas
X<scalar> X<string> X<character> X<escalar> X<cadena> X<carácter>

=for Pod::Functions =String

L<C<chomp>|/chomp VARIABLE>, L<C<chop>|/chop VARIABLE>, L<C<chr>|/chr NÚMERO>,
L<C<crypt>|/crypt TEXTOPLANO,SALTO>, L<C<fc>|/fc EXPR>, L<C<hex>|/hex EXPR>,
L<C<index>|/index CADENA,SUBCADENA,POSICIÓN>, L<C<lc>|/lc EXPR>,
L<C<lcfirst>|/lcfirst EXPR>, L<C<length>|/length EXPR>, L<C<oct>|/oct EXPR>,
L<C<ord>|/ord EXPR>, L<C<pack>|/pack PLANTILLA,LISTA>,
L<C<qE<sol>E<sol>>|/qE<sol>CADENAE<sol>>,
L<C<qqE<sol>E<sol>>|/qqE<sol>CADENAE<sol>>, L<C<reverse>|/reverse LISTA>,
L<C<rindex>|/rindex CADENA,SUBCADENA,POSICIÓN>, L<C<sprintf>|/sprintf FORMATO,
LISTA>, L<C<substr>|/substr EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO>,
L<C<trE<sol>E<sol>E<sol>>|/trE<sol>E<sol>E<sol>>, L<C<uc>|/uc EXPR>,
L<C<ucfirst>|/ucfirst EXPR>, L<C<yE<sol>E<sol>E<sol>>|/yE<sol>E<sol>E<sol>>

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

=item Expresiones regulares y coincidencia de patrones
X<regular expression> X<regex> X<regexp> X<expresión regular>

=for Pod::Functions =Regexp

L<C<mE<sol>E<sol>>|/mE<sol>E<sol>>, L<C<pos>|/pos ESCALAR>,
L<C<qrE<sol>E<sol>>|/qrE<sol>CADENAE<sol>>, L<C<quotemeta>|/quotemeta EXPR>,
L<C<sE<sol>E<sol>E<sol>>|/sE<sol>E<sol>E<sol>>, L<C<split>|/split
E<sol>PATRÓNE<sol>,EXPR,LÍMITE>, L<C<study>|/study ESCALAR>

=item Funciones numéricas
X<numeric> X<number> X<trigonometric> X<trigonometry> X<numérico> X<número> X<trigonométrica> X<trigonomía>

=for Pod::Functions =Math

L<C<abs>|/abs VALOR>, L<C<atan2>|/atan2 Y,X>, L<C<cos>|/cos EXPR>,
L<C<exp>|/exp EXPR>, L<C<hex>|/hex EXPR>, L<C<int>|/int EXPR>, L<C<log>|/log
EXPR>, L<C<oct>|/oct EXPR>, L<C<rand>|/rand EXPR>, L<C<sin>|/sin EXPR>,
L<C<sqrt>|/sqrt EXPR>, L<C<srand>|/srand EXPR>

=item Funciones para @ARRAY reales
X<array>

=for Pod::Functions =ARRAY

L<C<each>|/each HASH>, L<C<keys>|/keys HASH>, L<C<pop>|/pop ARRAY>,
L<C<push>|/push ARRAY,LISTA>, L<C<shift>|/shift ARRAY>, L<C<splice>|/splice
ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA>, L<C<unshift>|/unshift ARRAY,LISTA>,
L<C<values>|/values HASH>

=item Funciones para lista de datos
X<list> X<lista>

=for Pod::Functions =LIST

L<C<grep>|/grep BLOQUE LISTA>, L<C<join>|/join EXPR,LISTA>, L<C<map>|/map
BLOQUE LISTA>, L<C<qwE<sol>E<sol>>|/qwE<sol>CADENAE<sol>>,
L<C<reverse>|/reverse LISTA>, L<C<sort>|/sort NOMBRE_SUB LISTA>,
L<C<unpack>|/unpack PLANTILLA,EXPR>

=item Funciones %HASH reales
X<hash>

=for Pod::Functions =HASH

L<C<delete>|/delete EXPR>, L<C<each>|/each HASH>, L<C<exists>|/exists EXPR>,
L<C<keys>|/keys HASH>, L<C<values>|/values HASH>

=item Funciones de Entrada y Salida
X<I/O> X<input> X<output> X<dbm> X<entrada> X<salida>

=for Pod::Functions =I/O

L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA>, L<C<close>|/close
IDENTIFICADOR_ARCHIVO>, L<C<closedir>|/closedir IDENTIFICADOR_DIR>,
L<C<dbmclose>|/dbmclose HASH>, L<C<dbmopen>|/dbmopen
HASH,NOMBRE_BASE_DATOS,MÁSCARA>, L<C<die>|/die LISTA>, L<C<eof>|/eof
IDENTIFICADOR_ARCHIVO>, L<C<fileno>|/fileno IDENTIFICADOR_ARCHIVO>,
L<C<flock>|/flock IDENTIFICADOR_ARCHIVO,OPERACIÓN>, L<C<format>|/format>,
L<C<getc>|/getc IDENTIFICADOR_ARCHIVO>, L<C<print>|/print IDENTIFICADOR_ARCHIVO
LISTA>, L<C<printf>|/printf IDENTIFICADOR_ARCHIVO FORMATO, LISTA>,
L<C<read>|/read IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>,
L<C<readdir>|/readdir IDENTIFICADOR_DIR>, L<C<readline>|/readline EXPR>,
L<C<rewinddir>|/rewinddir IDENTIFICADOR_DIR>, L<C<say>|/say
IDENTIFICADOR_ARCHIVO LISTA>, L<C<seek>|/seek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>, L<C<seekdir>|/seekdir
IDENTIFICADOR_DIR,POSICIÓN>, L<C<select>|/select
RBITS,WBITS,EBITS,TIEMPO_ESPERA>, L<C<syscall>|/syscall NÚMERO, LISTA>,
L<C<sysread>|/sysread IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>,
L<C<sysseek>|/sysseek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>,
L<C<syswrite>|/syswrite IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>,
L<C<tell>|/tell IDENTIFICADOR_ARCHIVO>, L<C<telldir>|/telldir
IDENTIFICADOR_DIR>, L<C<truncate>|/truncate IDENTIFICADOR_ARCHIVO,LONGITUD>,
L<C<warn>|/warn LISTA>, L<C<write>|/write IDENTIFICADOR_ARCHIVO>

L<C<say>|/say IDENTIFICADOR_ARCHIVO LISTA> sólo está disponible si la
característica L<C<"say">|feature/La característica 'say'> está habilitada o
si está prefijada con C<CORE::>. La característica L<C<"say">|feature/La
característica 'say'> se activa automáticamente con una declaración C<use
v5.10> (o superior) en el ámbito actual.

=item Funciones para registros o datos de longitud fija

=for Pod::Functions =Binary

L<C<pack>|/pack PLANTILLA,LISTA>, L<C<read>|/read
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>, L<C<syscall>|/syscall
NÚMERO, LISTA>, L<C<sysread>|/sysread
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>, L<C<sysseek>|/sysseek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>, L<C<syswrite>|/syswrite
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>, L<C<unpack>|/unpack
PLANTILLA,EXPR>, L<C<vec>|/vec EXPR,DESPLAZAMIENTO,BITS>

=item Funciones para identificadores de archivo, archivos y directorios
X<file> X<filehandle> X<directory> X<pipe> X<link> X<symlink> X<archivo> X<identificador de archivo> X<enlace>

=for Pod::Functions =File

L<C<-I<X>>|/-X IDENTIFICADOR_ARCHIVO>, L<C<chdir>|/chdir EXPR>,
L<C<chmod>|/chmod LISTA>, L<C<chown>|/chown LISTA>, L<C<chroot>|/chroot
NOMBRE_ARCHIVO>, L<C<fcntl>|/fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>,
L<C<glob>|/glob EXPR>, L<C<ioctl>|/ioctl
IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>, L<C<link>|/link
ARCHIVO_VIEJO,ARCHIVO_NUEVO>, L<C<lstat>|/lstat IDENTIFICADOR_ARCHIVO>,
L<C<mkdir>|/mkdir NOMBRE_ARCHIVO,MÁSCARA>, L<C<open>|/open
IDENTIFICADOR_ARCHIVO,EXPR>, L<C<opendir>|/opendir IDENTIFICADOR_DIR,EXPR>,
L<C<readlink>|/readlink EXPR>, L<C<rename>|/rename NOMBRE_VIEJO,NOMBRE_NUEVO>,
L<C<rmdir>|/rmdir NOMBRE_DIRECTORIO>, L<C<select>|/select
IDENTIFICADOR_ARCHIVO>, L<C<stat>|/stat IDENTIFICADOR_ARCHIVO>,
L<C<symlink>|/symlink ARCHIVO_VIEJO,ARCHIVO_NUEVO>, L<C<sysopen>|/sysopen
IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO>, L<C<umask>|/umask EXPR>,
L<C<unlink>|/unlink LISTA>, L<C<utime>|/utime LISTA>

=item Palabras clave relativas al control de flujo de su programa Perl
X<control flow> X<control de flujo>

=for Pod::Functions =Flow

L<C<break>|/break>, L<C<caller>|/caller EXPR>, L<C<continue>|/continue BLOQUE>,
L<C<die>|/die LISTA>, L<C<do>|/do BLOQUE>, L<C<dump>|/dump ETIQUETA>,
L<C<eval>|/eval EXPR>, L<C<evalbytes>|/evalbytes EXPR> L<C<exit>|/exit EXPR>,
L<C<__FILE__>|/__FILE__>, L<C<goto>|/goto ETIQUETA>, L<C<last>|/last ETIQUETA>,
L<C<__LINE__>|/__LINE__>, L<C<next>|/next ETIQUETA>,
L<C<__PACKAGE__>|/__PACKAGE__>, L<C<redo>|/redo ETIQUETA>, L<C<return>|/return
EXPR>, L<C<sub>|/sub NOMBRE BLOQUE>, L<C<__SUB__>|/__SUB__>,
L<C<wantarray>|/wantarray>

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

L<C<evalbytes>|/evalbytes EXPR> sólo está disponible con la característica
L<C<"evalbytes"> feature|feature/Las características 'unicode_eval' y
'evalbytes'> (vea L<feature>) o si está prefijada con C<CORE::>.
L<C<__SUB__>|/__SUB__> sólo está disponible con la característica
L<C<"current_sub">|feature/La característica 'current_sub'> o si está
prefijada con C<CORE::>. Tanto la característica L<C<"evalbytes">|feature/Las
características 'unicode_eval' y 'evalbytes'> como la
L<C<"current_sub">|feature/La característica 'current_sub'> se activan de
forma automática con una declaración C<use v5.16> (o superior) en el ámbito
actual.

=item Palabras clave relacionadas con el ámbito

=for Pod::Functions =Namespace

L<C<caller>|/caller EXPR>, L<C<import>|/import LISTA>, L<C<local>|/local EXPR>,
L<C<my>|/my LISTAVAR>, L<C<our>|/our LISTAVAR>, L<C<package>|/package
ESPACIO_NOMBRES>, L<C<state>|/state LISTAVAR>, L<C<use>|/use Módulo VERSIÓN
LISTA>

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

=item Funciones varias

=for Pod::Functions =Misc

L<C<defined>|/defined EXPR>, L<C<formline>|/formline DIBUJO,LISTA>,
L<C<lock>|/lock COSA>, L<C<prototype>|/prototype FUNCIÓN>, L<C<reset>|/reset
EXPR>, L<C<scalar>|/scalar EXPR>, L<C<undef>|/undef EXPR>

=item Funciones para procesos y grupos de procesos
X<process> X<pid> X<process id> X<proceso> X<id proceso>

=for Pod::Functions =Process

L<C<alarm>|/alarm SEGUNDOS>, L<C<exec>|/exec LISTA>, L<C<fork>|/fork>,
L<C<getpgrp>|/getpgrp PID>, L<C<getppid>|/getppid>,
L<C<getpriority>|/getpriority CUÁL,QUIÉN>, L<C<kill>|/kill SEÑAL, LISTA>,
L<C<pipe>|/pipe IDENTIFICADOR_LECTURA,IDENTIFICADOR_ESCRITURA>,
L<C<qxE<sol>E<sol>>|/qxE<sol>CADENAE<sol>>, L<C<readpipe>|/readpipe EXPR>,
L<C<setpgrp>|/setpgrp PID,PGRP>, L<C<setpriority>|/setpriority
CUÁL,QUIÉN,PRIORIDAD>, L<C<sleep>|/sleep EXPR>, L<C<system>|/system LISTA>,
L<C<times>|/times>, L<C<wait>|/wait>, L<C<waitpid>|/waitpid PID,INDICADORES>

=item Palabras clave relativas a los módulos Perl
X<module> X<módulo>

=for Pod::Functions =Modules

L<C<do>|/do EXPR>, L<C<import>|/import LISTA>, L<C<no>|/no Módulo VERSIÓN
LISTA>, L<C<package>|/package ESPACIO_NOMBRES>, L<C<require>|/require
VERSIÓN>, L<C<use>|/use Módulo VERSIÓN LISTA>

=item Palabras clave relativas a las clases y orientación a objetos
X<object> X<class> X<package> X<objeto> X<clase> X<paquete>

=for Pod::Functions =Objects

L<C<bless>|/bless REF,NOMBRE_CLASE>, L<C<dbmclose>|/dbmclose HASH>,
L<C<dbmopen>|/dbmopen HASH,NOMBRE_BASE_DATOS,MÁSCARA>, L<C<package>|/package
ESPACIO_NOMBRES>, L<C<ref>|/ref EXPR>, L<C<tie>|/tie
VARIABLE,NOMBRE_CLASE,LISTA>, L<C<tied>|/tied VARIABLE>, L<C<untie>|/untie
VARIABLE>, L<C<use>|/use Módulo VERSIÓN LISTA>

=item Funciones de bajo nivel de sockets
X<socket> X<sock>

=for Pod::Functions =Socket

L<C<accept>|/accept NUEVOSOCKET,SOCKETGENÉRICO>, L<C<bind>|/bind
SOCKET,NOMBRE>, L<C<connect>|/connect SOCKET,NOMBRE>,
L<C<getpeername>|/getpeername SOCKET>, L<C<getsockname>|/getsockname SOCKET>,
L<C<getsockopt>|/getsockopt SOCKET,NIVEL,OPCIÓN>, L<C<listen>|/listen
SOCKET,TAMAÑO_COLA>, L<C<recv>|/recv SOCKET,ESCALAR,LONGITUD,INDICADORES>,
L<C<send>|/send SOCKET,MSG,INDICADORES,DESTINO>, L<C<setsockopt>|/setsockopt
SOCKET,NIVEL,OPCIÓN_NOMBRE,OPCIÓN_VALOR>, L<C<shutdown>|/shutdown
SOCKET,CÓMO>, L<C<socket>|/socket SOCKET,DOMINIO,TIPO,PROTOCOLO>,
L<C<socketpair>|/socketpair SOCKET1,SOCKET2,DOMINIO,TIPO,PROTOCOLO>

=item Funciones de comunicación interprocesos System V
X<IPC> X<System V> X<semaphore> X<shared memory> X<memory> X<message> X<semáforo> X<memoria compartida> X<memoria> X<mensaje>

=for Pod::Functions =SysV

L<C<msgctl>|/msgctl ID,CMD,ARG>, L<C<msgget>|/msgget CLAVE,INDICADORES>,
L<C<msgrcv>|/msgrcv ID,VAR,TAMAÑO,TIPO,INDICADORES>, L<C<msgsnd>|/msgsnd
ID,MSG,INDICADORES>, L<C<semctl>|/semctl ID,SEMNUM,CMD,ARG>,
L<C<semget>|/semget CLAVE,NSEMS,INDICADORES>, L<C<semop>|/semop
CLAVE,OPSTRING>, L<C<shmctl>|/shmctl ID,CMD,ARG>, L<C<shmget>|/shmget
CLAVE,TAMAÑO,INDICADORES>, L<C<shmread>|/shmread ID,VAR,POSICIÓN,TAMAÑO>,
L<C<shmwrite>|/shmwrite ID,CADENA,POSICIÓN,TAMAÑO>

=item Obtener información de usuarios y grupos
X<user> X<group> X<password> X<uid> X<gid> X<passwd> X</etc/passwd> X<usuario> X<grupo> X<contraseña>

=for Pod::Functions =User

L<C<endgrent>|/endgrent>, L<C<endhostent>|/endhostent>,
L<C<endnetent>|/endnetent>, L<C<endpwent>|/endpwent>, L<C<getgrent>|/getgrent>,
L<C<getgrgid>|/getgrgid GID>, L<C<getgrnam>|/getgrnam NOMBRE>,
L<C<getlogin>|/getlogin>, L<C<getpwent>|/getpwent>, L<C<getpwnam>|/getpwnam
NOMBRE>, L<C<getpwuid>|/getpwuid UID>, L<C<setgrent>|/setgrent>,
L<C<setpwent>|/setpwent>

=item Obtener información de la red
X<network> X<protocol> X<host> X<hostname> X<IP> X<address> X<service> X<red> X<protocolo> X<servidor> X<dirección> X<servicio>

=for Pod::Functions =Network

L<C<endprotoent>|/endprotoent>, L<C<endservent>|/endservent>,
L<C<gethostbyaddr>|/gethostbyaddr DIRECCIÓN,TIPODIR>,
L<C<gethostbyname>|/gethostbyname NOMBRE>, L<C<gethostent>|/gethostent>,
L<C<getnetbyaddr>|/getnetbyaddr DIRECCIÓN,TIPODIR>,
L<C<getnetbyname>|/getnetbyname NOMBRE>, L<C<getnetent>|/getnetent>,
L<C<getprotobyname>|/getprotobyname NOMBRE>,
L<C<getprotobynumber>|/getprotobynumber NÚMERO>,
L<C<getprotoent>|/getprotoent>, L<C<getservbyname>|/getservbyname
NOMBRE,PROTOCOLO>, L<C<getservbyport>|/getservbyport PUERTO,PROTOCOLO>,
L<C<getservent>|/getservent>, L<C<sethostent>|/sethostent SIGUEABIERTO>,
L<C<setnetent>|/setnetent SIGUEABIERTO>, L<C<setprotoent>|/setprotoent
SIGUEABIERTO>, L<C<setservent>|/setservent SIGUEABIERTO>

=item Funciones relacionadas con el tiempo
X<time> X<date>

=for Pod::Functions =Time

L<C<gmtime>|/gmtime EXPR>, L<C<localtime>|/localtime EXPR>, L<C<time>|/time>,
L<C<times>|/times>

=item Palabras clave que no son funciones

=for Pod::Functions =!Non-functions

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

=back

=head2 Portabilidad
X<portability> X<Unix> X<portable> X<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:

L<C<-I<X>>|/-X IDENTIFICADOR_ARCHIVO>, L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA>, L<C<chmod>|/chmod LISTA>, L<C<chown>|/chown
LISTA>, L<C<chroot>|/chroot NOMBRE_ARCHIVO>, L<C<crypt>|/crypt
TEXTOPLANO,SALTO>, L<C<dbmclose>|/dbmclose HASH>, L<C<dbmopen>|/dbmopen
HASH,NOMBRE_BASE_DATOS,MÁSCARA>, L<C<dump>|/dump ETIQUETA>,
L<C<endgrent>|/endgrent>, L<C<endhostent>|/endhostent>,
L<C<endnetent>|/endnetent>, L<C<endprotoent>|/endprotoent>,
L<C<endpwent>|/endpwent>, L<C<endservent>|/endservent>, L<C<exec>|/exec LISTA>,
L<C<fcntl>|/fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>, L<C<flock>|/flock
IDENTIFICADOR_ARCHIVO,OPERACIÓN>, L<C<fork>|/fork>, L<C<getgrent>|/getgrent>,
L<C<getgrgid>|/getgrgid GID>, L<C<gethostbyname>|/gethostbyname NOMBRE>,
L<C<gethostent>|/gethostent>, L<C<getlogin>|/getlogin>,
L<C<getnetbyaddr>|/getnetbyaddr DIRECCIÓN,TIPODIR>,
L<C<getnetbyname>|/getnetbyname NOMBRE>, L<C<getnetent>|/getnetent>,
L<C<getppid>|/getppid>, L<C<getpgrp>|/getpgrp PID>,
L<C<getpriority>|/getpriority CUÁL,QUIÉN>,
L<C<getprotobynumber>|/getprotobynumber NÚMERO>,
L<C<getprotoent>|/getprotoent>, L<C<getpwent>|/getpwent>,
L<C<getpwnam>|/getpwnam NOMBRE>, L<C<getpwuid>|/getpwuid UID>,
L<C<getservbyport>|/getservbyport PUERTO,PROTOCOLO>,
L<C<getservent>|/getservent>, L<C<getsockopt>|/getsockopt
SOCKET,NIVEL,OPCIÓN>, L<C<glob>|/glob EXPR>, L<C<ioctl>|/ioctl
IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>, L<C<kill>|/kill SEÑAL, LISTA>,
L<C<link>|/link ARCHIVO_VIEJO,ARCHIVO_NUEVO>, L<C<lstat>|/lstat
IDENTIFICADOR_ARCHIVO>, L<C<msgctl>|/msgctl ID,CMD,ARG>, L<C<msgget>|/msgget
CLAVE,INDICADORES>, L<C<msgrcv>|/msgrcv ID,VAR,TAMAÑO,TIPO,INDICADORES>,
L<C<msgsnd>|/msgsnd ID,MSG,INDICADORES>, L<C<open>|/open
IDENTIFICADOR_ARCHIVO,EXPR>, L<C<pipe>|/pipe
IDENTIFICADOR_LECTURA,IDENTIFICADOR_ESCRITURA>, L<C<readlink>|/readlink EXPR>,
L<C<rename>|/rename NOMBRE_VIEJO,NOMBRE_NUEVO>, L<C<select>|/select
RBITS,WBITS,EBITS,TIEMPO_ESPERA>, L<C<semctl>|/semctl ID,SEMNUM,CMD,ARG>,
L<C<semget>|/semget CLAVE,NSEMS,INDICADORES>, L<C<semop>|/semop
CLAVE,OPSTRING>, L<C<setgrent>|/setgrent>, L<C<sethostent>|/sethostent
SIGUEABIERTO>, L<C<setnetent>|/setnetent SIGUEABIERTO>, L<C<setpgrp>|/setpgrp
PID,PGRP>, L<C<setpriority>|/setpriority CUÁL,QUIÉN,PRIORIDAD>,
L<C<setprotoent>|/setprotoent SIGUEABIERTO>, L<C<setpwent>|/setpwent>,
L<C<setservent>|/setservent SIGUEABIERTO>, L<C<setsockopt>|/setsockopt
SOCKET,NIVEL,OPCIÓN_NOMBRE,OPCIÓN_VALOR>, L<C<shmctl>|/shmctl ID,CMD,ARG>,
L<C<shmget>|/shmget CLAVE,TAMAÑO,INDICADORES>, L<C<shmread>|/shmread
ID,VAR,POSICIÓN,TAMAÑO>, L<C<shmwrite>|/shmwrite
ID,CADENA,POSICIÓN,TAMAÑO>, L<C<socket>|/socket
SOCKET,DOMINIO,TIPO,PROTOCOLO>, L<C<socketpair>|/socketpair
SOCKET1,SOCKET2,DOMINIO,TIPO,PROTOCOLO>, L<C<stat>|/stat
IDENTIFICADOR_ARCHIVO>, L<C<symlink>|/symlink ARCHIVO_VIEJO,ARCHIVO_NUEVO>,
L<C<syscall>|/syscall NÚMERO, LISTA>, L<C<sysopen>|/sysopen
IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO>, L<C<system>|/system LISTA>,
L<C<times>|/times>, L<C<truncate>|/truncate IDENTIFICADOR_ARCHIVO,LONGITUD>,
L<C<umask>|/umask EXPR>, L<C<unlink>|/unlink LISTA>, L<C<utime>|/utime LISTA>,
L<C<wait>|/wait>, L<C<waitpid>|/waitpid PID,INDICADORES>

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

=head2 Lista de funciones de Perl en orden alfabético

=over

=item -X IDENTIFICADOR_ARCHIVO
X<-r>X<-w>X<-x>X<-o>X<-R>X<-W>X<-X>X<-O>X<-e>X<-z>X<-s>X<-f>X<-d>X<-l>X<-p>
X<-S>X<-b>X<-c>X<-t>X<-u>X<-g>X<-k>X<-T>X<-B>X<-M>X<-A>X<-C>

=item -X EXPR

=item -X IDENTIFICADOR_DIR

=item -X

=for Pod::Functions a file test (-r, -x, etc)

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 L<C<$_>|perlvar/$_>, excepto para
C<-t>, que prueba STDIN. Mientras no se diga lo contrario, se devuelve C<1>
para verdadero y C<''> para falso. Si el archivo no existe o no se puede
examinar, devuelve C<undef> y actualiza L<C<undef>|/undef EXPR> and sets
L<C<$!>|perlvar/$!> (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 C<-s/a/b/> no realiza una substitución negada. Al decir
C<-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 C<-r>, C<-R>,
C<-w>, C<-W>, C<-x> y C<-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 C<-r>, C<-R>, C<-w> y C<-W> siempre devuelven 1, y C<-x> y C<-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 L<C<stat>|/stat
IDENTIFICADOR_ARCHIVO> 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 L<C<filetest>|filetest> que
puede producir resultados más precisos que los simples bits de modo de
L<C<stat>|/stat IDENTIFICADOR_ARCHIVO>. Cuando esté bajo C<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 L<access(2)>. Note también que las pruebas C<-x> y C<-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
C<use filetest 'access'>, el identificador de archivo especial C<_> 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
L<C<filetest>|filetest>.

Las pruebas C<-T> y C<-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 C<-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 C<-B>; de lo contrario es un
archivo C<-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 L<S<use locale>|perllocale>, que incluye C<LC_CTYPE>,
caracteres extraños son cualquiera que no sean imprimibles ni espacios en la
configuración regional actual). Si C<-T> o C<-B> se usan con un identificador
de archivo, la memoria intermedia actual de IO es examinada en vez del primer
bloque. Ambos, C<-T> y C<-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 C<-T>, en
la mayoría de las ocasiones querrá usar primero C<-f>, como en C<next unless
-f $archivo && -T $archivo>.

Si a cualquiera de los test de archivo (o cualquiera de los operadores
L<C<stat>|/stat IDENTIFICADOR_ARCHIVO> o L<C<lstat>|/lstat
IDENTIFICADOR_ARCHIVO>) 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 L<C<stat>|/stat
IDENTIFICADOR_ARCHIVO>), ahorrando una llamada del sistema.  (Esto no funciona
con C<-t>, y necesita recordar que L<C<lstat()>|/lstat IDENTIFICADOR_ARCHIVO> y
C<-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 L<C<lstat>|/lstat IDENTIFICADOR_ARCHIVO>, C<-T> y C<-B> se
reinicializarán con los resultados de C<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 C<-f -w -x $archivo> es equivalente
a C<-x $archivo && -w _ && -f _>.  (Esto solo es fascinantemente elegante: si
usa el valor devuelto de C<-f $archivo> como un argumento para otro operador de
test de archivo, no ocurrirá ninguna magia especial)

Cuestiones de portabilidad: L<perlport/-X>.

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

=item abs VALOR
X<abs> X<absolute> X<absoluto>

=item abs

=for Pod::Functions absolute value function

Devuelve el valor absoluto del argumento. Si se omite VALOR, se usa
L<C<$_>|perlvar/$_>.

=item accept NUEVOSOCKET,SOCKETGENÉRICO
X<accept>

=for Pod::Functions accept an incoming socket connect

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

En sistemas que soportan el indicador B<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
L<C<$^F>|perlvar/$^F>. Ver L<perlvar/$^F>.

=item alarm SEGUNDOS
X<alarm> X<SIGALRM> X<timer> X<alarma> X<temporizador>

=item alarm

=for Pod::Functions schedule a SIGALRM

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 L<C<$_>|perlvar/$_>.  (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 C<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 L<Time::HiRes> (en
CPAN, y a partir de Perl 5.8 como parte de la distribución estándar) ofrece
L<C<ualarm>|Time::HiRes/ualarm_($useconds [, $interval_useconds ] )>. Puede
también usar la versión de L<C<select>|/select
RBITS,WBITS,EBITS,TIEMPO_ESPERA> de cuatro argumentos, dejando los tres
primeros indefinidos, o puede usar la interfaz L<C<syscall>|/syscall NÚMERO,
LISTA> para acceder a L<setitimer(2)> si su sistema lo soporta. Vea L<perlfaq8>
para más detalles.

Normalmente, es un error entremezclar llamadas a L<C<alarm>|/alarm SEGUNDOS> y
L<C<sleep>|/sleep EXPR>, porque L<C<sleep>|/sleep EXPR> se puede, internamente,
implementar en su sistema con L<C<alarm>|/alarm SEGUNDOS>.

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

    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 L<perlipc>.

Cuestiones de portabilidad: L<perlport/alarm>.

=item atan2 Y,X
X<atan2> X<arctangent> X<tan> X<tangent> X<arcotangente> X<tangente>

=for Pod::Functions arctangent of Y/X in the range -PI to PI

Devuelve el arcotangente de Y/X en el rango -PI a PI.

Para la operación tangente, puede usar la función
L<C<Math::Trig::tan>|Math::Trig/B<tan>>, o usar la conocida relación

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

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

Cuestiones de portabilidad: L<perlport/atan2>.

=item bind SOCKET,NOMBRE
X<bind>

=for Pod::Functions binds an address to a socket

Enlaza una dirección de red a un socket, como lo hace L<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
L<perlipc/"Sockets: Comunicación Cliente/Servidor">.

=item binmode IDENTIFICADOR_ARCHIVO, CAPA
X<binmode> X<binary> X<text> X<DOS> X<Windows> X<binario> X<texto>

=item binmode IDENTIFICADOR_ARCHIVO

=for Pod::Functions prepare binary files for I/O

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 L<C<undef>|/undef EXPR> y
establece L<C<$!>|perlvar/$!> (errno).

En algunos sistemas (en general, sistemas basados en DOS y Windows) es
necesario usar L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA> 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 L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA> 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 C<: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 I<"Programming Perl"> (el dromedario, 3.ª edición) o
en otro lugar, C<:raw> I<no> es el simplemente el inverso de C<:crlf> -- otras
capas que pudieran afectar la naturaleza binaria del flujo son I<también>
desactivadas. Ver L<PerlIO>, L<perlrun> y la discusión sobre la variable de
entorno PERLIO.

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

I<El parámetro CAPA de la función L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA> se describe como "DISCIPLINA" en "I<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 C<:utf8> o
C<:encoding(UTF-8)>. C<:utf8> solo marca los datos como UTF-8 sin más
comprobaciones ulteriores, mientras que C<:encoding(UTF-8)> comprueba que los
datos sean realmente UTF-8 válidos. Más detalles se pueden encontrar en
L<PerlIO::encoding>.

En general, L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA> se debe llamar
después de L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> pero antes de que
cualquier E/S se realice sobre el identificador de archivo. Llamando a
L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA>, 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 C<:encoding> que cambia la codificación por defecto del identificador
de archivo. La capa C<:encoding> algunas veces necesita ser llamada en mitad
del flujo de datos y no lo vacía. C<:encoding> también se coloca,
implícitamente, por encima de la capa C<: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 (C<\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 C<\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 C<\n> como un
simple C<\cJ>, pero es almacenado en los archivos de texto como los dos
caracteres C<\cM\cJ>. Esto significa que, si no usa L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA> en estos sistemas, las secuencias C<\cM\cJ> en
disco se convertirán a C<\n> en la entrada y cualquier C<\n> en tu programa se
convertirá de nuevo en C<\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 L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA>
(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 C<\cZ>, el subsistema de E/S lo
considerará como el fin del archivo, a menos que use L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA>.

L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA> es importante no solo para
las operaciones L<C<readline>|/readline EXPR> y L<C<print>|/print
IDENTIFICADOR_ARCHIVO LISTA>, sino también cuando se usa L<C<read>|/read
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>, L<C<seek>|/seek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>, L<C<sysread>|/sysread
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>, L<C<syswrite>|/syswrite
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> y L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO> (vea L<perlport> para más detalles). Consulte las
variables L<C<$E<sol>>|perlvar/$E<sol>> y L<C<$\>|perlvar/$\> en L<perlvar>
para ver cómo establecer manualmente sus secuencias de fin de línea en su
entrada y salida.

Cuestiones de portabilidad: L<perlport/binmode>.

=item bless REF,NOMBRE_CLASE
X<bless>

=item bless REF

=for Pod::Functions create an object

Esta función dice que la cosa referenciada por REF es ahora un objeto del
paquete NOMBRE_CLASE (I<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 L<C<bless>|/bless
REF,NOMBRE_CLASE> 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
L<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 I<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 L<perlmod/"Módulos Perl">.

=item break

=for Pod::Functions +switch break out of a C<given> block

Sale de un bloque C<given>.

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

=item caller EXPR
X<caller> X<call stack> X<stack> X<stack trace> X<llamador> X<pila de llamdas> X<pila> X<traza de pila>

=item caller

=for Pod::Functions get context of the current subroutine call

Devuelve el contexto de la llamada a la subrutina actual. En contexto escalar,
devuelve el nombre del paquete del llamante si aquel I<es> un llamante, es
decir, si estamos en una subrutina, L<C<eval>|/eval EXPR> o
L<C<require>|/require VERSIÓN>, 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 C<(eval)> si el marco de
llamada no es una llamada a una subrutina, sino un L<C<eval>|/eval EXPR>. En
tal caso, se añaden los nuevos elementos $evaltext y C<$is_require>:
C<$is_require> es verdadero si el marco se crea con una sentencia
L<C<require>|/require VERSIÓN> o L<C<use>|/use Módulo VERSIÓN LISTA>;
$evaltext contiene el texto de la sentencia C<eval EXPR>. En particular, para
una sentencia C<eval BLOQUE>, $subrutina es C<(eval)>, pero $evaltext es
indefinido.  (Note también que cada instrucción L<C<use>|/use Módulo
VERSIÓN LISTA> crea un marco L<C<require>|/require VERSIÓN> dentro de un
marco C<eval EXPR>). $subrutina puede ser también C<(unknown)> (desconocida)
si esta subrutina en particular parece haberse borrado de la tabla de
símbolos. C<$hasargs> es verdadero si una nueva instancia de
L<C<@_>|perlvar/@_> se creó para este marco. C<$hints> y C<$bitmask> contienen
detalles para los cuales caller fue compilado. C<$hints> corresponde a
L<C<$^H>|perlvar/$^H>, y C<$bitmask> corresponde a
L<C<${^WARNING_BITS}>|perlvar/${^WARNING_BITS}>. Los valores C<$hints> y
C<$bitmask> están sujetos a cambios entre versiones de Perl y no se espera que
se utilicen para uso externo.

C<$hinthash> es una referencia a un hash conteniendo el valor de
L<C<%^H>|perlvar/%^H> cuando el llamante se ha compilado, o L<C<undef>|/undef
EXPR> si L<C<%^H>|perlvar/%^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
C<@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
L<C<caller>|/caller EXPR> tenga la oportunidad de obtener la información. Eso
significa que C<caller(N)> quizás no devuelva información sobre el marco de
llamada que espera, para C<< N > 1 >>. En particular, C<@DB::args> podría
tener información de la llamada a la anterior llamada a L<C<caller>|/caller
EXPR>.

Tenga en cuenta que fijar C<@DB::args> es I<el mejor esfuerzo>, destinado a la
depuración o la generación de seguimientos, y no debería ser invocado. En
particular, como L<C<@_>|perlvar/@_> contiene los alias de los argumentos de la
función llamante, Perl no toma una copia de L<C<@_>|perlvar/@_>, así que
C<@DB::args> contendrá modificaciones que la subrutina hace a
L<C<@_>|perlvar/@_> o de sus contenidos, no los valores originales a la hora de
hacer la llamada. C<@DB::args>, como L<C<@_>|perlvar/@_>, 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 C<shift @_> puede, I<normalmente>, deshacerse (pero no C<pop
@_> u otras operaciones de troceado, I<y> tampoco si se ha tomado una
referencia a L<C<@_>|perlvar/@_>, I<y> con la salvedad sobre los elementos
reasignados), por lo que C<@DB::args> es realmente un híbrido del estado
actual e inicial de L<C<@_>|perlvar/@_>. Los compradores quedan advertidos.

=item chdir EXPR
X<chdir> X<cd> X<directory, change> X<directorio, cambio>

=item chdir IDENTIFICADOR_ARCHIVO

=item chdir IDENTIFICADOR_DIR

=item chdir

=for Pod::Functions change your current working directory

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

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

=item chmod LISTA
X<chmod> X<permission> X<mode> X<permisos> X<modo>

=for Pod::Functions changes the permissions on a list of files

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, I<no> debe ser una cadena de dígitos en octal: C<0644> es
correcto, C<"0644"> no lo es. Devuelve el número de archivos cambiados con
éxito. Vea también L<C</oct>|/oct EXPR> 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 L<fchmod(2)>, puede pasar identificadores de archivo
entre los archivos. En sistemas que no admiten L<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 C<S_I*> desde el módulo
L<C<Fcntl>|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: L<perlport/chmod>.

=item chomp VARIABLE
X<chomp> X<INPUT_RECORD_SEPARATOR> X<$/> X<newline> X<eol> X<nueva línea>

=item chomp( LISTA )

=item chomp

=for Pod::Functions remove a trailing record separator from a string

Esta versión segura de L<C<chop>|/chop VARIABLE>, quita cualquier cadena
restante que corresponda al valor actual de L<C<$E<sol>>|perlvar/$E<sol>>
(también conocido como $INPUT_RECORD_SEPARATOR -separador de registros en
entrada- en el módulo L<C<English>|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 (C<$/ = ''>), elimina todos los caracteres de nueva línea de la
cadena. En modo chupón (C<$/ = undef>) o en modo de registros de longitud fija
(L<C<$E<sol>>|perlvar/$E<sol>> es una referencia a un entero o algo parecido;
ver L<perlvar>), L<C<chomp>|/chomp VARIABLE> no elimina nada. Si se omite
VARIABLE, usa L<C<$_>|perlvar/$_>. 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 L<C<each>|/each HASH> 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 C<chomp $cwd = `pwd`;> es
interpretado como C<(chomp $cwd) = `pwd`;>, en vez de un C<chomp( $cwd = `pwd`
)> que es lo que se esperaba. Similarmente, C<chomp $a, $b> es interpretado
como C<chomp($a), $b> en vez de un C<chomp($a, $b)>.

=item chop VARIABLE
X<chop>

=item chop( LISTA )

=item chop

=for Pod::Functions remove the last character from a string

Recorta el último carácter de un string y devuelve el carácter recortado. Es
más eficiente que C<s/.$//s> porque ni escanea ni copia el string. Si se omite
VARIABLE, recorta L<C<$_>|perlvar/$_>. Si VARIABLE es un hash, recorta los
valores del hash, pero no sus claves, reiniciando el iterador L<C<each>|/each
HASH> 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 L<C<chop>|/chop VARIABLE>.

Note que L<C<chop>|/chop VARIABLE> devuelve el último carácter. Para devolver
todos menos el último carácter, use C<substr($string, 0, -1)>.

Vea también L<C<chomp>|/chomp VARIABLE>.

=item chown LISTA
X<chown> X<owner> X<user> X<group> X<propietario> X<usuario> X<grupo>

=for Pod::Functions change the ownership on a list of files

Cambia el propietario (y grupo) de una lista de archivos. Los primeros dos
elementos de la lista deben ser el valor I<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 L<fchown(2)>, puede pasar identificadores de archivo
entre los archivos. En sistemas que no admiten L<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: L<perlport/chown>.

=item chr NÚMERO
X<chr> X<character> X<ASCII> X<Unicode> X<carácter>

=item chr

=for Pod::Functions get character this number represents

Devuelve el carácter representado por NÚMERO en el conjunto de caracteres.
Por ejemplo, C<chr(65)> es C<"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 L<bytes>, donde se utilizan los ocho bits más bajos del valor
(truncado a un entero).

Si se omite NÚMERO, se usa L<C<$_>|perlvar/$_>.

Para lo contrario, use L<C<ord>|/ord EXPR>.

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 L<perlunicode> para más información acerca de Unicode.

=item chroot NOMBRE_ARCHIVO
X<chroot> X<root>

=item chroot

=for Pod::Functions make directory new root for path lookups

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 C</> 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
L<C<chroot>|/chroot NOMBRE_ARCHIVO> a L<C<$_>|perlvar/$_>.

B<NOTA:> Es una buena práctica de seguridad hacer C<chdir("/")>
(L<C<chdir>|/chdir EXPR> a la raíz del directorio) inmediatamente después de
un L<C<chroot>|/chroot NOMBRE_ARCHIVO>.

Cuestiones de portabilidad: L<perlport/chroot>.

=item close IDENTIFICADOR_ARCHIVO
X<close>

=item close

=for Pod::Functions close file (or pipe or socket) handle

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 L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> sobre él mismo, porque
L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> lo cierra por usted.  (Vea
L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR>). Sin embargo, un L<C<close>|/close
IDENTIFICADOR_ARCHIVO> explícito en un archivo de entrada reinicia el contador
de líneas (L<C<$.>|perlvar/$.>), mientras que un cierre implícito hecho por
L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR>, no.

Si el identificador de archivo proviene de una tubería abierta,
L<C<close>|/close IDENTIFICADOR_ARCHIVO> 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, L<C<$!>|perlvar/$!> se
establecerá a C<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 L<C<$?>|perlvar/$?> y en
L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>.

Si existen múltiples hilos en ejecución, L<C<close>|/close
IDENTIFICADOR_ARCHIVO> 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.

=item closedir IDENTIFICADOR_DIR
X<closedir>

=for Pod::Functions close directory handle

Cierra un directorio abierto por L<C<opendir>|/opendir IDENTIFICADOR_DIR,EXPR>
y devuelve el éxito de la llamada del sistema.

=item connect SOCKET,NOMBRE
X<connect>

=for Pod::Functions connect to a remote socket

Intenta conectarse a un socket remoto, al igual que L<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
L<perlipc/"Sockets: Comunicación Cliente/Servidor">.

=item continue BLOQUE
X<continue>

=item continue

=for Pod::Functions optional trailing block in a while or foreach

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

L<C<last>|/last ETIQUETA>, L<C<next>|/next ETIQUETA> o L<C<redo>|/redo
ETIQUETA> pueden aparecer dentro de un bloque L<C<continue>|/continue BLOQUE>;
L<C<last>|/last ETIQUETA> y L<C<redo>|/redo ETIQUETA> se comporta como si se
hubiera ejecutado dentro del bloque principal. También L<C<next>|/next
ETIQUETA>, pero como ejecutará un bloque L<C<continue>|/continue BLOQUE>,
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 L<C<continue>|/continue BLOQUE> es equivalente a usar un
bloque vacío, como es lógico, por lo que L<C<next>|/next ETIQUETA> va
directamente a comprobar la condición en la parte superior del bucle.

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

=item cos EXPR
X<cos> X<cosine> X<acos> X<arccosine> X<coseno> X<arco coseno>

=item cos

=for Pod::Functions cosine function

Devuelve el coseno de EXPR (expresado en radianes). Si EXPR se omite, devuelve
el coseno de L<C<$_>|perlvar/$_>.

Para la inversa de la operación coseno, puede usar la función
L<C<Math::Trig::acos>|Math::Trig>, o usar esta relación:

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

=item crypt TEXTOPLANO,SALTO
X<crypt> X<digest> X<hash> X<salt> X<plaintext> X<password> X<decrypt> X<cryptography> X<passwd> X<contraseña>

=for Pod::Functions one-way passwd-style encryption

Crea una cadena resumen exactamente igual que la función L<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).

L<C<crypt>|/crypt TEXTOPLANO,SALTO> es una función hash de un solo sentido. El
TEXTOPLANO y el SALTO se convierten en una pequeña cadena, llamada I<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 I<digest>.

No existe la función decrypt. Esta función no es muy útil para criptografía
(para esto, mire en los módulos F<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 I<digest> de una contraseña se almacena, no la propia contraseña. El
usuario escribe la contraseña que es en-L<C<crypt>|/crypt
TEXTOPLANO,SALTO>-tada con el mismo salto con el que se almacenó el I<digest>.
Si los dos I<digest> coinciden, la contraseña es correcta.

Cuando verifique una cadena I<digest> debe usar el propio I<digest> como salto
(como C<crypt($plano, $digest) eq $digest>). El SALTO usado para crear el
I<digest> es visible como parte del I<digest>. Esto asegura que
L<C<crypt>|/crypt TEXTOPLANO,SALTO> creará el hash de la nueva cadena con el
mismo salto que el I<digest>. Esto permite a su código trabajar con el
estándar L<C<crypt>|/crypt TEXTOPLANO,SALTO> 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 C<[./0-9A-Za-z]>, y sólo los
primeros ocho bytes del I<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 C<[./0-9A-Za-z]> (como por ejemplo C<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 L<C<crypt>|/crypt TEXTOPLANO,SALTO> 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 L<C<crypt>|/crypt TEXTOPLANO,SALTO> 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
L<Digest> por algoritmos más robustos.

Si usa L<C<crypt>|/crypt TEXTOPLANO,SALTO> en una cadena Unicode (que
I<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
L<C<crypt>|/crypt TEXTOPLANO,SALTO> (sobre esa copia). Si esto funciona, bien.
Si no, L<C<crypt>|/crypt TEXTOPLANO,SALTO> muere con el mensaje L<C<Wide
character in crypt>|perldiag/Wide character in %s>.

Cuestiones de portabilidad: L<perlport/crypt>.

=item dbmclose HASH
X<dbmclose>

=for Pod::Functions breaks binding on a tied dbm file

[Esta función ha sido largamente supeditada por la función L<C<untie>|/untie
VARIABLE>].

Rompe la ligadura entre un archivo DBM y un hash.

Cuestiones de portabilidad: L<perlport/dbmclose>.

=item dbmopen HASH,NOMBRE_BASE_DATOS,MÁSCARA
X<dbmopen> X<dbm> X<ndbm> X<sdbm> X<gdbm>

=for Pod::Functions create binding on a tied dbm file

[Esta función se ha superado de largo por la función L<C<tie>|/tie
VARIABLE,NOMBRE_CLASE,LISTA>].

Liga un archivo L<dbm(3)>, L<ndbm(3)>, L<sdbm(3)>, L<gdbm(3)> o Berkeley DB a
un hash. HASH es el nombre del hash.  (A diferencia de un L<C<open>|/open
IDENTIFICADOR_ARCHIVO,EXPR> normal, el primer argumento I<no> es un
identificador de archivo, aunque lo parezca). NOMBREDB es el nombre de la base
de datos (sin la extensión F<.dir> o F<.pag> si las tuviera). Si la base de
datos no existe, se crea con la protección especificada por MÁSCARA (y
modificada por L<C<umask>|/umask EXPR>). 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 L<C<dbmopen>|/dbmopen HASH,NOMBRE_BASE_DATOS,MÁSCARA> en su programa.
En las versiones anteriores de Perl, si su sistema no tiene ni DBM ni ndbm,
llamar a L<C<dbmopen>|/dbmopen HASH,NOMBRE_BASE_DATOS,MÁSCARA> produce un
error fatal; ahora lo reintentará con L<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
L<C<eval>|/eval EXPR> para atrapar el error.

Note que las funciones como L<C<keys>|/keys HASH> y L<C<values>|/values HASH>
pueden devolver listas largas cuando se usan con archivos DBM grandes. Puede
preferir usar la función L<C<each>|/each HASH> 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 L<AnyDBM_File> para una descripción más general de los pros y
contras de las distintas formas dbm, así como L<DB_File> para ver una
implementación particularmente rica.

Puede controlar qué biblioteca DBM usará cargando la biblioteca antes de
llamar a L<C<dbmopen>|/dbmopen HASH,NOMBRE_BASE_DATOS,MÁSCARA>:

    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: L<perlport/dbmopen>.

=item defined EXPR
X<defined> X<undef> X<undefined> X<definido> X<indefinido>

=item defined

=for Pod::Functions test whether a value, variable, or function is defined

Devuelve un valor booleano indicando si EXPR tiene un valor que no sea el valor
indefinido L<C<undef>|/undef EXPR>. Si EXPR no está presente, se comprobará
L<C<$_>|perlvar/$_>.

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

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

Se desaconseja el uso de L<C<defined>|/defined EXPR> 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 L<C<exists>|/exists EXPR> 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 L<C<defined>|/defined EXPR> y, para su
sorpresa, descubren que el número C<0> y C<""> (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 C<$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 L<C<defined>|/defined EXPR> sólo cuando está cuestionando la integridad
de lo que está intentando hacer. En otras ocasiones, una simple comparación
con C<0> o C<""> es lo que necesita.

Vea también L<C<undef>|/undef EXPR>, L<C<exists>|/exists EXPR>, L<C<ref>|/ref
EXPR>.

=item delete EXPR
X<delete>

=for Pod::Functions deletes a value from a hash

Dada una expresión que especifica un elemento o una porción de un hash,
L<C<delete>|/delete EXPR> elimina los elementos especificados de este hash de
tal forma que L<C<exists>|/exists EXPR> 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 L<C<exists>|/exists EXPR>.

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.

L<C<delete>|/delete EXPR> se puede usarse también en array y porciones de
array, pero su comportamiento es menos claro. Aunque L<C<exists>|/exists EXPR>
devolverá falso para entradas eliminadas, eliminar elementos del array nunca
cambia los índices de los valores existentes; use en su lugar
L<C<shift>|/shift ARRAY> o L<C<splice>|/splice
ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA>. 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 L<C<exists>|/exists EXPR>, o 0 si no hay ninguno. En otras palabras, un
array no tendrá elementos inexistentes al final, después de un delete.

B<AVISO:> Se desaconseja fuertemente llamar a L<C<delete>|/delete EXPR> 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 L<C<%ENV>|perlvar/%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 L<C<tied>|/tied VARIABLE> (I<atado>) no necesariamente devolverá
algo; depende de la implementación del método DELETE en el paquete
L<C<tied>|/tied VARIABLE>, que puede hacer lo que quiera.

La construcción C<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 L<perlsub/"Eliminación local de
elementos de tipos compuestos">.

    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];

=item die LISTA
X<die> X<throw> X<exception> X<raise> X<$@> X<abort> X<excepción> X<levantar> X<abortar> X<descartar>

=for Pod::Functions raise an exception or bail out

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

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 L<C<$.>|perlvar/$.>. Ver
L<perlvar/"$/"> y L<perlvar/"$.">.

Consejo: algunas veces añadir C<", parado"> a tu mensaje hará aparecerle con
un sentido mejor cuando se le añada la cadena C<"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 L<C<$@>|perlvar/$@> ya contiene un valor
(típicamente de un eval() anterior) este valor se utiliza después de
añadirle C<"\t...propagated">. Esto es útil para propagar excepciones:

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

Si la salida está vacía y L<C<$@>|perlvar/$@> contiene una referencia a un
objeto que tiene un método C<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 L<C<$@>|perlvar/$@>; es decir, como si se ejecutara C<<
$@ = eval { $@->PROPAGATE(__FILE__, __LINE__) }; >>.

Si L<C<$@>|perlvar/$@> está vacío entonces se usa la cadena C<"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 L<C<$!>|perlvar/$!> y
L<C<$?>|perlvar/$?> con este pseudocódigo:

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

Cuando se llega a L<C<exit>|/exit EXPR>, se establece L<C<$?>|perlvar/$?> antes
de que se desmantele la pila de llamadas; cualquier gestor C<DESTROY> o C<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 L<C<$!>|perlvar/$!> es el valor de C de C<errno>, que se puede establecer
por cualquier llamada al sistema, esto significa que el valor del código de
salida utilizada por L<C<die>|/die LISTA> puede no ser predecible, por lo que
no debe confiarse en él, aparte de cuando sea distinto de cero.

También puede llamar a L<C<die>|/die LISTA> con una referencia como argumento,
y si éste queda atrapado en un L<C<eval>|/eval EXPR>, L<C<$@>|perlvar/$@>
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 L<C<$@>|perlvar/$@> usando expresiones
regulares. Dado que L<C<$@>|perlvar/$@> es una variable global y
L<C<eval>|/eval EXPR> 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 L<overload> para los
detalles sobre esto.

Puede disponer que una retrollamada se ejecute antes de que L<C<die>|/die
LISTA> haga sus funciones, actualizando el enganche
L<C<$SIG{__DIE__}>|perlvar/%SIG>. 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 L<C<die>|/die LISTA>. Ver L<perlvar/%SIG> para los
detalles sobre cómo colocar entradas L<C<%SIG>|perlvar/%SIG> y L<C<eval>|/eval
EXPR> 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 L<C<$SIG{__DIE__}>|perlvar/%SIG>, ¡se llama incluso desde
dentro de cadenas y bloques L<C<eval>|/eval EXPR>uados!  Si uno quiere que el
enganche no haga nada en estas situaciones, ponga

    die @_ if $^S;

como primera línea del controlador (ver L<perlvar/$^S>). 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 L<C<exit>|/exit EXPR>, L<C<warn>|/warn LISTA> y el módulo
L<Carp>.

=item do BLOQUE
X<do> X<block> X<bloque>

=for Pod::Functions turn a BLOCK into a TERM

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 C<while> o C<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).

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

=item do EXPR
X<do>

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 L<C<@INC>|perlvar/@INC> y actualiza L<C<%INC>|perlvar/%INC> si
se encuentra al archivo. Vea L<perlvar/@INC> y L<perlvar/%INC> para encontrar
información sobre estas variables. También difiere en que el código evaluado
con C<do ARCHIVO> no puede ver a las variables léxicas en el ámbito en que se
ejecuta; C<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 L<C<do>|/do EXPR> puede leer el archivo pero no puede compilarlo, devuelve
L<C<undef>|/undef EXPR> y pone un mensaje de error en L<C<$@>|perlvar/$@>. Si
L<C<do>|/do EXPR> no puede leer el archivo, devuelve undef y pone
L<C<$!>|perlvar/$!> al valor del error. Siempre revise L<C<$@>|perlvar/$@> en
primer lugar, la compilación puede fallar de una manera que también se
establezca L<C<$!>|perlvar/$!>. Si el archivo se compila bien, L<C<do>|/do
EXPR> devuelve el valor de la última expresión evaluada.

La inclusión de bibliotecas de módulos es mejor hacerla con los operadores
L<C<use>|/use Módulo VERSIÓN LISTA> y L<C<require>|/require VERSIÓN>, que
también hacen una comprobación automática de errores y generan una
excepción si existe algún problema.

Puede usar L<C<do>|/do EXPR> 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;
        }
    }

=item dump ETIQUETA
X<dump> X<core> X<undump> X<volcado> X<núcleo>

=item dump EXPR

=item dump

=for Pod::Functions create an immediate core 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 B<-u> en L<perlrun>, que hace lo
mismo. Principalmente esto se utiliza en conjunción con el programa B<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 C<goto
ETIQUETA> (con todas las restricciones que L<C<goto>|/goto ETIQUETA> padece).
Piense en él como un goto entre un volcado del núcleo y una reencarnación.
Si se omite C<ETIQUETA>, reinicia el programa desde el principio. La forma
C<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 C<dump
LABEL>.

B<ATENCIÓN>: Cualquier archivo abierto en el momento del volcado I<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 C<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 C<dump ("foo")."bar"> hará que "bar" sea parte del argumento a
L<C<dump>|/dump ETIQUETA>.

Cuestiones de portabilidad: L<perlport/dump>.

=item each HASH
X<each> X<hash, iterator> X<hash, iterador>

=item each ARRAY
X<array, iterator> X<array, iterador>

=for Pod::Functions retrieve the next key/value pair from a hash

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 L<C<each>|/each
HASH> o L<C<keys>|/keys HASH> se puede borrar sin que cambie el orden. Siempre
y cuando no se modifique un determinado hash puede confiar en que
L<C<keys>|/keys HASH>, L<C<values>|/values HASH> y L<C<each>|/each HASH>
devuelvan repetidamente lo mismo en el mismo orden. Vea L<perlsec/"Ataques de
complejidad algorítmica"> 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 L<C<each>|/each HASH> haya devuelto todas las entradas del hash
o del array, la siguiente llamada a L<C<each>|/each HASH> devuelve la lista
vacía, en contexto lista, y L<C<undef>|/undef EXPR> en contexto escalar; la
siguiente llamada a I<ésa> reiniciará la iteración. Cada hash o array tiene
su propio iterador interno, accedido por L<C<each>|/each HASH>, L<C<keys>|/keys
HASH>, y L<C<values>|/values HASH>. El iterador es implícitamente restablecido
cuando L<C<each>|/each HASH> ha llegado al final como se acaba de describir;
puede ser explícitamente restablecido llamando a L<C<keys>|/keys HASH> o
L<C<values>|/values HASH> 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 L<C<each>|/each HASH>, 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 L<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 L<C<each>|/each
HASH> 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 L<C<each>|/each HASH> en un bucle
C<while>, que actualizará L<C<$_>|perlvar/$_> 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
I<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 L<C<keys>|/keys HASH>, L<C<values>|/values HASH> y L<C<sort>|/sort
NOMBRE_SUB LISTA>.

=item eof IDENTIFICADOR_ARCHIVO
X<eof> X<end of file> X<end-of-file> X<fin de archivo>

=item eof ()

=item eof

=for Pod::Functions test a filehandle for its end

Devuelve 1 si la siguiente lectura sobre IDENTIFICADOR_ARCHIVO devolverá un
fin-de-archivo, I<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 C<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
C<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 L<C<eof>|/eof IDENTIFICADOR_ARCHIVO> sin argumento usa el último archivo
leído. Usar L<C<eof()>|/eof IDENTIFICADOR_ARCHIVO> 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 C<< <> >>. Como C<< <> >> no
es explícitamente abierto, como lo sería un identificador de archivo, un
L<C<eof()>|/eof IDENTIFICADOR_ARCHIVO> antes de que se use un C<< <> >>,
causará que se examine L<C<@ARGV>|perlvar/@ARGV> para determinar si la entrada
está disponible.   De forma semejante, un L<C<eof()>|/eof
IDENTIFICADOR_ARCHIVO> después de que un C<< <> >> haya devuelto un
fin-de-archivo asumirá que está procesando otra lista
L<C<@ARGV>|perlvar/@ARGV>, y si no ha establecido un nuevo
L<C<@ARGV>|perlvar/@ARGV>, leerá la entrada desde C<STDIN>; vea
L<perlop/"Operadores E/S">.

En un bucle C<< while (<>) >>, L<C<eof>|/eof IDENTIFICADOR_ARCHIVO> o
C<eof(ARGV)> pueden usarse para detectar el fin de un archivo, mientras que
L<C<eof()>|/eof IDENTIFICADOR_ARCHIVO> 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 L<C<eof>|/eof IDENTIFICADOR_ARCHIVO>
en Perl, porque los operadores de entrada normalmente devuelven
L<C<undef>|/undef EXPR> cuando no hay más datos, o si se produce un error.

=item eval EXPR
X<eval> X<try> X<catch> X<evaluate> X<parse> X<execute> X<error, handling> X<exception, handling> X<manejo de excepciones> X<interpretar>

=item eval BLOQUE

=item eval

=for Pod::Functions catch exceptions or compile and run code

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 L<C<eval>|/eval EXPR>.
Si se omite EXPR, se usa L<C<$_>|perlvar/$_>. 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 L<característica C<"unicode_eval">|feature/Las características
'unicode_eval' y 'evalbytes'> está habilitada (que lo es por defecto con una
declaración C<use 5.16> o superior), EXPR o L<C<$_>|perlvar/$_> se tratan como
una cadena de caracteres, así que las declaraciones L<C<use utf8>|utf8> no
tienen efecto, y los filtros de código fuente quedan prohibidos. En ausencia
de la L<característica C<"unicode_eval"> feature|feature/Las características
'unicode_eval' y 'evalbytes'>, 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 L<C<eval>|/eval EXPR> 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
L<C<evalbytes>|/evalbytes EXPR>, que siempre trata su entrada como un flujo de
bytes y funciona correctamente con filtros de código fuente, y el pragma
L<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 C<"NaN"> o C<"Infinity">; o, dentro del ámbito de un L<C<use
locale>|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 L<C<eval>|/eval
EXPR> 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 L<C<eval>|/eval EXPR>. Ver L<C<wantarray>|/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 L<C<die>|/die LISTA>, L<C<eval>|/eval EXPR> devuelve
L<C<undef>|/undef EXPR> en contexto escalar o una lista vacía en contexto
lista, y L<C<$@>|perlvar/$@> se inicializa al mensaje de error.  (Antes de
5,16, un error causaba que C<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 L<C<$@>|perlvar/$@> será una cadena vacía. Un
operador de control de flujo como L<C<last>|/last ETIQUETA> o L<C<goto>|/goto
ETIQUETA> puede pasar por alto el valor de L<C<$@>|perlvar/$@>. Tenga cuidado
porque usar L<C<eval>|/eval EXPR> ni silencia a Perl a la hora de imprimir
avisos al STDERR, ni rellena el texto de los mensajes de aviso dentro de
L<C<$@>|perlvar/$@>. Para hacer cualquiera de estas dos cosas debe usar
L<C<$SIG{__WARN__}>|perlvar/%SIG>, o desactivar los avisos dentro del BLOQUE o
EXPR usando S<C<no warnings 'all'>>. Vea L<C<warn>|/warn LISTA>, L<perlvar>, y
L<warnings>.

Note que, como L<C<eval>|/eval EXPR> atrapa errores considerados fatales, es
útil para determinar cuándo una característica en particular (como
L<C<socket>|/socket SOCKET,DOMINIO,TIPO,PROTOCOLO> o L<C<symlink>|/symlink
ARCHIVO_VIEJO,ARCHIVO_NUEVO>) está implementada. También es el mecanismo de
captura de excepciones de Perl, donde el operador L<C<die>|/die LISTA> 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 L<C<eval>|/eval EXPR> a menos que esté establecido
C<$ENV{PERL_DL_NONLAZY}>. Vea L<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
L<C<$@>|perlvar/$@>. 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 C<eval {}> como una trampa de excepciones en bibliotecas puede
traer algunos problemas. Debido al posible mal estado de la llamada C<__DIE__>,
quizás deseé no activar ninguna de las llamadas C<__DIE__> que el código de
usuario puede haber instalado. Puede usar la construcción C<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 C<__DIE__> pueden
llamar de nuevo a L<C<die>|/die LISTA>, 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 L<C<eval>|/eval EXPR>, 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 C<'$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 I<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 L<C<$@>|perlvar/$@> 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
    }

C<eval BLOQUE> I<no> cuenta como un bucle, así que las instrucciones de
control de bucle L<C<next>|/next ETIQUETA>, L<C<last>|/last ETIQUETA>, o
L<C<redo>|/redo ETIQUETA> no se pueden usar para dejar o reiniciar el bloque.

Un C<eval ''> ejecutado dentro de una subrutina definida en el paquete C<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.

=item evalbytes EXPR
X<evalbytes>

=item evalbytes

=for Pod::Functions +evalbytes similar to string eval, but intend to parse a bytestream

Esta función es como L<C<eval>|/eval EXPR> con un argumento de cadena, excepto
que siempre analiza su argumento o L<C<$_>|perlvar/$_> 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.

L<C<evalbytes>|/evalbytes EXPR> sólo está disponible si la característica
L<C<"evalbytes">|feature/Las características 'unicode_eval' y 'evalbytes'>
(vea L<feature>) está activada o si está prefijada con C<CORE::>. La
característica L<C<"evalbytes">|feature/Las características 'unicode_eval' y
'evalbytes'> se activa automáticamente con una declaración C<use v5.16> (o
superior) en el ámbito actual.

=item exec LISTA
X<exec> X<execute> X<ejecutar>

=item exec PROGRAMA LISTA

=for Pod::Functions abandon this program to run another

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

Como es un error frecuente usar L<C<exec>|/exec LISTA> en lugar de
L<C<system>|/system LISTA>, Perl le avisará si se llama a L<C<exec>|/exec
LISTA> en contexto vacío, y si hay alguna instrucción a continuación que no
sea L<C<die>|/die LISTA> o L<C<warn>|/warn LISTA> o L<C<exit>|/exit EXPR> (si
L<warnings> está activado -pero usted, siempre lo tiene así, ¿verdad?-). Si
I<verdaderamente> quiere continuar un L<C<exec>|/exec LISTA> 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 L<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 C</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 C<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 C<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
L<perlop/"`STRING`"> para los detalles.

Usar un objeto indirecto con L<C<exec>|/exec LISTA> o L<C<system>|/system
LISTA> es también más seguro. Este uso (que también funciona bien con
L<C<system>|/system LISTA>) 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 I<echo>,
pasándole C<"sorpresa"> como argumento. La segunda versión no; intentó
ejecutar un programa llamado, literalmente, I<"echo sorpresa">; no lo
encontró, y estableció L<C<$?>|perlvar/$?> a un valor distinto de cero para
indicar error.

En Windows, solo la sintaxis de objetos indirecto en C<exec PROGRAMA LISTA>
evitará, de forma efectiva, evitar usar la shell; C<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
L<perlport>). Para estar seguros, puede necesitar establecer
L<C<$E<verbar>>|perlvar/$E<verbar>> ($AUTOFLUSH en el módulo L<English>) o
llamar el método C<autoflush> de L<C<IO::Handle>|IO::Handle/METHODS> en
cualquiera de los identificadores de archivo abiertos para evitar la pérdida
de datos en la salida.

Note que L<C<exec>|/exec LISTA> no llamará a sus bloques C<END>, ni llamará a
ningún método C<DESTROY> de sus objetos.

Cuestiones de portabilidad: L<perlport/exec>.

=item exists EXPR
X<exists> X<autovivification> X<autovivificación>

=for Pod::Functions test whether a hash key is present

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
L<C<delete>|/delete EXPR> en arrays.

B<AVISO:> Se desaconseja fuertemente llamar a L<C<exists>|/exists EXPR> 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 C<AUTOLOAD> que la
hace aparecer la primera vez que se le llama; ver L<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í. C<< $ref->{"A"} >> y C<< $ref->{"A"}->{"B"} >> aparecerán en
la existencia debido a la comprobación del elemento C<$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 L<C<exists>|/exists EXPR>, es un error.

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

=item exit EXPR
X<exit> X<terminate> X<abort> X<abortar> X<terminar> X<salir>

=item exit

=for Pod::Functions terminate this program

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

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

Vea también L<C<die>|/die LISTA>. Si se omite EXPR, sale con estado C<0>. Los
únicos valores universalmente reconocidos para EXPR son C<0> para éxito y
C<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 I<sendmail>
hará que el despachador de correo devuelva el elemento sin entregar, pero no
siempre es cierto.

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

La función L<C<exit>|/exit EXPR> no siempre termina de forma inmediata. Llama
primero a cualquier rutina C<END> definida, pero estas rutinas C<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 C<END> y
los destructores pueden cambiar el estado de salida modificando
L<C<$?>|perlvar/$?>. Si esto es un problema, puede llamar a
L<C<POSIX::_exit($status)>|POSIX/C<_exit>> para saltar el procesado de C<END> y
de los destructores. Ver L<perlmod> para los detalles.

Cuestiones de portabilidad: L<perlport/exit>.

=item exp EXPR
X<exp> X<exponential> X<antilog> X<antilogarithm> X<e> X<exponencial> X<anti logaritmo>

=item exp

=for Pod::Functions raise I<e> to a power

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

=item fc EXPR
X<fc> X<foldcase> X<casefold> X<fold-case> X<case-fold>
X<plegado de caja> X<plegado-caja> X<cambio de caja>

=item fc

=for Pod::Functions +fc return casefolded version of a string

Devuelve la versión de EXPR con los tamaños de caja cambiados. Esta es la
función interna de la secuencia de escapado C<\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 L<Unicode::UCD/B<casefold()>> y
L<Unicode::UCD/B<prop_invmap()>>. Para más información sobre plegado de caja,
consulte el Estándar Unicode, específicamente las secciones 3.13 C<Default
Case Operations>, 4.2 C<Case-Normative>, y 5.18 C<Case Mappings>, disponible en
L<http://www.unicode.org/versions/latest/>, así como los C<Case Charts>
disponibles en L<http://www.unicode.org/charts/case/>.

Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

Esta función se comporta de la misma manera bajo varios pragmas, como en
L<S<C<"use feature 'unicode_strings">>|feature/La característica
'unicode_strings'>, como lo hace L<C<lc>|/lc EXPR>, con la única excepción de
L<C<fc>|/fc EXPR> de I<LATIN CAPITAL LETTER SHARP S> (U+1E9E) dentro del
ámbito de L<S<C<use locale>>|locale>. El plegado de caja de este carácter
normalmente sería C<"ss">, pero como se ha explicado en la sección de
L<C<lc>|/lc EXPR>, 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
C<"\x{17F}\x{17F}">, la cual es la I<LATIN SMALL LETTER LONG S>. Ya que este
carácter se pliega a si mismo a una C<"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 L<C<Unicode::Casing>|Unicode::Casing> se puede
utilizar para proporcionar una implementación.

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

=item fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR
X<fcntl>

=for Pod::Functions file control system call

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

    use Fcntl;

primero para obtener las definiciones de las constantes. El procesamiento de
argumentos y el valor devuelto funcionan como L<C<ioctl>|/ioctl
IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>. Por ejemplo:

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

No necesita comprobar con L<C<defined>|/defined EXPR> al regreso de
L<C<fcntl>|/fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>. Como
L<C<ioctl>|/ioctl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>, mapea un C<0>
devuelto de la llamada del sistema en un C<"0 but true"> ("0, pero cierto") en
Perl. Esta cadena es verdadera en contexto booleano y C<0> en contexto
numérico. También es una excepción en el sistema normal de avisos
L<C<Argument "..." isn't numeric>|perldiag/Argument "%s" isn't numeric%s> sobre
conversiones numéricas no apropiadas.

Tenga en cuenta que L<C<fcntl>|/fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>
levanta una excepción si se utiliza en una máquina que no implemente
L<fcntl(2)>. Vea el módulo L<Fcntl> o la página de manual L<fcntl(2)> para
aprender qué funciones están disponibles en su sistema.

Aquí hay un ejemplo que establece un identificador de archivo llamado
C<$REMOTE> a no bloqueante a nivel de sistema. Aunque, tendrá que negociar con
L<C<$E<verbar>>|perlvar/$E<verbar>>.

    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: L<perlport/fcntl>.

=item __FILE__
X<__FILE__>

=for Pod::Functions the name of the current source file

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

=item fileno IDENTIFICADOR_ARCHIVO
X<fileno>

=for Pod::Functions return file descriptor from filehandle

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
L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> con una referencia para el tercer
argumento, se devuelve -1.

Esto es principalmente útil para construir bitmaps para L<C<select>|/select
RBITS,WBITS,EBITS,TIEMPO_ESPERA> 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 L<C<fileno>|/fileno IDENTIFICADOR_ARCHIVO> en un
identificador de directorio depende del sistema operativo. En un sistema con
L<dirfd(3)> o similar, L<C<fileno>|/fileno IDENTIFICADOR_ARCHIVO> 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 L<C<fileno>|/fileno IDENTIFICADOR_ARCHIVO>
(errno).

=item flock IDENTIFICADOR_ARCHIVO,OPERACIÓN
X<flock> X<lock> X<locking>

=for Pod::Functions lock an entire file with an advisory lock

Llama a L<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 L<flock(2)>, bloqueo L<fcntl(2)>, o
L<lockf(3)>. L<C<flock>|/flock IDENTIFICADOR_ARCHIVO,OPERACIÓN> 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
L<C<flock>|/flock IDENTIFICADOR_ARCHIVO,OPERACIÓN> son: que espera
indefinidamente hasta que el bloqueo se concede, y que sus cerrojos son
B<meramente consultivos>. Tales bloqueos, discrecionalmente, son más
flexibles, pero ofrecen pocas garantías. Esto significa que los programas que
no usen L<C<flock>|/flock IDENTIFICADOR_ARCHIVO,OPERACIÓN> pueden modificar
archivos bloqueados con L<C<flock>|/flock IDENTIFICADOR_ARCHIVO,OPERACIÓN>.
Vea L<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 L<Fcntl>,
tanto de forma individual o como un grupo usando la marca C<: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 L<C<flock>|/flock
IDENTIFICADOR_ARCHIVO,OPERACIÓN> 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 L<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 L<lockf(3)> implementa. La mayor
parte si no todos los sistemas implementan L<lockf(3)> en términos de bloqueo
con L<fcntl(2)>, aunque, las diferencias en la semántica no debería
sorprender a muchas personas.

Note que la emulación de L<fcntl(2)> de L<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 L<C<flock>|/flock
IDENTIFICADOR_ARCHIVO,OPERACIÓN> no pueden bloquear cosas sobre la red;
necesitará usar un L<C<fcntl>|/fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>
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 L<flock(2)> y proveer de su propia
emulación basada en L<fcntl(2)>, pasando la opción C<-Ud_flock> al programa
F<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 L<flock(2)> real, los bloqueos se heredan a través
de las llamadas L<C<fork>|/fork>, teniendo en cuenta que se recurrirá a la
caprichosa función L<fcntl(2)> que pierde sus bloqueos, haciendo difícil
escribir servidores.

Ver también L<DB_File> para otros ejemplos de L<C<flock>|/flock
IDENTIFICADOR_ARCHIVO,OPERACIÓN>.

Cuestiones de portabilidad: L<perlport/flock>.

=item fork
X<fork> X<child> X<parent> X<hijo> X<padre>

=for Pod::Functions create a new process just like this one

Hace una llamada del sistema L<fork(2)> para crear un nuevo proceso ejecutando
el mismo programa en el mismo punto. Devuelve el pid del hijo al proceso padre,
C<0> al proceso hijo, o L<C<undef>|/undef EXPR> 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 L<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 L<perlport>). Para estar seguros, puede necesitar establecer
L<C<$E<verbar>>|perlvar/$E<verbar>> ($AUTOFLUSH en el módulo L<English>) o
llamar el método C<autoflush> de L<C<IO::Handle>|IO::Handle/METHODS> en
cualquiera de los identificadores de archivo abiertos para evitar la salida
duplicada.

Si hace un L<C<fork>|/fork> sin luego esperar a sus hijos, irá acumulando
zombies. En algunos sistemas, puede evitarlo poniendo
L<C<$SIG{CHLD}>|perlvar/%SIG> a C<"IGNORE">. Ver también L<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 F</dev/null> si eso es un problema.

En algunas plataformas, como Windows, en donde la llamada del sistema
L<fork(2)> no está disponible, Perl se puede compilar para emular
L<C<fork>|/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
L<fork(2)> del "Unix". Sin embargo, tiene limitaciones que se tienen que
considerar en el código que pretenda ser portable. Vea L<perlfork> para más
detalles.

Cuestiones de portabilidad: L<perlport/fork>.

=item format
X<format>

=for Pod::Functions declare a picture format with use by the write() function

Declara una imagen del formato para usar con la función L<C<write>|/write
IDENTIFICADOR_ARCHIVO>. Por ejemplo:

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

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

Ver L<perlform> para más detalles y ejemplos.

=item formline DIBUJO,LISTA
X<formline>

=for Pod::Functions internal function used for formats

Esta es una función interna usada por L<C<format>|/format>, aunque usted
también puede llamarla. Formatea (vea L<perlform>) una lista de valores de
acuerdo a los contenidos de CUADRO, colocando la salida en el acumulador de
salida de format, L<C<$^A>|perlvar/$^A> (o C<$ACCUMULATOR> en L<English>).
Finalmente, cuando se hace un L<C<write>|/write IDENTIFICADOR_ARCHIVO>, los
contenidos de L<C<write>|/write IDENTIFICADOR_ARCHIVO> se escriben al
identificador de archivo. Puede también leer L<C<$^A>|perlvar/$^A> y volver a
ponerla otra vez a C<"">. Note que un formato típicamente hace un
L<C<formline>|/formline DIBUJO,LISTA> por línea del formato, pero a la misma
función L<C<formline>|/formline DIBUJO,LISTA> no le preocupa cuántos avances
de línea están incluidos en el CUADRO. Esto significa que los I<tokens> C<~>
y C<~~> 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 L<C<format>|/format>.

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

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

=item getc IDENTIFICADOR_ARCHIVO
X<getc> X<getchar> X<character> X<file, read> X<archivo, lectura> X<carácter>

=item getc

=for Pod::Functions get the next character from the filehandle

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 L<C<$!>|perlvar/$!>). 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 I<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 C<$BSD_STYLE> se deja como ejercicio al
lector.

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

=item getlogin
X<getlogin> X<login>

=for Pod::Functions return who logged in at this tty

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

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

No considere usar L<C<getlogin>|/getlogin> para autenticación: no es tan
seguro como L<C<getpwuid>|/getpwuid UID>.

Cuestiones de portabilidad: L<perlport/getlogin>.

=item getpeername SOCKET
X<getpeername> X<peer>

=for Pod::Functions find the other end of a socket connection

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);

=item getpgrp PID
X<getpgrp> X<group> X<grupo>

=for Pod::Functions get process group

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

Cuestiones de portabilidad: L<perlport/getpgrp>.

=item getppid
X<getppid> X<parent> X<pid> X<padre>

=for Pod::Functions get parent process ID

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 L<$$|perlvar/$$> para más
detalles.

Cuestiones de portabilidad: L<perlport/getppid>.

=item getpriority CUÁL,QUIÉN
X<getpriority> X<priority> X<nice> X<prioridad>

=for Pod::Functions get current nice value

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

Cuestiones de portabilidad: L<perlport/getpriority>.

=item getpwnam NOMBRE
X<getpwnam> X<getgrnam> X<gethostbyname> X<getnetbyname> X<getprotobyname>
X<getpwuid> X<getgrgid> X<getservbyname> X<gethostbyaddr> X<getnetbyaddr>
X<getprotobynumber> X<getservbyport> X<getpwent> X<getgrent> X<gethostent>
X<getnetent> X<getprotoent> X<getservent> X<setpwent> X<setgrent> X<sethostent>
X<setnetent> X<setprotoent> X<setservent> X<endpwent> X<endgrent> X<endhostent>
X<endnetent> X<endprotoent> X<endservent>

=for Pod::Functions get passwd record given user login name

=item getgrnam NOMBRE

=for Pod::Functions get group record given group name

=item gethostbyname NOMBRE

=for Pod::Functions get host record given name

=item getnetbyname NOMBRE

=for Pod::Functions get networks record given name

=item getprotobyname NOMBRE

=for Pod::Functions get protocol record given name

=item getpwuid UID

=for Pod::Functions get passwd record given user ID

=item getgrgid GID

=for Pod::Functions get group record given group user ID

=item getservbyname NOMBRE,PROTOCOLO

=for Pod::Functions get services record given its name

=item gethostbyaddr DIRECCIÓN,TIPODIR

=for Pod::Functions get host record given its address

=item getnetbyaddr DIRECCIÓN,TIPODIR

=for Pod::Functions get network record given its address

=item getprotobynumber NÚMERO

=for Pod::Functions get protocol record numeric protocol

=item getservbyport PUERTO,PROTOCOLO

=for Pod::Functions get services record given numeric port

=item getpwent

=for Pod::Functions get next passwd record

=item getgrent

=for Pod::Functions get next group record

=item gethostent

=for Pod::Functions get next hosts record

=item getnetent

=for Pod::Functions get next networks record

=item getprotoent

=for Pod::Functions get next protocols record

=item getservent

=for Pod::Functions get next services record

=item setpwent

=for Pod::Functions prepare passwd file for use

=item setgrent

=for Pod::Functions prepare group file for use

=item sethostent SIGUEABIERTO

=for Pod::Functions prepare hosts file for use

=item setnetent SIGUEABIERTO

=for Pod::Functions prepare networks file for use

=item setprotoent SIGUEABIERTO

=for Pod::Functions prepare protocols file for use

=item setservent SIGUEABIERTO

=for Pod::Functions prepare services file for use

=item endpwent

=for Pod::Functions be done using passwd file

=item endgrent

=for Pod::Functions be done using group file

=item endhostent

=for Pod::Functions be done using hosts file

=item endnetent

=for Pod::Functions be done using networks file

=item endprotoent

=for Pod::Functions be done using protocols file

=item endservent

=for Pod::Functions be done using services file

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 L<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 I<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 L<getpwnam(3)> y su archivo del
sistema F<pwd.h>. Puede también encontrar, dentro de Perl, que es lo que
significan sus campos $cuota, $comentario y $expira usando el módulo
L<C<Config>|Config> y los valores C<d_pwquota>, C<d_pwage>, C<d_pwchange>,
C<d_pwcomment> y C<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 L<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 I<getgr*()> es una lista separada por
espacios de los nombres de login de los miembros del grupo.

Para las funciones I<gethost*()>, si la variable C<h_errno> se soporta en C, se
devolverá vía L<C<$?>|perlvar/$?> si la llamada a la función falla. El valor
devuelto C<@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 L<C<gethostbyname>|/gethostbyname NOMBRE> en
contexto ESCALAR y compruebe que se ha definido su valor de retorno.

La función L<C<getprotobynumber>|/getprotobynumber NÚMERO>, 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:
L<C<File::stat>|File::stat>, L<C<Net::hostent>|Net::hostent>,
L<C<Net::netent>|Net::netent>, L<C<Net::protoent>|Net::protoent>,
L<C<Net::servent>|Net::servent>, L<C<Time::gmtime>|Time::gmtime>,
L<C<Time::localtime>|Time::localtime> y L<C<User::grent>|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
C<File::stat> es diferente de un objeto C<User::pwent>.

Cuestiones de portabilidad: L<perlport/getpwnam> a L<perlport/endservent>.

=item getsockname SOCKET
X<getsockname>

=for Pod::Functions retrieve the sockaddr for a given 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);

=item getsockopt SOCKET,NIVEL,OPCIÓN
X<getsockopt>

=for Pod::Functions get socket options on a given socket

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 I<socket>, pero al menos existirá el más alto nivel de I<socket>
SOL_SOCKET (definido en el módulo L<C<Socket>|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 L<C<getprotobyname>|/getprotobyname
NOMBRE>.

La llamada devuelve una cadena empaquetada representando la opción I<socket>
solicitada, o L<C<undef>|/undef EXPR> si hay un error, con la razón del error
establecida en L<C<$!>|perlvar/$!>. Lo que exista exactamente en la cadena
empaquetada depende de NIVEL y OPCIÓN; consulte L<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
L<C<unpack>|/unpack PLANTILLA,EXPR> con el formato C<i> (o C<I>).

Aquí hay un ejemplo para comprobar si el algoritmo de Nagle está habilitado
en un I<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: L<perlport/getsockopt>.

=item glob EXPR
X<glob> X<wildcard> X<filename, expansion> X<expand> X<archivo, expansión> X<comodín> X<expandir>

=item glob

=for Pod::Functions expand filenames using wildcards

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 F</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<< <*.c> >>, pero puede usarla
directamente. Si se omite EXPR, se usa L<C<$_>|perlvar/$_>. El operador C<<
<*.c> >> se explica con más detalle en L<perlop/"Operadores E/S">.

Tenga en cuenta que L<C<glob>|/glob EXPR> divide sus argumentos por los
espacios en blanco y trata a cada segmento como patrones independientes. En
este sentido, C<glob("*.c *.h")> coincide con todos los archivos con una
extensión F<.c> o F<.h>. La expresión C<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 C<e>, seguida por un
espacio, seguido por una C<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 L<C<glob>|/glob EXPR> 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 C<File::Glob>. Ver
L<File::Glob> para los detalles, incluyendo
L<C<bsd_glob>|File::Glob/C<bsd_glob>> que no trata al espacio en blanco como
separador de patrones.

Cuestiones de portabilidad: L<perlport/glob>.

=item gmtime EXPR
X<gmtime> X<UTC> X<Greenwich>

=item gmtime

=for Pod::Functions convert UNIX time into record or string using Greenwich time

Funciona igual que L<C<localtime>|/localtime EXPR> 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 C<0>. No hay horario de verano en el horario GMT.

Cuestiones de portabilidad: L<perlport/gmtime>.

=item goto ETIQUETA
X<goto> X<jump> X<jmp>

=item goto EXPR

=item goto &NOMBRE

=for Pod::Functions create spaghetti code

La forma C<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 L<C<sort>|/sort NOMBRE_SUB LISTA>. 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 L<C<last>|/last ETIQUETA> o L<C<die>|/die LISTA>. El autor
de Perl nunca ha tenido la necesidad de usar esta forma de L<C<goto>|/goto
ETIQUETA> (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 L<C<goto>|/goto
ETIQUETA> en otros lenguajes).

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

Si la expresión evalúa a un nombre de etiqueta, su ámbito se resolverá
dinámicamente. Esto permite crear L<C<goto>|/goto ETIQUETA> 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, C<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. C<goto("NE")."XT"> es equivalente a
C<goto NEXT>. También, a diferencia de otros operadores con nombre, este tiene
la misma precedencia que una asignación.

El uso de C<goto ETIQUETA> o C<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 C<foreach>. Tampoco se puede usar para ir a una construcción que se ha
optimizado.

La forma C<goto &NOMBRE> es muy diferente de las otras formas de
L<C<goto>|/goto ETIQUETA>. 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 L<C<local>|/local EXPR>) e
inmediatamente llama a la subrutina indicada pasándole el valor actual de
L<C<@_>|perlvar/@_>. Esto se usa en subrutinas C<AUTOLOAD()> que desean cargar
otra subrutina y fingen que ésta otra subrutina se ha llamado en primer lugar
(excepto que cualquier modificación L<C<@_>|perlvar/@_> en la subrutina actual
se propaga a la otra). Después del L<C<goto>|/goto ETIQUETA>, ni siquiera
L<C<caller>|/caller EXPR> 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.

=item grep BLOQUE LISTA
X<grep>

=item grep EXPR,LISTA

=for Pod::Functions locate elements in a list test true against a given criterion

Es similar en espíritu, pero no es lo mismo, que con L<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
L<C<$_>|perlvar/$_> 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 L<C<$_>|perlvar/$_> 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 C<foreach>, L<C<map>|/map BLOQUE LISTA> u otro L<C<grep>|/grep BLOQUE
LISTA>) realmente modifica el elemento en la lista original. Esto es algo
usualmente a evitarse cuando se está escribiendo código claro.

Vea también L<C<map>|/map BLOQUE LISTA> para ver una lista compuesta de los
resultados del BLOQUE o EXPR.

=item hex EXPR
X<hex> X<hexadecimal>

=item hex

=for Pod::Functions convert a hexadecimal string to a number

Interpreta EXPR como una cadena en hexadecimal y devuelve el valor numérico
correspondiente. Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

    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
C<0x> o C<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 L<C<oct>|/oct EXPR>). Solo se pueden representar
enteros, y un desborde de enteros disparará una advertencia.

Para convertir cadenas que podrían comenzar con C<0>, C<0x> o C<0b>, vea
L<C<oct>|/oct EXPR>). Para presentar algo en formato hexadecimal, mire en
L<C<printf>|/printf IDENTIFICADOR_ARCHIVO FORMATO, LISTA>,
L<C<sprintf>|/sprintf FORMATO, LISTA>, y L<C<unpack>|/unpack PLANTILLA,EXPR>.

=item import LISTA
X<import>

=for Pod::Functions patch a module's namespace into your own

No existe la función predefinida L<C<import>|/import LISTA>. 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 L<C<use>|/use Módulo VERSIÓN
LISTA> llama al método L<C<import>|/import LISTA> del paquete a usar. Ver
también L<C<use>|/use Módulo VERSIÓN LISTA>, L<perlmod> y L<Exporter>.

=item index CADENA,SUBCADENA,POSICIÓN
X<index> X<indexOf> X<InStr>

=item index CADENA,SUBCADENA

=for Pod::Functions find a substring within a string

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, L<C<index>|/index CADENA,SUBCADENA,POSICIÓN> devuelve -1.

=item int EXPR
X<int> X<integer> X<truncate> X<trunc> X<floor> X<truncar> X<trunca> X<entero>

=item int

=for Pod::Functions get the integer portion of a number

Devuelve la parte entera de EXPR. Si se omite EXPR, usa L<C<$_>|perlvar/$_>. No
debe usar esta función para redondear: primero, porque trunca hacia C<0> y
segundo, porque las representaciones máquina de números en punto flotante
puede producir, algunas veces, resultados dispares. Por ejemplo,
C<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 L<C<sprintf>|/sprintf FORMATO, LISTA>, L<C<printf>|/printf
IDENTIFICADOR_ARCHIVO FORMATO, LISTA>, o las L<C<POSIX::floor>|POSIX/C<floor>>
y L<C<POSIX::ceil>|POSIX/C<ceil>> le serviran mejor que L<C<int>|/int EXPR>.

=item ioctl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR
X<ioctl>

=for Pod::Functions system-dependent device control system call

Implementa la función L<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 F<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 F<< <sys/ioctl.h>
>>. (Existe un script Perl llamado B<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 L<C<ioctl>|/ioctl
IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>.  (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 C<0> al escalar antes de usarlo). Las funciones L<C<pack>|/pack
PLANTILLA,LISTA> y L<C<unpack>|/unpack PLANTILLA,EXPR> pueden ser necesarias
para manipular los valores de las estructuras utilizadas por L<C<ioctl>|/ioctl
IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>.

El valor devuelto de L<C<ioctl>|/ioctl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>
(y L<C<fcntl>|/fcntl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>) 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 C<"0 but true"> (0, pero verdadero) es una excepción de que
el L<C<Argumento "..." no es numérico>|perldiag/Argument "%s" isn't numeric%s>
en conversiones numéricas impropias.

Cuestiones de portabilidad: L<perlport/ioctl>.

=item join EXPR,LISTA
X<join>

=for Pod::Functions join a list into a string using a separator

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 L<C<split>|/split
E<sol>PATRÓNE<sol>,EXPR,LÍMITE>, L<C<join>|/join EXPR,LISTA> no toma un
patrón como su primer argumento. Busque las diferencias con L<C<split>|/split
E<sol>PATRÓNE<sol>,EXPR,LÍMITE>.

=item keys HASH
X<keys> X<key> X<clave>

=item keys ARRAY

=for Pod::Functions retrieve list of indices from a hash

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 L<C<each>|/each
HASH> o L<C<keys>|/keys HASH> se puede borrar sin que cambie el orden. Siempre
y cuando no se modifique un determinado hash puede confiar en que
L<C<keys>|/keys HASH>, L<C<values>|/values HASH> y L<C<each>|/each HASH>
devuelven repetidamente lo mismo en el mismo orden. Vea L<perlsec/"Ataques de
complejidad algorítmica"> 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 L<C<keys>|/keys HASH> reinicia el iterador
interno del HASH o del ARRAY (vea L<C<each>|/each HASH>). De forma particular,
llamando a L<C<keys>|/keys HASH> 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 L<C<values>|/values
HASH>.

Para ordenar un hash por valor, necesitará usar la función L<C<sort>|/sort
NOMBRE_SUB LISTA>. 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, L<C<keys>|/keys HASH> 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 C<%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 C<%hash = ()>. Use C<undef
%hash> si quiere liberar el almacenamiento mientras mantiene a C<%hash> en el
ámbito. No puede reducir el número de casillas reservadas para el hash usando
L<C<keys>|/keys HASH> de esta manera (pero no necesita preocuparse si hace esto
por accidente; intentarlo no tiene ningún efecto). C<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 L<C<keys>|/keys
HASH> 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
I<sólo> en versiones Perl de cosechas recientes:

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

Vea también L<C<each>|/each HASH>, L<C<values>|/values HASH> y L<C<sort>|/sort
NOMBRE_SUB LISTA>.

=item kill SEÑAL, LISTA

=item kill SEÑAL
X<kill> X<signal> X<señal>

=for Pod::Functions send a signal to a process or process group

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 C<SIG>, así que C<FOO> y C<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 C<$Config{sig_name}>, ofrecida por el módulo
L<C<Config>|Config>. Vea L<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, C<kill '-KILL',
$pgrp> y C<kill -9, $pgrp> enviará C<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 C<ZERO> (o C<SIGZERO>), no se envía ninguna
señal al proceso, pero L<C<kill>|/kill SEÑAL, LISTA> comprueba si es
I<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 L<perlport> para notas sobre la
portabilidad de esta construcción.

El comportamiento de kill cuando el I<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 L<perlipc/"Señales"> para más detalles.

En algunas plataformas, como en Windows, en donde la llamada del sistema
L<fork(2)> no está disponible, Perl se puede compilar para emular
L<C<fork>|/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 L<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 L<perlsec/Aclarado y
detección de datos contaminados>.

Cuestiones de portabilidad: L<perlport/kill>.

=item last ETIQUETA
X<last> X<break>

=item last EXPR

=item last

=for Pod::Functions exit a block prematurely

El comando L<C<last>|/last ETIQUETA> es como la instrucción C<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 C<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
C<last ETIQUETA>. El bloque L<C<continue>|/continue BLOQUE>, si está, no se
ejecuta:

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

L<C<last>|/last ETIQUETA> no se puede usar para salir de un bloque que devuelve
un valor como en C<eval {}>, C<sub {}> o C<do {}>, y no debería usarse para
salir de una operación L<C<grep>|/grep BLOQUE LISTA> o L<C<map>|/map BLOQUE
LISTA>.

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

Ver también L<C<continue>|/continue BLOQUE> para una ilustración de cómo
funcionan L<C<last>|/last ETIQUETA>, L<C<next>|/next ETIQUETA> y
L<C<redo>|/redo ETIQUETA>.

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 C<last ("foo")."bar"> hará que "bar" sea parte del argumento a
L<C<last>|/last ETIQUETA>.

=item lc EXPR
X<lc> X<lowercase> X<minúscula>

=item lc

=for Pod::Functions return lower-case version of a string

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

Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

Lo que se devuelve depende de varios factores:

=over

=item Si C<use bytes> está activo:

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

=item De lo contrario, si está activo C<use locale> para C<LC_CTYPE>:

Respeta la configuración regional C<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 L<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 C<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 L<locale|perldiag/Can't
do %s("%s") on non-UTF-8 locale; resolved to "%s".> (No puedo hacer ... en una
configuración regional que no es UTF-8; se resuelve a ...).

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

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

=item De otra forma, si C<use feature 'unicode_strings'> o C<use locale ':not_characters'> están habilitados:

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

=item 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.

=back

=item lcfirst EXPR
X<lcfirst> X<lowercase> X<minúscula>

=item lcfirst

=for Pod::Functions return a string with just the next letter in lower case

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

Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

Esta función se comporta de la misma manera bajo varios I<pragmas>, como por
ejemplo en una configuración regional, como lo hace L<C<lc>|/lc EXPR>.

=item length EXPR
X<length> X<size> X<longitud> X<tamaño>

=item length

=for Pod::Functions return the number of characters in a string

Devuelve la longitud en I<caracteres> del valor de EXPR. Si se omite EXPR,
devuelve la longitud de L<C<$_>|perlvar/$_>. Si EXPR es indefinido, devuelve
L<C<undef>|/undef EXPR>.

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

Al igual que todas las operaciones de caracteres de Perl, L<C<length>|/length
EXPR> 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
C<length(Encode::encode_utf8(EXPR))> (tendrá que poner C<use Encode> primero).
Ver L<Encode> y L<perlunicode>.

=item __LINE__
X<__LINE__>

=for Pod::Functions the current source line number

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

=item link ARCHIVO_VIEJO,ARCHIVO_NUEVO
X<link>

=for Pod::Functions create a hard link in the filesystem

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: L<perlport/link>.

=item listen SOCKET,TAMAÑO_COLA
X<listen>

=for Pod::Functions register your socket as a server

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

=item local EXPR
X<local>

=for Pod::Functions create a temporary value for a global variable (dynamic scoping)

Lo que realmente querrá usar es L<C<my>|/my LISTAVAR>, debido a que
L<C<local>|/local EXPR> no es lo que la mayoría de la gente piensa de "local".
Vea L<perlsub/"Variables privadas con my()"> 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 L<perlsub/"Valores temporales con
local()"> para más detalles, incluidas las cuestiones relativas a arrays y
hash atados.

La construcción C<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
L<perlsub/"Eliminación local de elementos de tipos compuestos">.

=item localtime EXPR
X<localtime> X<ctime>

=item localtime

=for Pod::Functions convert UNIX time into record or string using local time

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.

C<$mdia> es el día del mes, y C<$mes> es el mes en el rango C<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"

C<$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);

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

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

Si se omite EXPR, L<C<localtime>|/localtime EXPR> utiliza la hora actual
(devuelta por L<C<time>|/time>).

En contexto escalar, L<C<localtime>|/localtime EXPR> devuelve el valor de
L<ctime(3)>:

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

El formato de este valor escalar B<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 L<C<gmtime>|/gmtime EXPR>. Vea también el
módulo L<C<Time::Local>|Time::Local> (para convertir los segundos, minutos,
horas, etc., de nuevo al valor entero devuelto por L<C<time>|/time>), y las
funciones L<C<strftime>|POSIX/C<strftime>> y L<C<mktime>|POSIX/C<mktime>> del
módulo L<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 L<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 C<%a> y C<%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 L<Time::gmtime> y L<Time::localtime> proporcionan mecanismos
convenientes de acceso por nombre para las funciones L<C<gmtime>|/gmtime EXPR>
y L<C<localtime>|/localtime EXPR>, respectivamente.

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

Cuestiones de portabilidad: L<perlport/localtime>.

=item lock COSA
X<lock>

=for Pod::Functions +5.005 get a thread lock on a variable, subroutine, or method

Esta función coloca un bloqueo sobre una variable compartida, o un objeto
referenciado contenido en I<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.

L<C<lock>|/lock COSA> 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 C<use threads::shared>, no
hará nada. Ver L<threads::shared>.

=item log EXPR
X<log> X<logarithm> X<e> X<ln> X<base> X<logaritmo>

=item log

=for Pod::Functions retrieve the natural logarithm for a number

Devuelve el logaritmo natural (base I<e>) de EXPR. Si se omite EXPR, devuelve
el logaritmo de L<C<$_>|perlvar/$_>. 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 L<C<exp>|/exp EXPR> para la operación inversa.

=item lstat IDENTIFICADOR_ARCHIVO
X<lstat>

=item lstat EXPR

=item lstat IDENTIFICADOR_DIR

=item lstat

=for Pod::Functions stat a symbolic link

Hace lo mismo que la función L<C<stat>|/stat IDENTIFICADOR_ARCHIVO>
(incluyendo el establecimiento del identificador de archivo especial C<_>) 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
L<C<stat>|/stat IDENTIFICADOR_ARCHIVO> normal. Para información más
detallada, por favor consulte la documentación de L<C<stat>|/stat
IDENTIFICADOR_ARCHIVO>.

Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

Cuestiones de portabilidad: L<perlport/lstat>.

=item m//

=for Pod::Functions match a string with a regular expression pattern

El operador de emparejamiento. See L<perlop/"Operadores I<Regex>">.

=item map BLOQUE LISTA
X<map>

=item map EXPR,LISTA

=for Pod::Functions apply a change to a list to get back a new list with the changes

Evalúa el BLOQUE o EXPR para cada elemento de LISTA (estableciendo localmente
L<C<$_>|perlvar/$_> 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 L<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 L<C<$_>|perlvar/$_> 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 C<foreach> normal para este propósito sería
más claro en la mayoría de los casos. Vea también L<C<grep>|/grep BLOQUE
LISTA> para un array compuesto por los elementos de la lista original en que el
BLOQUE o EXPR se evalúa como verdadero.

C<{> comienza tanto una referencia a hash como bloques, por lo que C<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 C<}>, tiene que hacer una
conjetura basándose en lo que encuentra justo después de C<{>. Por lo
general, lo hace bien, pero si no, no se dará cuenta de que algo anda mal
hasta que llega a la C<}> y se encuentra con la omisión de (o una inesperada)
coma. El error de sintaxis estará indicado cerca de C<}>, pero tendrá que
cambiar algo cerca de C<{>, como en el uso de un C<+> 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 C<+{>:

    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.

=item mkdir NOMBRE_ARCHIVO,MÁSCARA
X<mkdir> X<md> X<directory, create> X<directorio, crear>

=item mkdir ARCHIVO

=item mkdir

=for Pod::Functions create a directory

Crea el directorio especificado por el nombre de ARCHIVO, con permisos
especificados por la MÁSCARA (y modificada a su vez por L<C<umask>|/umask
EXPR>). Si tiene éxito devuelve verdadero; en caso contrario devuelve falso y
asigna L<C<$!>|perlvar/$!> (errno). MÁSCARA vale por defecto 0777, si no se
indica, y ARCHIVO es por defecto L<C<$_>|perlvar/$_>, 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 L<C<umask>|/umask EXPR> 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
L<C<umask>|/umask EXPR> 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
L<C<make_path>|File::Path/make_path( $dir1, $dir2, ... )> del módulo
L<File::Path>.

=item msgctl ID,CMD,ARG
X<msgctl>

=for Pod::Functions SysV IPC message control operations

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

    use IPC::SysV;

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

Cuestiones de portabilidad: L<perlport/msgctl>.

=item msgget CLAVE,INDICADORES
X<msgget>

=for Pod::Functions get SysV IPC message queue

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

Cuestiones de portabilidad: L<perlport/msgget>.

=item msgrcv ID,VAR,TAMAÑO,TIPO,INDICADORES
X<msgrcv>

=for Pod::Functions receive a SysV IPC message from a message queue

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 C<unpack("l! a*")>. Contamina
la variable. Devuelve verdadero si tuvo éxito, falso en caso de error. Vea
también L<perlipc/"SysV IPC"> y la documentación de L<C<IPC::SysV>|IPC::SysV>
y L<C<IPC::Msg>|IPC::Msg>.

Cuestiones de portabilidad: L<perlport/msgrcv>.

=item msgsnd ID,MSG,INDICADORES
X<msgsnd>

=for Pod::Functions send a SysV IPC message to a message queue

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 C<pack("l! a*",
$tipo, $mensaje)>. Devuelve verdadero si tuvo éxito, falso en caso de error.
Vea también L<perlipc/"SysV IPC"> y la documentación de
L<C<IPC::SysV>|IPC::SysV> y L<C<IPC::Msg>|IPC::Msg>.

Cuestiones de portabilidad: L<perlport/msgsnd>.

=item my LISTAVAR
X<my>

=item my TIPO VARLIST

=item my LISTAVAR : ATRIBUTOS

=item my TIPO LISTAVAR : ATRIBUTOS

=for Pod::Functions declare and assign a local variable (lexical scoping)

Un L<C<my>|/my LISTAVAR> declara las variables listadas como locales
(léxicamente) en el bloque, archivo, o L<C<eval>|/eval EXPR> 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 L<C<use
constant>|constant>, o L<C<__PACKAGE__>|/__PACKAGE__>. Está vinculado al uso
del pragma L<fields>, y los atributos se gestionan con el I<pragma>
L<attributes>, o a partir de Perl 5.8.0 también a través del módulo
L<Attribute::Handlers>. Ver L<perlsub/"Variables privadas con my()"> para más
detalles.

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

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

=item next ETIQUETA
X<next> X<continue>

=item next EXPR

=item next

=for Pod::Functions iterate a block prematurely

El comando L<C<next>|/next ETIQUETA> es como la instrucción C<continue> en C;
comienza la siguiente iteración del bucle:

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

Note que si hubiera un bloque L<C<continue>|/continue BLOQUE> 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 C<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
C<next ETIQUETA>.

L<C<next>|/next ETIQUETA> no se puede utilizar para salir de un bloque que
devuelve un valor, como en C<eval {}>, C<sub {}> o C<do {}>, y no se debe
utilizar para salir de una operación L<C<grep>|/grep BLOQUE LISTA> o
L<C<map>|/map BLOQUE LISTA>.

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

Ver también L<C<continue>|/continue BLOQUE> para una ilustración de cómo
funcionan L<C<last>|/last ETIQUETA>, L<C<next>|/next ETIQUETA> y
L<C<redo>|/redo ETIQUETA>.

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 C<next ("foo")."bar"> hará que "bar" sea parte del argumento a
L<C<next>|/next ETIQUETA>.

=item no Módulo VERSIÓN LISTA
X<no declarations> X<unimporting> X<declaraciones no> X<desimportando>

=item no MÓDULO VERSIÓN

=item no MÓDULO LISTA

=item no MÓDULO

=item no VERSIÓN

=for Pod::Functions unimport some module symbols or semantics at compile time

Vea la función L<C<use>|/use Módulo VERSIÓN LISTA>, y su opuesta L<C<no>|/no
Módulo VERSIÓN LISTA>.

=item oct EXPR
X<oct> X<octal> X<hex> X<hexadecimal> X<binary> X<bin> X<binario>

=item oct

=for Pod::Functions convert a string to an octal number

Interpreta EXPR como una cadena en octal y devuelve el valor correspondiente. 
(Si EXPR comienza con C<0x>, se interpreta como una cadena en hexadecimal. Si
EXPR empieza con C<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 L<C<$_>|perlvar/$_>.   Para hacer lo contrario (producir
un número en octal), use L<C<sprintf>|/sprintf FORMATO, LISTA> o
L<C<printf>|/printf IDENTIFICADOR_ARCHIVO FORMATO, LISTA>:

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

La función L<C<oct>|/oct EXPR> es de uso común cuando una cadena como C<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
(L<C<oct>|/oct EXPR> sólo gestiona números enteros no negativos, no enteros
negativos o en punto flotante).

=item open IDENTIFICADOR_ARCHIVO,EXPR
X<open> X<pipe> X<file, open> X<fopen> X<archivo, open>

=item open IDENTIFICADOR_ARCHIVO,MODO,EXPR

=item open IDENTIFICADOR_ARCHIVO,MODO,EXPR,LISTA

=item open IDENTIFICADOR_ARCHIVO,MODO,REFERENCIA

=item open IDENTIFICADOR_ARCHIVO

=for Pod::Functions open a file, pipe, or descriptor

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 L<C<open>|/open
IDENTIFICADOR_ARCHIVO,EXPR>: para una introducción más suave puede considerar
el leer L<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 C<use strict "refs"> I<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 C<< < >> o
nada, el archivo se abre para lectura. Si MODO es C<< > >>, 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 C<<< >> >>>, el archivo es abierto en modo añadir, y de nuevo, será
creado si es necesario.

Puede poner un C<+> en frente de C<< > >> o C<< < >> para indicar que desea
acceder al archivo tanto en lectura como en escritura; así, C<< +< >> casi
siempre es la forma preferida para la lectura/escritura de actualizaciones -el
modo C<< +> >> 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 B<-i> en
L<perlrun> para una mejor aproximación. El archivo se crea con permisos
C<0666> modificados por el valor de L<C<umask>|/umask EXPR> del proceso.

Estos prefijos se corresponden con los modos de la función L<fopen(3)> de
C<r>, C<r+>, C<w>, C<w+>, C<a> y C<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 C<< < >>. Siempre es más seguro utilizar el formato de dos argumentos
de L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> si el argumento con el nombre de
archivo es un literal bien visible.

Para tres o más argumentos, cuando MODO es C<|->, el nombre del archivo se
interpreta como un comando cuya salida va a ser entubada, y si MODO es C<-|>,
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 (C<->) por el comando. Ver L<perlipc/"Usando open() por IPC"> para más
ejemplos de sobre esto. (No se le permite hacer un L<C<open>|/open
IDENTIFICADOR_ARCHIVO,EXPR> a un comando que entube tanto en la entrada I<como>
en la salida, pero vea L<IPC::Open2>, L<IPC::Open3>, y L<perlipc/"Comunicación
bidireccional con otro proceso"> 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 L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> 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 C<< <- >> o C<->
abre STDIN, y abriendo C<< >- >> 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 L<open> y L<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
L<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 L<perlvar>; normalmente fijados por el I<pragma> L<open> o la
opción C<-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 L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> 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 L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA> 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 L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> se utiliza
con frecuencia con L<C<die>|/die LISTA>. Incluso si L<C<die>|/die LISTA> 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
L<C<my>|/my LISTAVAR>, 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 C<FH> como identificador de archivo, en C<< close FH >> y
C<< <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í, C<$ARTICULO> debe ser una variable escalar global (package), no
declarada con L<C<my>|/my LISTAVAR> o L<C<state>|/state LISTAVAR>.

Como un caso especial, la forma de tres argumentos con un modo de
lectura/escritura y el tercer argumento siendo L<C<undef>|/undef EXPR>:

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

abre un identificador de archivo a un archivo anónimo temporal. También,
usando C<< +< >> trabaja de forma simétrica, pero debe considerar, escribir
antes algo en el archivo temporal. Necesitará llamar a L<seek|/"seek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE"> antes de leer.

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

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

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

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

Ver L<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 C<< >& >>, 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 L<dup(2)>) y luego abierto. Puede usar
C<&> después de C<< > >>, C<<< >> >>>, C<< < >>, C<< +> >>, C<<< +>> >>>, y
C<< +< >>. 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 C<STDOUT> y C<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 C<< '<&=X' >>, donde C<X> es un número de descriptor de archivo
o un identificador de archivo, entonces Perl hará un equivalente de C de
L<fdopen(3)> de ese descriptor de archivo (y no llamar a L<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 L<C<flock>|/flock
IDENTIFICADOR_ARCHIVO,OPERACIÓN>. Si sólo hace C<< open(my $A, ">>&", $B) >>,
el identificador de archivo C<$A> no tendrá el mismo descriptor de archivo que
C<$B>, y por lo tanto C<flock($A)> no hará un C<flock($B)>, y viceversa. Pero
con C<< 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 L<fdopen(3)> para implementar la funcionalidad de
C<=>. En muchos sistemas Unix, L<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 C<perl
-V:useperlio>. Si dice C<'define'>, tiene PerlIO; de lo contrario, no.

Si abre una tubería en el comando C<-> (es decir, ya sea C<|-> o C<-|> con la
forma de uno o dos argumentos de L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR>),
entonces se crea un L<C<fork>|/fork> implícito, y L<C<open>|/open
IDENTIFICADOR_ARCHIVO,EXPR> regresa dos veces: en el proceso padre devuelve el
PID del proceso hijo, y el proceso hijo devuelve un (valor definido) C<0>. Use
C<defined($pid)> o C<//> 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
L<C<fork>|/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 L<perlipc/"Aperturas seguras de tuberías"> 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 L<perlport>). Para estar seguros, puede
necesitar establecer L<C<$E<verbar>>|perlvar/$E<verbar>> ($AUTOFLUSH en el
módulo L<English>) o llamar el método C<autoflush> de
L<C<IO::Handle>|IO::Handle/METHODS> en cualquiera de los identificadores de
archivo abiertos para evitar la pérdida de datos en la salida.

En sistemas que soportan el indicador B<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
L<C<$^F>|perlvar/$^F>. Ver L<perlvar/$^F>.

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

Al nombre del archivo pasado a las formas de uno y dos argumentos de
L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> 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 F<"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 I<magia> y la forma de I<tres argumentos> de
L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR>:

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

permitirá al usuario especificar un argumento de la forma C<"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 C<< 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" L<open(2)> como en C, entonces debe usar la función
L<C<sysopen>|/sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO>, que no
incluye ninguna magia (pero puede utilizar, sutilmente, diferentes modos de
acceso a archivos que con el L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> de
Perl, que se corresponde a la función del C L<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 L<C<seek>|/seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> para más detalles
acerca de mezclar lectura y escritura.

Cuestiones de portabilidad: L<perlport/open>.

=item opendir IDENTIFICADOR_DIR,EXPR
X<opendir>

=for Pod::Functions open a directory

Abre un directorio llamado EXPR para procesarse por L<C<readdir>|/readdir
IDENTIFICADOR_DIR>, L<C<telldir>|/telldir IDENTIFICADOR_DIR>,
L<C<seekdir>|/seekdir IDENTIFICADOR_DIR,POSICIÓN>, L<C<rewinddir>|/rewinddir
IDENTIFICADOR_DIR>, y L<C<closedir>|/closedir IDENTIFICADOR_DIR>. 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 L<C<readdir>|/readdir IDENTIFICADOR_DIR>.

=item ord EXPR
X<ord> X<encoding> X<codificación>

=item ord

=for Pod::Functions find a character's numeric representation

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 L<C<$_>|perlvar/$_>. (Note que es un
I<carácter>, no un byte).

Para lo contrario, vea L<C<chr>|/chr NÚMERO>. Vea L<perlunicode> para más
información acerca de Unicode.

=item our LISTAVAR
X<our> X<global>

=item our TIPO VARLIST

=item our LISTAVAR : ATRIBUTOS

=item our TIPO LISTAVAR : ATRIBUTOS

=for Pod::Functions +5.6.0 declare and assign a package variable (lexical scoping)

L<C<our>|/our LISTAVAR> 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.

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

Esto significa que cuando C<use strict 'vars'> está activo, L<C<our>|/our
LISTAVAR> 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 L<C<our>|/our
LISTAVAR>. 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 C<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 L<C<our>|/our LISTAVAR> 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 L<C<our>|/our LISTAVAR> 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 L<C<my>|/my LISTAVAR>. A
diferencia de una segunda declaración de L<C<my>|/my LISTAVAR>, que unirá el
nombre a una nueva variable, una segunda declaración de L<C<our>|/our
LISTAVAR> 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 L<C<our>|/our LISTAVAR> 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 I<<pragma> L<fields>, y los atributos se
gestionan con el I<pragma> L<attributes>, o a partir de Perl 5.8.0 también a
través del módulo L<Attribute::Handlers>. Ver L<perlsub/"Variables privadas
con my()"> para más detalles.

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

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

L<C<our>|/our LISTAVAR> difiere de L<C<use vars>|vars>, que permite usar un
nombre no calificado I<solo> dentro del paquete afectado, pero sí en diversos
ámbitos.

=item pack PLANTILLA,LISTA
X<pack>

=for Pod::Functions convert a list into a binary representation

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 L<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 C<< > >> y C<< < >> también se pueden utilizar en los grupos
C<()> para obligar a un orden particular de bytes en todos los componentes de
ese grupo, que incluye todos sus subgrupos.

=begin comment

Larry recuerda que los formatos de cadena hex y bit (H, h, B, b) se añadieron
para empaquetar el procesamiento de datos de la sonda Magallanes de la NASA.
Magallanes estaba en una órbita elíptica, utilizando la antena para el mapeo
de radar cuándo se acercaba a Venus y para comunicarse con la Tierra en el
resto de la órbita. Había dos unidades de transmisión, pero uno de estos
falló, y luego el otro desarrolló un error por el cual, aleatoriamente
cambiaba el sentido de todos los bits. Fue fácil detectar automáticamente
registros completos con el sentido correcto, y completar registros con todos
los bits cambiados. Aun así, esto no recuperó los registros donde el sentido
cambiaba a la mitad. Un colega de Larry fue capaz de darse cuenta donde los
registros cambiaban, así que escribieron un editor llamado kybble (una broma
sobre la comida de perro Kibbles 'n Bits) para ayudarle corregir a mano los
registros y recuperar los datos. Fue para este propósito por el que pack tiene
los especificadores de formato de cadena hex y bit.

git muestra que fueron añadidos a perl 3.0 en el parche #44 (enero 1991,
envío 27e2fb84680b9cc1), pero la descripción del parche no hace ninguna
mención de su adición, olvidando la historia que hubo detrás de ellos.

=end comment

Se aplica las siguientes reglas:

=over

=item *

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 C<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 C<a>, C<A>, C<Z>, C<b>, C<B>, C<h>, C<H>, C<@>,
C<.>, C<x>, C<X> y C<P>, donde significa otra cosa, descrita abajo. El
suministro de un C<*> para el número de repeticiones en lugar de un número
significa usar tantos elementos como queden, a excepción de:

=over

=item *

C<@>, C<x> y C<X>, donde es equivalente a C<0>.

=item *

C<.>, donde significa relativo al inicio de la cadena.

=item *

C<u>, donde es equivalente a 1 (o 45, que aquí es equivalente).

=back

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 C<x[L]> salta tantos bytes como en un largo
empaquetado, y la plantilla C<"$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 C<x![d]>), su longitud se
calculará como si el comienzo de la plantilla tuviera la máxima alineación
posible.

Cuando se utiliza con C<Z>, un C<*> 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 C<@>, el número de repeticiones representa un
desplazamiento desde el inicio del grupo C<()> más interior.

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

=over

=item *

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

=item *

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

=item *

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

=back

El número de repeticiones para C<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.

=item *

Los tipos C<a>, C<A>, y C<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, C<A> elimina el espacio en blanco y nulos
sobrantes del final, C<Z> elimina todo después del primer nulo, y C<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, C<Z> empaqueta solo
C<$contador-1> bytes, seguido por un byte nulo. Por lo tanto C<Z> siempre
empaqueta un valor nulo adicional, excepto cuando el contador es 0.

=item *

Del mismo modo, los formatos C<b> y C<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 C<B8> o C<B64>.

Cada bit resultante se basa en el bit menos significativo del correspondiente
carácter de la entrada, es decir, en C<ord($carácter)%2>. En particular, los
caracteres C<"0"> y C<"1"> generan los bits 0 y 1, al igual que los caracteres
C<"\000"> y C<"\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 C<b>, el primer
carácter de la 8-tupla determina el bit menos significativo de un carácter;
con el formato C<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 C<*> como contador de repetición utiliza todos los caracteres del campo de
entrada. Al desempaquetar, los bits se convierten a una cadena de C<0> y C<1>.

=item *

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

Para cada formato así, L<C<pack>|/pack PLANTILLA,LISTA> 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
C<ord($carácter)%16>. En particular, los caracteres C<"0"> y C<"1"> generan
los nibles 0 y 1, así como los bytes C<"\000"> y C<"\001">. Para los
caracteres C<"a".."f"> y C<"A".."F">, el resultado es compatible con los
dígitos hexadecimales acostumbrados, de modo que C<"a"> y C<"A"> generan ambos
el nible C<0xA==10>. Utilice sólo estos caracteres hexadecimales con este
formato.

A partir del comienzo de la plantilla a L<C<pack>|/pack PLANTILLA,LISTA>, cada
par de caracteres se convierte en un carácter en la salida. Con el formato
C<h>, el primer carácter del par determina el nible menos significativo de la
salida de caracteres; con el formato C<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 C<*> como contador de repetición utiliza todos los caracteres del campo de
entrada. Para L<C<unpack>|/unpack PLANTILLA,EXPR>, los I<nibles> se convierten
en una cadena de dígitos hexadecimales.

=item *

El formato C<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
C<P> empaqueta un puntero a una estructura del tamaño indicado por la
longitud. Un puntero nulo se crea si el valor correspondiente para C<p> o C<P>
es L<C<undef>|/undef EXPR>; de forma similar con L<C<unpack>|/unpack
PLANTILLA,EXPR>, donde un puntero nulo se desempaqueta en L<C<undef>|/undef
EXPR>.

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.

=item *

La plantilla C</> 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 L<C<pack>|/pack PLANTILLA,LISTA>, escriba
I<longitud-item>C</>I<secuencia-item>, y la I<longitud-item> indica el valor de
la longitud de lo que está empaquetado. Formatos de mayor uso son los
empaquetados de enteros como el C<n> para las cadenas de Java, C<w> de ASN.1 o
SNMP, y C<N> de XDR de Sun

Para L<C<pack>|/pack PLANTILLA,LISTA>, I<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 I<longitud-ítem>. Si no
tiene contador de repeticiones o utiliza un '*', se utiliza el número de
elementos disponibles.

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

Si I<secuencia-item> se refiere a un tipo de cadena de caracteres (C<"A">,
C<"a">, o C<"Z">), la I<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 I<longitud-item> no se devuelve de forma explícita desde
L<C<unpack>|/unpack PLANTILLA,EXPR>.

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

=item *

Los tipos enteros C<s>, C<S>, C<l>, y C<L> pueden ser seguidos por un modificar
C<!> para especificar un corto (short) o largo (long) nativos. Como se muestra
en el ejemplo anterior, una simple C<l> significa exactamente 32 bits, aunque
el C<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 C<!> 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!");


C<i!> y C<I!> también están permitidos, pero solo a efectos de completar: son
idénticos a C<i> y C<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 L<C<Config>|Config>:

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

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

=item *

Los formatos enteros C<s>, C<S>, C<i>, C<I>, C<l>, C<L>, C<j>, y C<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
I<little-endian>, pero SGI/Cray los usa en modo I<big-endian>.

Los nombres I<big-endian> y I<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, I<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 L<Config>:

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

o desde la línea de comandos:

    $ perl -V:byteorder

Las ordenaciones C<"1234"> y C<"12345678"> son little-endian; C<"4321"> y
C<"87654321"> son big-endian. Sistemas con binarios multiarquitectura serán
C<"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 C<n>,
C<N>, C<v>, y C<V> o bien los modificadores C<< > >> y C<< < >> descritos a
continuación. Vea también L<perlport>.

=item *

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 C<Config>, C<doublekind> y
C<longdblkind> (también C<doublesize>, C<longdblsize>): la "clase" de valores
se enumeran, a diferencia de C<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 C<"%a">) de L<C<printf>|/printf
IDENTIFICADOR_ARCHIVO FORMATO, LISTA>.

=item *

A partir de Perl 5.10.0, los formatos de enteros y de punto flotante, junto con
los formatos C<p> y C<P> y los grupos C<()>, se podrán continuar con los
modificadores de ordenación de bytes C<< > >> o C<< < >>, para forzar,
respectivamente, el orden de bytes I<big-endian> o I<little-endian>. Estos
modificadores son especialmente útiles dado que C<n>, C<N>, C<v> y C<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:

=over

=item *

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.

=item *

Los modificadores C<< > >> o C<< < >> 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.

=item *

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 C<< > >> o C<< < >> 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.

=item *

Cuando se usa C<< > >> o C<< < >> en un grupo C<()>, 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.

=back

=item *

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 L<perlport>.

Si sabe I<exactamente> lo que está haciendo, puede usar los modificadores C<<
> >> o C<< < >> 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 C<unpack("f",
pack("f", $foo)>) no será, generalmente, igual a $foo.

=item *

pack y unpack pueden funcionar de dos modos: modo de caracteres (modo C<C0>)
donde la cadena empaquetada se procesa por cada carácter, y el modo byte UTF-8
(modo C<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 C<U>. Siempre puede cambiar de modo con un
explícito C<C0> o C<U0> en mitad del formato. Este modo permanece activo hasta
el cambio del modo siguiente, o hasta el final del grupo C<()> en que se
aplicó directamente.

Usar C<C0> para obtener los caracteres Unicode mientras se utiliza C<U0> para
obtener bytes I<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 L<C<pack>|/pack
PLANTILLA,LISTA>/L<C<unpack>|/unpack PLANTILLA,EXPR> como un sustituto del
módulo L<Encode>.

=item *

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

=item *

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

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

es la cadena C<"\0X\0\0YZ">.

=item *

C<x> y C<X> aceptan el modificar C<!> 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 C<contador> caracteres. Por ejemplo, para L<C<pack>|/pack
PLANTILLA,LISTA> o L<C<unpack>|/unpack PLANTILLA,EXPR> 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<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 C<contador> de 0 es equivalente a un
C<contador> de 1; ambos son instrucciones no efectivas.

=item *

C<n>, C<N>, C<v> y C<V> aceptan el modificador C<!> 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.

=item *

Los comentarios pueden integrarse en una PLANTILLA usando C<#> 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 C</x> lo es para las
expresiones regulares complicadas.

=item *

Si PLANTILLA requiere más argumentos de los que se pasan a L<C<pack>|/pack
PLANTILLA,LISTA>, éste asume que los argumentos adicionales son iguales a
C<"">. Si PLANTILLA requiere menos argumentos de los que se le dan, los
argumentos adicionales se ignoran.

=item *

Intentar empaquetar los valores especiales de punto flotante C<Inf> y C<NaN>
(infinito, también en negativo), y no-es-un-número) en valores enteros
empaquetados (como C<"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.

=back

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 L<C<unpack>|/unpack
PLANTILLA,EXPR>.

=item package ESPACIO_NOMBRES

=item package ESPACIO_NOMBRES VERSIÓN
X<package> X<module> X<namespace> X<version>
X<paquete> X<módulo> X<espacio de nombres> X<versión>

=item package ESPACIO_NOMBRES BLOQUE

=item package ESPACIO_NOMBRES VERSIÓN BLOQUE
X<package> X<module> X<namespace> X<version>
X<paquete> X<módulo> X<espacio de nombres> X<versión>

=for Pod::Functions declare a separate global namespace

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
L<C<eval>|/eval EXPR> que lo engloba). Es decir, las formas sin un BLOQUE son
operativas hasta el final del ámbito actual, al igual que los operadores
L<C<my>|/my LISTAVAR>, L<C<state>|/state LISTAVAR> y L<C<our>|/our LISTAVAR>.
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 L<C<package>|/package ESPACIO_NOMBRES> o cuando sean uno de
los identificadores especiales que califican dentro de C<main::>, al igual que
C<STDOUT>, C<ARGV>, C<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 L<C<local>|/local EXPR>, pero I<no> a las variables de
ámbito léxico, que se crean con L<C<my>|/my LISTAVAR>, L<C<state>|/state
LISTAVAR> o L<C<our>|/our LISTAVAR>. Normalmente será la primera declaración
en un archivo incluido por medio de un L<C<require>|/require VERSIÓN> o
L<C<use>|/use Módulo VERSIÓN LISTA>. 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 C<$AlgunPaquete::var> o C<EstePaquete::CONTROLADOR_ENTRADA>. Si el
nombre del paquete se omite, se asume que es C<main>. Es decir, C<$::sail> es
equivalente a C<$main::sail> (y también a C<$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, L<C<package>|/package ESPACIO_NOMBRES> inicializa la
variable C<$VERSION> en el espacio de nombres indicado a un objeto L<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 L<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 C<$VERSION> solo una vez por
paquete.

Ver L<perlmod/"Paquetes"> para más información sobre paquetes, módulos y
clases. Ver L<perlsub> para otras cuestiones sobre el ámbito o contexto.

=item __PACKAGE__
X<__PACKAGE__>

=for Pod::Functions +5.004 the current package

Un I<token> especial que devuelve el nombre del paquete en el que aparece.

=item pipe IDENTIFICADOR_LECTURA,IDENTIFICADOR_ESCRITURA
X<pipe> X<tubería>

=for Pod::Functions open a pair of connected filehandles

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 L<C<$E<verbar>>|perlvar/$E<verbar>> para limpiar
su IDENTIFICADOR_ESCRITURA después de cada comando, dependiendo de la
aplicación.

Devuelve verdadero en caso de éxito.

Ver L<IPC::Open2>, L<IPC::Open3>, y L<perlipc/"Comunicación Bidireccional con
otro proceso"> 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 L<C<fileno>|/fileno IDENTIFICADOR_ARCHIVO> sean más
I<altos> que el valor actual de L<C<$^F>|perlvar/$^F> (por defecto 2 para
C<STDERR>). Ver L<perlvar/$^F>.

=item pop ARRAY
X<pop> X<stack> X<pila>

=item pop

=for Pod::Functions remove the last element from an array and return it

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
L<C<@ARGV>|perlvar/@ARGV> en el programa principal, y del array
L<C<@_>|perlvar/@_> en subrutinas, igual que L<C<shift>|/shift ARRAY>.

A partir de 5.14, una característica experimental permitía a L<C<pop>|/pop
ARRAY> tomar una expresión escalar. Se ha considerado que este experimento no
ha funcionado, y se quitó a partir de Perl 5.24.

=item pos ESCALAR
X<pos> X<match, position> X<coincidencia, posición>

=item pos

=for Pod::Functions find or set the offset for the last/next m//g search

Devuelve el desplazamiento desde donde la última búsqueda C<m//g> terminó
para la variable en cuestión (L<C<$_>|perlvar/$_> 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. L<C<undef>|/undef EXPR> 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).

L<C<pos>|/pos ESCALAR> accede directamente a la ubicación utilizada por el
motor de expresiones regulares para almacenar el desplazamiento, por lo que
asignar a L<C<pos>|/pos ESCALAR> cambiará ese desplazamiento, por lo que
también influirá en la aserción de ancho cero C<\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 L<C<pos>|/pos ESCALAR> durante la
coincidencia actual, como en C<(?{pos() = 5})> o C<s//pos() = 5/e>.

Actualizando L<C<pos>|/pos ESCALAR> también reinicializa el indicador que
I<coincide-con-longitud-cero>, descrita en L<perlre/"Coincidiendo con patrones
repetidos en una cadena de longitud cero">.

Debido a que una coincidencia C<m//gc> fallida no reinicia el desplazamiento,
el retorno de L<C<pos>|/pos ESCALAR> no cambiará en ningún caso. Vea
L<perlre> y L<perlop>.

=item print IDENTIFICADOR_ARCHIVO LISTA
X<print>

=item print IDENTIFICADOR_ARCHIVO

=item print LISTA

=item print

=for Pod::Functions output a list to a filehandle

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
I<token> es un término, se puede malinterpretar como un operador a menos que
interponga un C<+> o ponga los argumentos entre paréntesis). Si se omite
IDENTIFICADOR_ARCHIVO, se imprime al canal de salida seleccionado por última
vez (vea L<C<select>|/select IDENTIFICADOR_ARCHIVO>). Si la LISTA se omite, se
imprime L<C<$_>|perlvar/$_> al actual canal de salida seleccionado. Para
utilizar solamente IDENTIFICADOR_ARCHIVO para imprimir en él el contenido de
L<C<$_>|perlvar/$_>, debe ser un identificador de archivo real, como C<FH>, no
uno indirecto como C<$fh>. Para configurar el controlador de salida
predeterminado a otro valor distinto que STDOUT, use el operador C<select>.

El valor actual de L<C<$,>|perlvar/$,> (si lo tiene) es impreso entre cada
elemento de la LISTA. El valor actual de L<C<$\>|perlvar/$\> (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 C<+>, 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
L<perlipc> para más información sobre el manejo de señales.

=item printf IDENTIFICADOR_ARCHIVO FORMATO, LISTA
X<printf>

=item printf IDENTIFICADOR_ARCHIVO

=item printf FORMATO, LISTA

=item printf

=for Pod::Functions output a formatted list to a filehandle

Equivalente a C<print IDENTIFICADOR_ARCHIVO sprintf(FORMATO, LISTA)>, excepto
que L<C<$\>|perlvar/$\> (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 L<C<printf>|/printf
IDENTIFICADOR_ARCHIVO FORMATO, LISTA>. Esto significa que C<printf(@_)>
utilizará C<$_[0]> como el formato. Vea L<sprintf|/sprintf FORMATO, LISTA>
para una explicación del argumento de formato. Si C<use locale> (incluyendo
C<use locale ':not_characters'>) está en activo y se ha llamado a
L<C<POSIX::setlocale>|POSIX/C<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 C<LC_NUMERIC>. Vea L<perllocale> y L<POSIX>.

Por razones históricas, si omite la lista, se usará L<C<$_>|perlvar/$_> como
formato; para usar un IDENTIFICADOR_ARCHIVO sin una lista, debe usar un
identificador de archivo simple, como C<FH>, no uno indirecto como C<$fh>. Aun
así, esto raramente será lo que quiera hacer; si L<C<$_>|perlvar/$_> 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 L<C<print>|/print
IDENTIFICADOR_ARCHIVO LISTA> si quiere imprimir los contenidos de
L<C<$_>|perlvar/$_>.

No caiga en la trampa de utilizar un L<C<printf>|/printf IDENTIFICADOR_ARCHIVO
FORMATO, LISTA> cuando valdría un simple L<C<print>|/print
IDENTIFICADOR_ARCHIVO LISTA>. El L<C<print>|/print IDENTIFICADOR_ARCHIVO LISTA>
es más eficiente y menos propenso a errores.

=item prototype FUNCIÓN
X<prototype> X<prototipo>

=item prototipo

=for Pod::Functions +5.002 get the prototype (if any) of a subroutine

Devuelve el prototipo de una función como una cadena (o L<C<undef>|/undef
EXPR> 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 L<C<$_>|perlvar/$_>.

Si FUNCIÓN es una cadena que comienza con C<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 L<C<system>|/system LISTA>), L<C<prototype>|/prototype FUNCIÓN> devuelve
L<C<undef>|/undef EXPR>, 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.

=item push ARRAY,LISTA
X<push> X<stack> X<pila>

=for Pod::Functions append one or more elements to an array

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 L<C<push>|/push ARRAY,LISTA>.

A partir de 5.14, una característica experimental permitía a L<C<push>|/push
ARRAY,LISTA> tomar una expresión escalar. Se ha considerado que este
experimento no ha funcionado, y se quitó a partir de Perl 5.24.

=item q/CADENA/

=for Pod::Functions singly quote a string

=item qq/CADENA/

=for Pod::Functions doubly quote a string

=item qw/CADENA/

=for Pod::Functions quote a list of words

=item qx/CADENA/

=for Pod::Functions backquote quote a string

Comillas generales. Ver L<perlop/"Operadores entrecomillados">.

=item qr/CADENA/

=for Pod::Functions +5.005 compile pattern

Entrecomillado de expresión regular. See L<perlop/"Operadores I<Regex>">.

=item quotemeta EXPR
X<quotemeta> X<metacharacter> X<metacarácter>

=item quotemeta

=for Pod::Functions quote regular expression magic characters

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 C</[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 C<\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 L<C<$_>|perlvar/$_>.

quotemeta (y C<\Q> ... C<\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 C<$instruccion> se convierta en C<'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
L<C<quotemeta>|/quotemeta EXPR> o C<\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 L<C<use feature 'unicode_strings'>|feature/The 'unicode_strings'
feature>, 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
C<unicode_strings> se activa automáticamente en el ámbito de S<C<use v5.12>>
o mayor).

Dentro del ámbito de L<C<use locale>|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 C<"|"> 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 L<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 (C<\ E<verbar> ( ) [ { ^ *
$ + ?  .>), 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 C</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).

=item rand EXPR
X<rand> X<random> X<aleatorio>

=item rand

=for Pod::Functions retrieve the next pseudorandom number

Devuelve un número decimal aleatorio mayor o igual a C<0> y menor que el valor
de EXPR.  (EXPR debe ser positiva). Si la EXPR se omite, se usa C<1>.
Actualmente EXPR con el valor de C<0> es también un caso especial como el de
C<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 L<C<srand>|/srand EXPR>
a menos que L<C<srand>|/srand EXPR> ya se haya llamado. Vea también
L<C<srand>|/srand EXPR>.

Aplique L<C<int>|/int EXPR> al valor devuelto por L<C<rand>|/rand EXPR> si
quiere obtener enteros aleatorios en lugar de fraccionarios. Por ejemplo,

    int(rand(10))

devuelve un número entero aleatorio entre C<0> y C<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).

B<L<C<rand>|/rand EXPR> 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 L<Data::Entropy>, L<Crypt::Random>, L<Math::Random::Secure> y
L<Math::TrulyRandom>.

=item read IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO
X<read> X<file, read> X<archivo, leer>

=item read IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD

=for Pod::Functions fixed-length buffered input from a filehandle

Intento de leer LONGITUD I<caracteres> de datos en la variable ESCALAR del
IDENTIFICADOR_ARCHIVO especificado. Devuelve el número de caracteres realmente
leídos, C<0> al final del archivo, o undef si hubo un error (en este último
caso se actualiza el valor de L<C<$!>|perlvar/$!>). 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 C<"\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
L<fread(3)> de su sistema. Para obtener una auténtica llamada del sistema
L<read(2)>, vea L<sysread|/sysread
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>.

Note los I<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 C<:utf8> (vea L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR>, y
el pragma L<open>), la E/S operará en caracteres Unicode codificados en UTF-8,
no bytes. Del mismo modo, para la capa C<:encoding>: en este caso casi todos
los caracteres se pueden leer.

=item readdir IDENTIFICADOR_DIR
X<readdir>

=for Pod::Functions get a directory from a directory handle

Devuelve la siguiente entrada de directorio de un directorio abierto con
L<C<opendir>|/opendir IDENTIFICADOR_DIR,EXPR>. 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
L<C<readdir>|/readdir IDENTIFICADOR_DIR>, más le vale anteponer el directorio
en cuestión. De lo contrario, debido a que no hicimos antes un
L<C<chdir>|/chdir EXPR>, 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 L<C<readdir>|/readdir
IDENTIFICADOR_DIR> en un bucle C<while>, que actualizará L<C<$_>|perlvar/$_>
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 I<sólo> en
versiones Perl de cosechas recientes:

    use 5.012; # así, readdir asigna a $_ en un solitario test del while

=item readline EXPR

=item readline
X<readline> X<gets> X<fgets>

=for Pod::Functions fetch a record from a file

Lee del identificador de archivo cuyo I<typeglob> esté contenido en EXPR (o
desde C<*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 L<C<undef>|/undef EXPR>. 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
L<C<$E<sol>>|perlvar/$E<sol>> o C<$INPUT_RECORD_SEPARATOR> en L<English>. Ver
L<perlvar/"$/">.

Cuando  L<C<$E<sol>>|perlvar/$E<sol>> tenga un valor de L<C<undef>|/undef
EXPR>, cuando L<C<readline>|/readline EXPR> esté en contexto escalar (es
decir, modo de absorción completa de archivo), y cuando se esté leyendo un
archivo vacío, devuelve C<''> la primera vez, seguido a continuación de
L<C<undef>|/undef EXPR>.

Esto es la función interna que implementa el operador C<< <EXPR> >>, pero
puede usarla directamente. El operador C<< <EXPR> >> se discute con más
detalle en L<perlop/"Operadores E/S">.

    my $linea = <STDIN>;
    my $linea = readline(STDIN);    # lo mismo

Si L<C<readline>|/readline EXPR> encuentra un error del sistema operativo,
L<C<$!>|perlvar/$!> se establecerá al correspondiente mensaje de error. Puede
ser útil comprobar L<C<$!>|perlvar/$!> 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 L<C<readline>|/readline EXPR> 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 L<C<readline>|/readline EXPR> de esta
manera con el identificador de archivo C<ARGV>. En este caso, tiene que abrir
cada elemento de L<C<@ARGV>|perlvar/@ARGV> debido a que L<C<eof>|/eof
IDENTIFICADOR_ARCHIVO> gestiona C<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: $!";
            ...
        }
    }

=item readlink EXPR
X<readlink>

=item readlink

=for Pod::Functions determine where a symbolic link is pointing

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 L<C<$!>|perlvar/$!> (errno). Si se
omite EXPR, usa L<C<$_>|perlvar/$_>.

Cuestiones de portabilidad: L<perlport/readlink>.

=item readpipe EXPR

=item readpipe
X<readpipe>

=for Pod::Functions execute a system command and collect standard output

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
L<C<$E<sol>>|perlvar/$E<sol>> (o C<$INPUT_RECORD_SEPARATOR> en L<English>)).
Esto es la función interna que implementa el operador C<qx/EXPR/>, pero puede
usarla directamente. El operador C<qx/EXPR/> se discute con más detalle en
L<perlop/"Operadores E/S">. Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

=item recv SOCKET,ESCALAR,LONGITUD,INDICADORES
X<recv>

=for Pod::Functions receive a message over a Socket

Recibe un mensaje de un socket. Intenta leer LONGITUD I<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
L<recvfrom(2)>. Ver L<perlipc/"UDP: Paso de mensajes"> para ejemplos.

Note los I<caracteres>: dependiendo del estado del socket, se leen bytes
(8-bit) o caracteres. Por defecto todos los I<sockets> operan en bytes, pero
por ejemplo si el I<socket> se ha cambiado usando L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA> para operar con la capa de E/S C<:encoding(utf8)>
(vea el pragma L<open>), la E/S operará en caracteres Unicode codificados en
UTF-8, no bytes. Del mismo modo, para la capa C<:encoding>: en este caso casi
todos los caracteres se pueden leer.

=item redo ETIQUETA
X<redo>

=item redo EXPR

=item redo

=for Pod::Functions start this loop iteration over again

El comando L<C<redo>|/redo ETIQUETA> reinicia la iteración sin evaluar de
nuevo la condición. El bloque L<C<continue>|/continue BLOQUE>, 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 C<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 C<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;
    }

L<C<redo>|/redo ETIQUETA> no puede usarse para reiniciar un bloque que devuelve
un valor, como C<eval {}>, C<sub {}> o C<do {}>, y no se debe usar para salir
de una operación L<C<grep>|/grep BLOQUE LISTA> o L<C<map>|/map BLOQUE LISTA>.

Note que un bloque por sí mismo es semánticamente idéntico a un bucle que se
ejecuta una vez. Por lo tanto L<C<redo>|/redo ETIQUETA> dentro de un bloque lo
convertirá de forma efectiva en una construcción de bucle.

Ver también L<C<continue>|/continue BLOQUE> para una ilustración de cómo
funcionan L<C<last>|/last ETIQUETA>, L<C<next>|/next ETIQUETA> y
L<C<redo>|/redo ETIQUETA>.

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 C<redo ("foo")."bar"> hará que "bar" sea parte del argumento a
L<C<redo>|/redo ETIQUETA>.

=item ref EXPR
X<ref> X<reference> X<referencia>

=item ref

=for Pod::Functions find out the type of thing being referenced

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á L<C<$_>|perlvar/$_>. 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 L<C<ref>|/ref EXPR> como un operador C<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 C<LVALUE> indica una referencia a un valor-izquierda que no
es una variable. Obtiene esto de la referencia a las llamadas a funciones como
L<C<pos>|/pos ESCALAR> o L<C<substr>|/substr
EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO>. C<VSTRING> se devuelve si la
referencia apunta a una L<version string|perldata/"Cadenas de versión">.

El resultado C<Regexp> indica que el argumento es una expresión regular como
resultado de L<C<qrE<sol>E<sol>>|/qrE<sol>CADENAE<sol>>.

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
C<Regexp> o C<IO>, o incluso C<HASH>. También, porque L<C<ref>|/ref EXPR> no
tiene en cuenta a las subclases, como hace L<C<isa>|UNIVERSAL/C<< $obj->isa(
TIPO ) >>>.

En lugar de eso, use L<C<blessed>|Scalar::Util/blessed> (en el módulo
L<Scalar::Util>) para comprobaciones booleanas, L<C<isa>|UNIVERSAL/C<<
$obj->isa( TIPO ) >>> para comprobaciones de una clase específica y
L<C<reftype>|Scalar::Util/reftype> (también en L<Scalar::Util>) para
comprobaciones de tipo.  (Vea L<perlobj> para más detalles y un ejemplo de
L<C<blessed>|Scalar::Util/blessed>/L<C<isa>|UNIVERSAL/C<< $obj->isa( TIPO )
>>>).

Ver también L<perlref>.

=item rename NOMBRE_VIEJO,NOMBRE_NUEVO
X<rename> X<move> X<mv> X<ren> X<mover> X<renombra>

=for Pod::Functions change a filename

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 I<mv> a veces lo compense. Otras restricciones incluyen si funciona en
directorios, archivos abiertos, o archivos pre-existentes. Compruebe
L<perlport> y, o bien la página de manual de L<rename(2)> o documentación
equivalente del sistema para más detalles.

Para una función independiente de la plataforma vea L<C<move>|File::Copy/move>
en el módulo L<File::Copy>.

Cuestiones de portabilidad: L<perlport/rename>.

=item require VERSIÓN
X<require>

=item require EXPR

=item require

=for Pod::Functions load in external functions from a library at runtime

Exige una versión de Perl especificada por VERSIÓN, o exige una semántica
especificada por EXPR, o por L<C<$_>|perlvar/$_> si EXPR se omite.

VERSIÓN puede ser un argumento numérico, como 5.006, que será comparado con
L<C<$]>|perlvar/$]>, o un literal de la forma v5.6.1, que será comparado con
L<C<$^V>|perlvar/$^V> (alias de $PERL_VERSION en L<English>). Se genera una
excepción si VERSIÓN es mayor que la versión actual del intérprete de Perl.
Compare con L<C<use>|/use Módulo VERSIÓN LISTA>, 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, L<C<require>|/require VERSIÓN> 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 L<C<eval>|/eval EXPR> 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 C<1;> a menos que esté
seguro de que devolverá cierto, de otra manera. Pero es mejor sólo para poner
C<1;>, en caso de que añada más instrucciones.

Si EXPR es una palabra simple, el L<C<require>|/require VERSIÓN> asume una
extensión "F<.pm>" y le reemplaza C<::> con C</> 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 "F<Foo/Bar.pm>" en los
directorios especificados en el array L<C<@INC>|perlvar/@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 C<require> buscará por el archivo "F<Foo::Bar>" en los directorios
especificados por el array L<C<@INC>|perlvar/@INC> y se quejará de que no lo
encuentra. En este caso puede hacer:

        eval "require $clase";

Ahora que sabe cómo L<C<require>|/require VERSIÓN> busca archivos con un
argumento simple, hay una funcionalidad extra que pasa por detrás de las
cámaras. Antes de L<C<require>|/require VERSIÓN> busque una extensión
"F<.pm>", en primer lugar, buscará un nombre de archivo similar con una
extensión "F<.pmc>". Si se encuentra este archivo, se cargará en lugar de
cualquier archivo que termine en una extensión "F<.pm>".

También puede insertar enganches en la facilidad C<import> poniendo código
Perl directamente en el array L<C<@INC>|perlvar/@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 L<C<@INC>|perlvar/@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,
F<Foo/Bar.pm>). La subrutina debe devolver, o nada, o bien una lista de hasta
cuatro valores en el orden siguiente:

=over

=item 1

Una referencia a un escalar, conteniendo cualquier código de fuente inicial
para agregarse antes del archivo o salida del generador.

=item 2

Un identificador de archivo, desde el cual, el archivo será leído.

=item 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 L<C<$_>|perlvar/$_> 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
L<C<$_>|perlvar/$_>. De nuevo, devuelve 1 para cada línea válida y 0 después
de que todas las líneas han sido devueltas.

=item 4

Estado opcional para la subrutina. El estado es pasado en C<$_[1]>. Una
referencia a la propia subrutina es pasada en C<$_[0]>.

=back

Si se devuelve una lista vacía, L<C<undef>|/undef EXPR>, o nada que coincida
con los tres primeros valores anteriores, entonces L<C<require>|/require
VERSIÓN> mira en los elementos restantes de L<C<@INC>|perlvar/@INC>. Tenga en
cuenta que este identificador de archivo debe ser un identificador de archivo
real (en sentido estricto un C<typeglob> o una referencia a un C<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 C<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 C<INC> está siempre forzado en el paquete C<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
L<C<%INC>|perlvar/%INC> correspondientes a los archivos que se hayan cargado.
Ver L<perlvar/%INC>.

Para una más-que-poderosa facilidad de importación, vea L<C<use>|/use Módulo
VERSIÓN LISTA> y L<perlmod>.

=item reset EXPR
X<reset>

=item reset

=for Pod::Functions clear all variables of a given name

Generalmente se usa en un bloque L<C<continue>|/continue BLOQUE>, al final de
un bucle para limpiar variables y reinicializar las búsquedas C<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 (C<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 C<"A-Z"> no es recomendable porque limpiará sus arrays
L<C<@ARGV>|perlvar/@ARGV> y L<C<@INC>|perlvar/@INC> y su hash
L<C<%ENV>|perlvar/%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 L<C<my>|/my LISTAVAR>.

=item return EXPR
X<return>

=item return

=for Pod::Functions get out of a function early

Regresa de una subrutina, L<C<eval>|/eval EXPR>, L<C<do FILE>|/do EXPR>, un
bloque L<C<sort>|/sort NOMBRE_SUB LISTA> o un bloque I<regex> eval (pero no un
bloque L<C<grep>|/grep BLOQUE LISTA> o L<C<map>|/map BLOQUE LISTA>) 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
L<C<wantarray>|/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 L<C<return>|/return EXPR> explícito, una subrutina,
L<C<eval>|/eval EXPR>, o L<C<do ARCHIVO>|/do EXPR>, 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 C<return ("foo")."bar">
hará que C<"bar"> sea parte del argumento a L<C<return>|/return EXPR>.

=item reverse LISTA
X<reverse> X<rev> X<invert> X<invertir>

=for Pod::Functions flip a string or a list

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, L<C<reverse>|/reverse LISTA>
invierte L<C<$_>|perlvar/$_>.

    $_ = "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 C<@a = reverse @a>)
preservará los elementos inexistentes mientras le sea posible, es decir, para
arrays no mágicos o arrays enlazados con métodos C<EXISTS> y C<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

=item rewinddir IDENTIFICADOR_DIR
X<rewinddir>

=for Pod::Functions reset directory handle

Establece la posición actual al comienzo del directorio para la rutina
L<C<readdir>|/readdir IDENTIFICADOR_DIR> en IDENTIFICADOR_DIR.

Problemas de adaptación: L<perlport/rewinddir>.

=item rindex CADENA,SUBCADENA,POSICIÓN
X<rindex>

=item rindex CADENA,SUBCADENA

=for Pod::Functions right-to-left substring search

Funciona igual que L<C<index>|/index CADENA,SUBCADENA,POSICIÓN> excepto que
devuelve la posición de la I<última> ocurrencia de SUBCADENA en CADENA. Sí
POSICIÓN es especificada, devuelve la última ocurrencia comenzando en o antes
de esta posición.

=item rmdir NOMBRE_DIRECTORIO
X<rmdir> X<rd> X<directory, remove> X<directorio, eliminar>

=item rmdir

=for Pod::Functions remove a directory

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 L<C<$!>|perlvar/$!> (errno). Si se omite NOMBRE_ARCHIVO, usa
L<C<$_>|perlvar/$_>.

Para eliminar un árbol de directorio recursivamente (C<rm -rf> en Unix) mire
la función L<C<rmtree>|File::Path/rmtree( $dir )> del módulo L<File::Path>.

=item s///

=for Pod::Functions replace a pattern with a string

El operador de sustitución. See L<perlop/"Operadores I<Regex>">.

=item say IDENTIFICADOR_ARCHIVO LISTA
X<say>

=item say IDENTIFICADOR_ARCHIVO

=item say LISTA

=item say

=for Pod::Functions +say output a list to a filehandle, appending a newline

Igual que L<C<print>|/print IDENTIFICADOR_ARCHIVO LISTA>, pero implícitamente
añade un carácter de nueva línea. C<say LISTA> es simplemente una
abreviatura de C<{ local $\ = "\n"; print LISTA }>. Para utilizar solamente
IDENTIFICADOR_ARCHIVO para imprimir en él el contenido de L<C<$_>|perlvar/$_>
sin una LISTA, debe ser un identificador de archivo real, como C<FH>, no uno
indirecto como C<$fh>.

L<C<say>|/say IDENTIFICADOR_ARCHIVO LISTA> sólo está disponible si la
característica L<C<"say">|feature/La característica 'say'> está habilitada o
si está prefijada con C<CORE::>. La característica L<C<"say">|feature/La
característica 'say'> se activa automáticamente con una declaración C<use
v5.10> (o superior) en el ámbito actual.

=item scalar EXPR
X<scalar> X<context> X<escalar> X<contexto>

=for Pod::Functions force a scalar context

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  C<@{[ (una
expresión) ]}>, pero por lo general un simple C<(una expresión)> basta.

Dado que L<C<scalar>|/scalar EXPR> 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 L<perlop> para más detalles en operadores unarios y el operador coma, y
L<perldata> para más detalles al evaluar un hash en contexto escalar.

=item seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE
X<seek> X<fseek> X<filehandle, position> X<identificador de archivo, posición>

=for Pod::Functions reposition file pointer for random-access I/O

Establece la posición de IDENTIFICADOR_ARCHIVO, igual que la llamada
L<fseek(3)> de C<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
C<0> para poner la nueva posición I<en bytes> a POSICIÓN; C<1> para poner la
posición actual más POSICIÓN; y C<2> para ponerlo a EOF más POSICIÓN,
normalmente negativo. Para DÓNDE puede usar las constantes C<SEEK_SET>,
C<SEEK_CUR> y C<SEEK_END> (inicio del archivo, posición actual y fin de
archivo) desde el módulo L<Fcntl>. Devuelve C<1> en caso de éxito; falso en
caso contrario.

Nota sobre lo de I<en bytes>: incluso si el identificador de archivo se ha
establecido para operar en caracteres (por ejemplo usando la capa de open
C<:encoding(utf8)>), L<C<tell>|/tell IDENTIFICADOR_ARCHIVO> devolverá
desplazamientos en bytes, no en caracteres (porque implementando esto
convertirían en lentas a L<C<seek>|/seek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> y L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO>).

Si desea posicionar el archivo para las funciones L<C<sysread>|/sysread
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> o
L<C<syswrite>|/syswrite IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>,
no utilice L<C<seek>|/seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>, 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,
L<C<sysseek>|/sysseek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>.

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 L<clearerr(3)> de
stdio. Un DONDE de C<1> (C<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 C<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 L<C<seek>|/seek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> para restablecer las cosas. El
L<C<seek>|/seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> no cambia la posición,
pero I<borra> la condición de final de archivo en el identificador de archivo,
para que el próximo C<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);
    }

=item seekdir IDENTIFICADOR_DIR,POSICIÓN
X<seekdir>

=for Pod::Functions reposition directory pointer

Establece la posición actual para la rutina L<C<readdir>|/readdir
IDENTIFICADOR_DIR> en IDENTIFICADOR_DIR. POS debe ser un valor devuelto por
L<C<telldir>|/telldir IDENTIFICADOR_DIR>. L<C<seekdir>|/seekdir
IDENTIFICADOR_DIR,POSICIÓN> también tiene las mismas advertencias sobre la
posible compactación del directorio como la correspondiente rutina del
sistema.

=item select IDENTIFICADOR_ARCHIVO
X<select> X<filehandle, default> X<identificador de archivo, por defecto>

=item select

=for Pod::Functions reset default output or do I/O multiplexing

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
L<C<write>|/write IDENTIFICADOR_ARCHIVO> o un L<C<print>|/print
IDENTIFICADOR_ARCHIVO LISTA> 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 C<use IO::Handle;> de
forma explícita).

Cuestiones de portabilidad: L<perlport/select>.

=item select RBITS,WBITS,EBITS,TIEMPO_ESPERA
X<select>

Esto llama a la función del sistema L<select(2)> con las máscaras de bit
especificadas, que pueden construirse usando L<C<fileno>|/fileno
IDENTIFICADOR_ARCHIVO> y L<C<vec>|/vec EXPR,DESPLAZAMIENTO,BITS>, 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
C<$tiempo_restante>, así que llamando L<C<select>|/select
RBITS,WBITS,EBITS,TIEMPO_ESPERA> en contexto escalar sólo devuelve
C<$n_encontrados>.

Cualquiera de las máscaras de bit también puede ser L<C<undef>|/undef EXPR>.
El tiempo de espera, si se especifica, en segundos, puede ser decimal. Nota: no
todas las implementaciones son capaces de devolver C<$tiempo_restante>. Si no,
siempre devuelven C<$tiempo_restante> igual a C<$tiempo_espera> indicado.

Puede efectuar una espera de 250 milisegundos de esta manera:

    select(undef, undef, undef, 0.25);

Tenga en cuenta que cuando L<C<select>|/select RBITS,WBITS,EBITS,TIEMPO_ESPERA>
se reinicia después de señales (por ejemplo, SIGALRM) es algo dependiente de
la implementación. Vea también L<perlport> para las notas sobre la
portabilidad de L<C<select>|/select RBITS,WBITS,EBITS,TIEMPO_ESPERA>.

En caso de error, L<C<select>|/select RBITS,WBITS,EBITS,TIEMPO_ESPERA> se
comporta como L<select(2)>: devuelve C<-1> y actualiza L<C<$!>|perlvar/$!>.

En algunos sistemas Unix, L<select(2)> puede informar de un descriptor de
archivo I<socket> como "listo para leer" incluso cuando no hay datos
disponibles, y por lo tanto un posterior L<C<read>|/read
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> producirá un bloqueo.
Esto puede evitarse si siempre utiliza C<O_NONBLOCK> en el I<socket>. Vea
L<select(2)> y L<fcntl(2)> para más detalles.

El módulo estándar L<C<IO::Select>|IO::Select> proporciona una interfaz
fácil de utilizar para L<C<select>|/select RBITS,WBITS,EBITS,TIEMPO_ESPERA>,
sobre todo porque hace todo el trabajo de la máscara de bit, por usted.

B<AVISO> : No debe tratar de mezclar el E/S con búferes (como L<C<read>|/read
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> o L<C<select>|/select
RBITS,WBITS,EBITS,TIEMPO_ESPERA>) con L<C<readline>|/readline EXPR>, excepto lo
autorizado por POSIX, e incluso entonces sólo en sistemas POSIX. Tiene que
usar en su lugar L<C<sysread>|/sysread
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>

Cuestiones de portabilidad: L<perlport/select>.

=item semctl ID,SEMNUM,CMD,ARG
X<semctl>

=for Pod::Functions SysV semaphore control operations

Llama a la función L<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
L<C<ioctl>|/ioctl IDENTIFICADOR_ARCHIVO,FUNCIÓN,ESCALAR>: el valor indefinido
para indicar un error, "C<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 C<pack("s!",(0)x$nsem)>. Vea también
L<perlipc/"SysV IPC"> y la documentación de L<C<IPC::SysV>|IPC::SysV> y
L<C<IPC::Semaphore>|IPC::Semaphore>.

Cuestiones de portabilidad: L<perlport/semctl>.

=item semget CLAVE,NSEMS,INDICADORES
X<semget>

=for Pod::Functions get set of SysV semaphores

Llama a la función L<semget(2)> de System V IPC. Devuelve el id del semáforo,
o el valor indefinido en caso de error. Vea también L<perlipc/"SysV IPC"> y la
documentación de L<C<IPC::SysV>|IPC::SysV> y
L<C<IPC::Semaphore>|IPC::Semaphore>.

Cuestiones de portabilidad: L<perlport/semget>.

=item semop CLAVE,OPSTRING
X<semop>

=for Pod::Functions SysV semaphore operations

Llama a la función System V IPC L<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 C<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 C<-1> con C<1>. Vea también
L<perlipc/"SysV IPC"> y la documentación de L<C<IPC::SysV>|IPC::SysV> y
L<C<IPC::Semaphore>|IPC::Semaphore>.

Cuestiones de portabilidad: L<perlport/semop>.

=item send SOCKET,MSG,INDICADORES,DESTINO
X<send>

=item send SOCKET,MSG,FLAGS

=for Pod::Functions send a message over a socket

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
I<adonde> enviarlo, en cuyo caso hace una llamada del sistema L<sendto(2)>.
Devuelve el número de caracteres enviados, o el valor indefinido en caso de
error. La llamada del sistema L<sendmsg(2)> no está, actualmente,
implementada. Ver L<perlipc/"UDP: Paso de mensajes"> para ejemplos.

Note los I<caracteres>: dependiendo del estado del socket, son enviados bytes
(8-bit) o caracteres. Por defecto todos los I<sockets> operan en bytes, pero
por ejemplo si el I<socket> se ha cambiado usando L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA> para operar con la capa de E/S C<:encoding(utf8)>
(vea L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR>, o el pragma L<open>), la E/S
operará en caracteres Unicode codificados en UTF-8, no bytes. Del mismo modo,
para el pragma C<:encoding>: en este caso casi todos los caracteres se pueden
enviar.

=item setpgrp PID,PGRP
X<setpgrp> X<group>

=for Pod::Functions set the process group of a process

Establece el grupo de procesos en curso para el PID especificado, C<0> para el
proceso actual. Eleva una excepción si se usa en una máquina que no
implemente POSIX L<setpgid(2)> o BSD L<setpgrp(2)>. Si los argumentos se
omiten, el valor predeterminado es C<0,0>. Tenga en cuenta que la versión de
BSD 4.2 de L<C<setpgrp>|/setpgrp PID,PGRP> no acepta ningún argumento, por lo
que sólo C<setpgrp(0,0)> es portátil. Vea también
L<C<POSIX::setsid()>|POSIX/C<setsid>>.

Cuestiones de portabilidad: L<perlport/setpgrp>.

=item setpriority CUÁL,QUIÉN,PRIORIDAD
X<setpriority> X<priority> X<nice> X<renice> X<prioridad>

=for Pod::Functions set a process's nice value

Devuelve la prioridad actual de un proceso, un grupo de procesos o un usuario.
(Vea L<setpriority(2)>). Lanza una excepción si se usa en una máquina que no
implementa L<setpriority(2)>.

Cuestiones de portabilidad: L<perlport/setpriority>.

=item setsockopt SOCKET,NIVEL,OPCIÓN_NOMBRE,OPCIÓN_VALOR
X<setsockopt>

=for Pod::Functions set some socket options

Establece la opción de socket solicitada. Devuelve L<C<undef>|/undef EXPR> en
caso de error. Utilice constantes enteras proporcionadas por el módulo
L<C<Socket>|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: L<perlport/setsockopt>.

=item shift ARRAY
X<shift>

=item shift

=for Pod::Functions remove the first element of an array, and return it

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
L<C<@_>|perlvar/@_> dentro del ámbito léxico de subrutinas y formatos, y el
array L<C<@ARGV>|perlvar/@ARGV> si está fuera de una subrutina y también
dentro de los ámbitos léxicos establecidos por construcciones como C<eval
CADENA>, C<BEGIN {}>, C<INIT {}>, C<CHECK {}>, C<UNITCHECK {}> y C<END {}>.

A partir de Perl 5.14, una característica experimental permitía a
L<C<shift>|/shift ARRAY> 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 L<C<unshift>|/unshift ARRAY,LISTA>, L<C<push>|/push ARRAY,LISTA>,
y L<C<pop>|/pop ARRAY>. L<C<shift>|/shift ARRAY> y L<C<unshift>|/unshift
ARRAY,LISTA> hacen lo mismo con el extremo izquierdo de un array que
L<C<pop>|/pop ARRAY> y L<C<push>|/push ARRAY,LISTA> lo hacen para el extremo
derecho.

=item shmctl ID,CMD,ARG
X<shmctl>

=for Pod::Functions SysV shared memory operations

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 C<IPC_STAT>,
entonces ARG debe ser una variable que contendrá la estructura C<shmid_ds>
devuelta. Devuelve lo mismo que ioctl: L<C<undef>|/undef EXPR> para error;
"C<0> but true" para cero; o el valor de retorno real, en cualquier otro caso.
Vea también L<perlipc/"SysV IPC"> y la documentación de
L<C<IPC::SysV>|IPC::SysV>.

Cuestiones de portabilidad: L<perlport/shmctl>.

=item shmget CLAVE,TAMAÑO,INDICADORES
X<shmget>

=for Pod::Functions get SysV shared memory segment identifier

Llama a la función System V IPC shmget(2). Devuelve el identificador de la
memoria compartida, o L<C<undef>|/undef EXPR> en caso de error. Vea también
L<perlipc/"SysV IPC"> y la documentación de L<C<IPC::SysV>|IPC::SysV>.

Cuestiones de portabilidad: L<perlport/shmget>.

=item shmread ID,VAR,POSICIÓN,TAMAÑO
X<shmread> X<shmwrite>

=for Pod::Functions read SysV shared memory

=item shmwrite ID,CADENA,POSICIÓN,TAMAÑO

=for Pod::Functions write SysV shared memory

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. L<C<shmread>|/shmread ID,VAR,POSICIÓN,TAMAÑO> contamina la variable.
Vea también L<perlipc/"SysV IPC"> y la documentación del módulo
L<C<IPC::SysV>|IPC::SysV> y L<C<IPC::Shareable>|IPC::Shareable> en CPAN.

Cuestiones de portabilidad: L<perlport/shmread> y L<perlport/shmwrite>.

=item shutdown SOCKET,CÓMO
X<shutdown>

=for Pod::Functions close down just half of a socket connection

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 C<1> para el éxito; en caso de error, devuelve L<C<undef>|/undef
EXPR> si el primer argumento no es un identificador de archivo válido, o
devuelve C<0> y establece L<C<$!>|perlvar/$!> por cualquier otro error.

=item sin EXPR
X<sin> X<sine> X<asin> X<arcsine> X<arco seno> X<seno>

=item sin

=for Pod::Functions return the sine of a number

Devuelve el seno de EXPR (expresado en radianes). Si se omite EXPR, devuelve el
seno de L<C<$_>|perlvar/$_>.

Para la inversa de la operación seno, puede usar la función
C<Math::Trig::asin()>, o usar esta relación:

    sub asin { atan2($_[0], sqrt(1 - $_[0] * $_[0])) }

=item sleep EXPR
X<sleep> X<pause> X<pausa>

=item sleep

=for Pod::Functions block for some number of seconds

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 C<SIGALRM>.

    eval {
        local $SIG{ALRM} = sub { die "¡Alarma!\n" };
        sleep;
    };
    die $@ unless $@ eq "¡Alarma!\n";

Probablemente no puede entremezclar llamadas a L<C<alarm>|/alarm SEGUNDOS> y
L<C<sleep>|/sleep EXPR>, porque L<C<sleep>|/sleep EXPR> se implementa, a
menudo, con L<C<alarm>|/alarm SEGUNDOS>.

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 L<Time::HiRes> (en
CPAN, y a partir de Perl 5.8 como parte de la distribución estándar) ofrece
L<C<usleep>|Time::HiRes/usleep ( $useconds )>. Puede también usar la versión
de L<C<select>|/select RBITS,WBITS,EBITS,TIEMPO_ESPERA> de cuatro argumentos,
dejando los tres primeros indefinidos, o puede usar la interfaz
L<C<syscall>|/syscall NÚMERO, LISTA> para acceder a L<setitimer(2)> si su
sistema lo soporta. Vea L<perlfaq8> para más detalles.

Vea también la función L<C<pause>|POSIX/C<pause>> del módulo L<POSIX>.

=item socket SOCKET,DOMINIO,TIPO,PROTOCOLO
X<socket>

=for Pod::Functions create a socket

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 C<use Socket> primero para
obtener las apropiadas definiciones. Ver los ejemplos en L<perlipc/"Sockets:
Comunicación Cliente/Servidor">.

En sistemas que soportan el indicador B<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
L<C<$^F>|perlvar/$^F>. Ver L<perlvar/$^F>.

=item socketpair SOCKET1,SOCKET2,DOMINIO,TIPO,PROTOCOLO
X<socketpair>

=for Pod::Functions create a pair of sockets

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 B<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
L<C<$^F>|perlvar/$^F>. Ver L<perlvar/$^F>.

Algunos sistemas definen L<C<pipe>|/pipe
IDENTIFICADOR_LECTURA,IDENTIFICADOR_ESCRITURA> en términos de
L<C<socketpair>|/socketpair SOCKET1,SOCKET2,DOMINIO,TIPO,PROTOCOLO>, en el que
una llamada a C<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 L<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: L<perlport/socketpair>.

=item sort NOMBRE_SUB LISTA
X<sort> X<qsort> X<quicksort> X<mergesort>

=item sort BLOQUE LISTA

=item sort LISTA

=for Pod::Functions sort a list of values

En contexto lista, ordena la LISTA y devuelve los valores de la lista
ordenados. En contexto escalar, el comportamiento de L<C<sort>|/sort NOMBRE_SUB
LISTA> 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 C<0>,
dependiendo de cómo los elementos de la lista tienen que ordenarse.  (Los
operadores C<< <=> >> y C<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 C<($$)>, los elementos a compararse se pasan
por referencia en L<C<@_>|perlvar/@_>, 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 C<$a> y
C<$b> (ver ejemplo más abajo). Tenga en cuenta que en el último caso, suele
ser altamente contraproducente declarar C<$a> y C<$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.
C<$a> y C<$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
L<perlsyn> o con L<C<goto>|/goto ETIQUETA>.

Cuando L<C<use locale>|locale> está activo (pero no C<use locale
':not_characters'>), C<sort LISTA> ordena LISTA de acuerdo con la actual
configuración regional de cotejo. Vea L<perllocale>.

L<C<sort>|/sort NOMBRE_SUB LISTA> 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
L<C<sort>|/sort NOMBRE_SUB LISTA> (por ejemplo, en un C<foreach>, L<C<map>|/map
BLOQUE LISTA> u otro L<C<grep>|/grep BLOQUE LISTA>) 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 I<podría> ser cuadrático.  (Un sort
I<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 I<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 L<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 C<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 C<@claves> con la rutina de comparación
C<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));

I<No debe> declarar C<$a> y C<$b> como léxicas. Son variables globales del
paquete. Esto significa que si usted está en el paquete C<main> y escribe

    my @articulos = sort {$b <=> $a} @archivos;

entonces C<$a> y C<$b> son C<$main::a> y C<$main::b> (o C<$::a> y C<$::b>),
pero si está en el paquete C<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 C<$x[1]> es
menor que C<$x[2]> y otras veces diciendo lo opuesto, por ejemplo) los
resultados no están definidos.

Dado que C<< <=> >> devuelve L<C<undef>|/undef EXPR> cuando alguno de los
operandos es C<NaN> (I<not-a-number>, "no es un número"), tenga cuidado al
ordenar con una función de comparación como C<< $a <=> $b >> cualquier lista
que pueda contener un C<NaN>. En el ejemplo siguiente se aprovecha de que C<NaN
!= NaN> para eliminar cualquier C<NaN> de la lista de entrada.

    my @resultado = sort { $a <=> $b } grep { $_ == $_ } @entrada;

=item splice ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA
X<splice>

=item splice ARRAY,DESPLAZAMIENTO,LONGITUD

=item splice ARRAY,DESPLAZAMIENTO

=item splice ARRAY

=for Pod::Functions add or remove elements anywhere in an 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 L<C<undef>|/undef EXPR> 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 C<< $#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 L<C<splice>|/splice ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA>, 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
L<C<splice>|/splice ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA> tomar una expresión
escalar. Se ha considerado que este experimento no ha funcionado, y se quitó a
partir de Perl 5.24.

=item split /PATRÓN/,EXPR,LÍMITE
X<split>

=item split /PATRÓN/,EXPR

=item split /PATRÓN/

=item split

=for Pod::Functions split up a string using a regexp delimiter

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, L<C<$_>|perlvar/$_>.

Cualquier cosa en EXPR concordante con el PATRÓN se toma como un delimitador
que divide EXPR en subcadenas (llamadas "I<campos>") que B<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 C<b> en C<'abc'> como separador para producir la salida C<a:c>. Sin
embargo, esto:

    print join(':', split(//, 'abc')), "\n";

utiliza las coincidencias de cadena vacía como separadores para producir la
salida C<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 L<C<split>|/split E<sol>PATRÓNE<sol>,EXPR,LÍMITE>,
el patrón vacío indicado en la sintaxis del L<operador de
coincidencia|perlop/"m/PATRÓN/msixpodualngc"> (C<//>), 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 C</^/>, entonces se trata como si estuviera presente el
L<modificador multilínea|perlreref/OPERADORES> (C</^/m>), ya que de lo
contrario no serviría de mucho.

Como otro caso especial, L<C<split>|/split E<sol>PATRÓNE<sol>,EXPR,LÍMITE>
emula el comportamiento predeterminado de la herramienta de línea de comando
B<awk> cuando el PATRÓN se omite o es una I<cadena literal> compuesta de un
único carácter de espacio (tal como S<C<' '>> o S<C<"\x20">>, pero no, por
ejemplo, S<C</ />>). 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 C</\s+/>; en particular, esto significa que I<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
S<C</ />> en lugar de la cadena S<C<" ">>, 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 S<C<" ">> 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 S<C<" ">>.

Si se omite, el PATRÓN por defecto es un único espacio, S<C<" ">>, lo que
provoca el comportamiento de la emulación I<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 C<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 C<abc>, y esto:

    print join(':', split(//, 'abc', 2)), "\n";

produce la salida C<a:bc>, y cada uno de estos:

    print join(':', split(//, 'abc', 3)), "\n";
    print join(':', split(//, 'abc', 4)), "\n";

produce la salida C<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 C<a:b:c>, pero lo siguiente:

    print join(':', split(/,/, 'a,b,c,,,', -1)), "\n";

produce la salida C<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 C<: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 S<C< :a:b:c>> (en lugar de S<C<: :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 S<C< :a:b:c:>>.

Si el PATRÓN contiene L<grupos de captura|perlretut/Agrupando cosas y
coincidencia jerárquica>, 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
L<retrorreferencias|perlretut/Retrorreferencias>); si algún grupo no coincide,
entonces captura el valor L<C<undef>|/undef EXPR> 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 B<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')

=item sprintf FORMATO, LISTA
X<sprintf>

=for Pod::Functions formatted print into a string

Devuelve una cadena formateada por los habituales convenios de
L<C<printf>|/printf IDENTIFICADOR_ARCHIVO FORMATO, LISTA> de la función de
biblioteca L<C<sprintf>|/sprintf FORMATO, LISTA>. Vea más abajo para detalles
y vea L<sprintf(3)> o L<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 L<C<sprintf>|/sprintf FORMATO, LISTA>: emula la
función del C L<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 L<sprintf(3)> regional, por lo tanto, no
estarán disponibles desde Perl.

A diferencia de L<C<printf>|/printf IDENTIFICADOR_ARCHIVO FORMATO, LISTA>,
L<C<sprintf>|/sprintf FORMATO, LISTA> 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 L<C<sprintf>|/sprintf FORMATO, LISTA> 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 C<%e>, C<%E>, C<%g> y C<%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 C<%a> y C<%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 C<%> y la letra de formato, puede especificar varios atributos
adicionales controlando la interpretación del formato. En fin, estos son:

=over 4

=item índice de parámetro de formato

Un explícito índice de parámetros de formato, tales como C<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"

=item 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>"

=item 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
C<.> 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 C<*> antes de C<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 C<*2$v>; por ejemplo:

  printf '%*4$vX %*4$vX %*4$vX',       # 3 direcciones IPv6
          @addr[1..3], ":";

=item 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 C<*>) o de un argumento
determinado (por ejemplo, con C<*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 C<*> es negativo, tiene el mismo
efecto que el indicador C<->: alineación a la izquierda.

=item precisión, o ancho máximo
X<precision> X<precisión>

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 C<.> seguido de un número. Para formatos en punto flotante excepto C<g>
y C<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 C<.*> o de
un argumento específico (ejemplo, con C<.*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 C<*> 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>"

=item size

Para conversiones numéricas, se puede especificar el tamaño del número a
interpretar usando C<l>, C<h>, C<V>, C<q>, C<L>, o C<ll>. Para las conversiones
de entero (C<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 L<C<printf>|warnings> 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 L<Config>:

    use Config;
    if ($Config{use64bitint} eq "define"
        || $Config{longsize} >= 8) {
        print "¡quads divertidos!\n";
    }

Para las conversiones de punto flotante (C<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 C<q>, C<L>, o
C<ll> si la plataforma es compatible con ellas. Puede averiguar si su Perl
soporta dobles a través de L<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 L<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 C<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.

=item orden de los argumentos

Normalmente, L<C<sprintf>|/sprintf FORMATO, LISTA> toma el siguiente argumento
utilizado como el valor de formato para cada especificación de formato. Si la
especificación de formato utiliza C<*> para exigir argumentos adicionales,
estos se consumen de la lista de argumentos en el orden en que aparecen en la
especificación del formato I<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 C<$a> para el ancho, C<$b> para la precisión, y C<$c> como el valor a
formatear; mientras:

  printf '<%*1$.*s>', $a, $b;

usaría C<$a> para el ancho y precisión, y C<$b> como el valor a formatear.

Éstos son algunos ejemplos más; sea consciente de que cuando se utiliza un
índice explícito, el C<$> 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"

=back

Si L<C<use locale>|locale> (incluyendo C<use locale ':not_characters'>) está
en activo y se ha llamado a L<C<POSIX::setlocale>|POSIX/C<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 C<LC_NUMERIC>. Ver
L<perllocale> y L<POSIX>.

=item sqrt EXPR
X<sqrt> X<root> X<square root> X<raíz cuadrada>

=item sqrt

=for Pod::Functions square root function

Devuelve la raíz cuadrada positiva de EXPR. Si se omite EXPR, usa
L<C<$_>|perlvar/$_>. Sólo funciona para operandos no negativos a menos que
haya cargado el módulo L<C<Math::Complex>|Math::Complex>.

    use Math::Complex;
    print sqrt(-4);    # imprime 2i

=item srand EXPR
X<srand> X<seed> X<randseed>

=item srand

=for Pod::Functions seed the random number generator

Establece y devuelve la semilla de números aleatorios para el operador
L<C<rand>|/rand EXPR>.

La misión de la función es "alimentar" a la función L<C<rand>|/rand EXPR>
para que pueda producir una secuencia diferente cada vez que ejecute su
programa. Cuando se llama con un parámetro, L<C<srand>|/srand EXPR> 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 I<solo> en un Perl de una cosecha reciente:

    use 5.014;	# así srand devuelve la semilla

Si L<C<srand>|/srand EXPR> no se llama de forma explícita, se llama
implícitamente en el primer uso del operador L<C<rand>|/rand EXPR>. Hay, sin
embargo, unas pocas situaciones donde es probable que desee llamar a
L<C<srand>|/srand EXPR>. Una de ellas es para la generación de resultados
predecibles, generalmente para pruebas o depuraciones. Así, puede utilizar
C<srand($semilla)>, con la misma C<$semilla> cada vez. Otro caso es que puede
llamar a L<C<srand>|/srand EXPR> después de un L<C<fork>|/fork> para evitar
que los procesos hijos compartan el mismo valor de semilla que la del padre (y
por lo tanto, entre sí).

B<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
L<C<srand>|/srand EXPR> realmente hace I<perder> la aleatoriedad.

La mayoría de las implementaciones de L<C<srand>|/srand EXPR> toman un número
entero y silenciosamente truncará los números decimales. Esto significa que
C<srand(42)> produce los mismos resultados, generalmente, que C<srand(42.1)>.
Para estar seguros, siempre pase un entero a L<C<srand>|/srand EXPR>.

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.

B<L<C<rand>|/rand EXPR> 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 L<Data::Entropy>, L<Crypt::Random>, L<Math::Random::Secure> y
L<Math::TrulyRandom>.

=item stat IDENTIFICADOR_ARCHIVO
X<stat> X<file, status> X<ctime> X<archivo, estado>

=item stat EXPR

=item stat IDENTIFICADOR_DIR

=item stat

=for Pod::Functions get a file's status information

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
L<C<$_>|perlvar/$_> (¡no C<_>!). Devuelve la lista vacía si L<C<stat>|/stat
IDENTIFICADOR_ARCHIVO> 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 L<perlport/"Archivos y sistemas de
archivos"> para más detalles.

Si a L<C<stat>|/stat IDENTIFICADOR_ARCHIVO> 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 L<C<stat>|/stat IDENTIFICADOR_ARCHIVO>, L<C<lstat>|/lstat
IDENTIFICADOR_ARCHIVO>, 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 C<"%o"> si desea ver los
permisos reales.

    my $modo = (stat($archivo))[2];
    printf "Permisos son %04o\n", $modo & 07777;

En contexto escalar, L<C<stat>|/stat IDENTIFICADOR_ARCHIVO> 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 C<_>.

El módulo L<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 (C<S_IF*>) y funciones (C<S_IS*>) desde
el módulo L<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 C<-u> y C<-d>.
Comúnmente disponibles las constantes C<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 C<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 L<chmod(2)> y L<stat(2)> para obtener
más detalles acerca de las constantes C<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 L<C<lstat>|/lstat IDENTIFICADOR_ARCHIVO>.

Cuestiones de portabilidad: L<perlport/stat>.

=item state LISTAVAR
X<state>

=item state TIPO LISTAVAR

=item state LISTAVAR: ATRIBUTOS

=item state TIPO LISTAVAR : ATRIBUTOS

=for Pod::Functions +state declare and assign a persistent lexical variable

L<C<state>|/state LISTAVAR> declara una variable de ámbito léxico, como lo
hace L<C<my>|/my LISTAVAR>. 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 L<perlsub/"Variables privadas persistentes"> 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 L<C<undef>|/undef EXPR> 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.

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


=item study ESCALAR
X<study>

=item study

=for Pod::Functions optimize input data for repeated searches

B<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 (L<C<$_>|perlvar/$_> 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 L<C<study>|/study ESCALAR> 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 C<'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 C</\bfoo\b/>, los únicos lugares que se examinarán de
L<C<$_>|perlvar/$_> serán los que contengan una C<f>, debido a que C<f> es
más rara que una C<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 L<C<eval>|/eval EXPR>, para evitar tener que volver a recompilar
todos los patrones todo el tiempo. Junto con la indefinición de
L<C<$E<sol>>|perlvar/$E<sol>> 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 L<fgrep(1)>. Lo siguiente examina una lista de
archivos (C<@archivos>) por una lista de palabras (C<@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";
    }

=item sub NOMBRE BLOQUE
X<sub>

=item sub NOMBRE (PROTO) BLOQUE

=item sub NOMBRE : ATRIBS BLOQUE

=item sub NOMBRE (PROTO) : ATRIBS BLOQUE

=for Pod::Functions declare a subroutine, possibly anonymously

Esta es la definición de subrutina, no una función real I<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 L<perlsub> y L<perlref> para los detalles acerca de subrutinas y
referencias; vea L<attributes> y L<Attribute::Handlers> para obtener más
información acerca de los atributos.

=item __SUB__
X<__SUB__>

=for Pod::Functions +current_sub the current subroutine, or C<undef> if not in a subroutine

Un I<token> especial que devuelve una referencia a la subrutina actual, o
L<C<undef>|/undef EXPR> si está fuera de una subrutina.

El comportamiento de L<C<__SUB__>|/__SUB__> dentro de un bloque de código con
una expresión regular (como en C</(?{...})/>) está sujeto a cambio.

Este I<token> sólo está disponible bajo C<use v5.16> o la característica
L<C<"current_sub"> feature|feature/La característica 'current_sub'>. Ver
L<feature>.

=item substr EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO
X<substr> X<substring> X<mid> X<left> X<right>

=item substr EXPR,DESPLAZAMIENTO,LONGITUD

=item substr EXPR,DESPLAZAMIENTO

=for Pod::Functions get or alter a portion of a string

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 L<C<substr>|/substr
EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO> 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 L<C<sprintf>|/sprintf
FORMATO, LISTA>.

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, L<C<substr>|/substr
EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO> 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 L<C<substr>|/substr
EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO> 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 L<C<splice>|/splice ARRAY,DESPLAZAMIENTO,LONGITUD,LISTA>.

    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 L<C<substr>|/substr EXPR,DESPLAZAMIENTO,LONGITUD,REEMPLAZO>
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.

=item symlink ARCHIVO_VIEJO,ARCHIVO_NUEVO
X<symlink> X<link> X<symbolic link> X<link, symbolic> X<enlace simbólico> X<enlace>

=for Pod::Functions create a symbolic link to a file

Crea un nuevo nombre de archivo vinculado simbólicamente al nombre del archivo
antiguo. Devuelve C<1> en caso de éxito; de otra manera, C<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: L<perlport/symlink>.

=item syscall NÚMERO, LISTA
X<syscall> X<system call> X<llamada del sistema>

=for Pod::Functions execute an arbitrary system call

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 L<C<syscall>|/syscall NÚMERO, LISTA> 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 C<0> para obligarles a que se
parezcan a números. Esto emula la función L<C<syswrite>|/syswrite
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> (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, L<C<syscall>|/syscall NÚMERO, LISTA> devuelve
C<-1> y establece L<C<$!>|perlvar/$!> (errno). Tenga en cuenta que algunas
llamadas al sistema I<pueden> legalmente devolver C<-1>. La forma correcta de
gestionar llamadas de ese tipo es el de asignar C<$! = 0> antes de la llamada,
y comprobar el valor de L<C<$!>|perlvar/$!> si L<C<syscall>|/syscall NÚMERO,
LISTA> devuelve C<-1>.

Hay un problema con C<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 L<C<pipe>|/pipe
IDENTIFICADOR_LECTURA,IDENTIFICADOR_ESCRITURA>.

Cuestiones de portabilidad: L<perlport/syscall>.

=item sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO
X<sysopen>

=item sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO,PERMISOS

=for Pod::Functions +5.002 open a file, pipe, or descriptor

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 L<open(2)> con los parámetros
ARCHIVO, MODO y PERMISOS.

Devuelve verdadero cuando tiene éxito, y L<C<undef>|/undef EXPR> 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 L<C<Fcntl>|Fcntl>.
Consulte la documentación de la llamada del sistema L<open(2)> de su sistema
operativo para ver qué valores y bit de indicadores están disponibles. Puede
combinar varios indicadores con el operador C<|>.

Algunos de los valores más comunes son C<O_RDONLY> para abrir el archivo en
modo de sólo lectura, C<O_WRONLY> para abrir el archivo en modo de sólo
escritura, y C<O_RDWR> para abrir el archivo en modo lectura-escritura.
X<O_RDONLY> X<O_RDWR> X<O_WRONLY>

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 I<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 L<C<open>|/open
IDENTIFICADOR_ARCHIVO,EXPR> lo crea (por lo general porque el modo incluye el
indicador C<O_CREAT>), entonces el valor de PERMISOS especifica los permisos
del archivo recién creado. Si se omite el argumento PERMISOS a
L<C<sysopen>|/sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO>, Perl utiliza
el valor octal C<0666>. Estos valores de permisos tiene que estar en octal, y
se modifican por el valor de L<C<umask>|/umask EXPR> de su proceso actual.
X<O_CREAT>

En muchos sistemas el indicador C<O_EXCL> está disponible para abrir archivos
en modo exclusivo. Esto B<no> es bloquear: la exclusividad significa aquí que
si el archivo ya existe, L<C<sysopen>|/sysopen
IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO> falla. C<O_EXCL> quizás no funcione
en sistemas de archivos en red, y no tiene ningún efecto a menos que el
indicador C<O_CREAT> también esté establecido. Estableciendo
C<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. X<O_EXCL>

A veces puede querer truncar un archivo ya existente. Esto se puede hacer con
el uso del indicador C<O_TRUNC>. El comportamiento de C<O_TRUNC> con
C<O_RDONLY> no está definido. X<O_TRUNC>

Rara vez o nunca debe utilizar C<0644> como argumento a L<C<sysopen>|/sysopen
IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO>, porque eso le quita al usuario la
opción de tener un umask más permisivo. Es mejor omitirlo. Vea
L<C<umask>|/umask EXPR> para más detalles sobre esto.

Tenga en cuenta que bajo Perl anteriores a 5.8.0, L<C<sysopen>|/sysopen
IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO> depende de la función de biblioteca
C L<fdopen(3)>. En muchos sistemas Unix, L<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 L<C<POSIX::open>|POSIX/C<open>>. Para las
versiones de Perl 5.8.0 y posteriores, PerlIO es (casi siempre) el valor
predeterminado.

Ver L<perlopentut> para una más amable, más suave explicación de apertura de
los archivos.

Cuestiones de portabilidad: L<perlport/sysopen>.

=item sysread IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO
X<sysread>

=item sysread IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD

=for Pod::Functions fixed-length unbuffered input from a filehandle

Intenta leer LONGITUD bytes de datos en la variable ESCALAR desde el
IDENTIFICADOR_ARCHIVO especificado, utilizando L<read(2)>. Omite E/S con
búfer, por lo que mezclar esto con otros tipos de lecturas, L<C<print>|/print
IDENTIFICADOR_ARCHIVO LISTA>, L<C<write>|/write IDENTIFICADOR_ARCHIVO>,
L<C<seek>|/seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>, L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO> o L<C<eof>|/eof IDENTIFICADOR_ARCHIVO> 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, C<0> al final del archivo, o
undef si hubo un error (en este último caso se actualiza el valor de
L<C<$!>|perlvar/$!>). 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 C<"\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, 
L<C<eof>|/eof IDENTIFICADOR_ARCHIVO> no funciona bien con los archivos de
dispositivo (como los ttys). Use L<C<sysread>|/sysread
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> 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 C<:utf8>,
se leen caracteres Unicode en lugar de bytes (la LONGITUD, el DESPLAZAMIENTO y
el valor de retorno de L<C<sysread>|/sysread
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> están descritos en
forma de número de caracteres Unicode). La capa C<:encoding(...)> introduce,
implícitamente, la capa C<:utf8>. Vea L<C<binmode>|/binmode
IDENTIFICADOR_ARCHIVO, CAPA>, L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> y el
I<pragma> L<open>

=item sysseek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE
X<sysseek> X<lseek>

=for Pod::Functions +5.004 position I/O pointer on handle used with sysread and syswrite

Establece la posición del IDENTIFICADOR_ARCHIVO en bytes usando L<lseek(2)>.
IDENTIFICADOR_ARCHIVO puede ser una expresión cuyo valor da el nombre del
identificador de archivo. Los valores de DÓNDE son C<0> para establecer la
nueva posición a POSICIÓN; C<1> para establecerla a la actual más POSICIÓN;
y C<2> para establecerla a EOF más POSICIÓN, normalmente negativa.

Nota sobre lo de I<en bytes>: incluso si el identificador de archivo se ha
establecido para operar en caracteres (por ejemplo usando la capa de open
C<:encoding(utf8)>), L<C<tell>|/tell IDENTIFICADOR_ARCHIVO> devolverá
desplazamientos en bytes, no en caracteres (porque implementando esto
convertirían en inaceptablemente lentas a L<C<seek>|/seek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> y L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO>).

L<C<sysseek>|/sysseek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> omite el búfer
normal de E/S, por lo que mezclar esto con otros tipos de lecturas distintas de
L<C<sysread>|/sysread IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>
(por ejemplo L<C<readline>|/readline EXPR> o L<C<read>|/read
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>), L<C<print>|/print
IDENTIFICADOR_ARCHIVO LISTA>, L<C<write>|/write IDENTIFICADOR_ARCHIVO>,
L<C<seek>|/seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>, L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO>, o L<C<eof>|/eof IDENTIFICADOR_ARCHIVO> pueden causar
confusión.

Para DÓNDE puede usar también las constantes C<SEEK_SET>, C<SEEK_CUR> y
C<SEEK_END> (inicio del archivo, posición actual y fin de archivo) desde el
módulo L<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 C<"0 but true"> (I<"0 pero
verdadero">), por lo que L<C<sysseek>|/sysseek
IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> devuelve verdadero o falso en caso de
error, sin embargo, usted puede determinar fácilmente la nueva posición.

=item system LISTA
X<system> X<shell>

=item system PROGRAMA LISTA

=for Pod::Functions run a separate program

Hace exactamente lo mismo que L<C<exec>|/exec LISTA>, 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 C</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 C<execvp>, que es más eficiente. En
Windows, solo la sintaxis de objetos indirecto en C<system PROGRAMA LISTA>
evitará, de forma efectiva, evitar usar la shell; C<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 L<perlport>). Para estar seguros, puede
necesitar establecer L<C<$E<verbar>>|perlvar/$E<verbar>> ($AUTOFLUSH en el
módulo L<English>) o llamar el método C<autoflush> de
L<C<IO::Handle>|IO::Handle/METHODS> 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
L<C<wait>|/wait>. Para obtener el valor real de la salida, se debe desplazar
ocho a la derecha (ver más abajo). Vea también L<C<exec>|/exec LISTA>. Esto
I<no> es lo que desea utilizar para capturar la salida de un comando; para ello
debería utilizar solamente las comillas invertidas o
L<C<qxE<sol>>|/qxE<sol>CADENAE<sol>>, como se describe en L<perlop/"`CADENA`">.
El valor de retorno de -1 indica un error en el arranque del programa o un
error de la llamada al sistema L<wait(2)> (inspeccionar L<C<$!>|perlvar/$!>
para saber la razón).

Si desea hacer que L<C<system>|/system LISTA> (y muchos otros fragmentos de
Perl) mueran en caso de error, eche un vistazo al I<pragma> L<autodie>.

Al igual que L<C<exec>|/exec LISTA>, L<C<system>|/system LISTA> permite reposar
a un programa bajo un nombre, si se utiliza la sintaxis C<system PROGRAMA
LISTA>. De nuevo, vea también L<C<exec>|/exec LISTA>.

Puesto que C<SIGINT> y C<SIGQUIT> se ignoran durante la ejecución de
L<C<system>|/system LISTA>, 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 L<C<system>|/system LISTA>, puede
comprobar todas las posibles causas del error mediante la inspección de
L<C<$?>|perlvar/$?> 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
L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}> con las llamadas
L<C<W*()>|POSIX/C<WIFEXITED>> desde el módulo L<POSIX>.

Cuando los argumentos de L<C<system>|/system LISTA> se ejecutan indirectamente
por el shell, los resultados y los códigos de retorno están sujetos a sus
caprichos. Vea L<perlop/"`CADENA`"> y L<C<exec>|/exec LISTA> para más
detalles.

Debido a que L<C<system>|/system LISTA> hace un L<C<fork>|/fork> y un
L<C<wait>|/wait> puede afectar al controlador C<SIGCHLD>. Vea L<perlipc> para
más detalles.

Cuestiones de portabilidad: L<perlport/system>.

=item syswrite IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO
X<syswrite>

=item syswrite IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD

=item syswrite IDENTIFICADOR_ARCHIVO,ESCALAR

=for Pod::Functions fixed-length unbuffered output to a filehandle

Intenta escribir LONGITUD bytes de datos desde la variable ESCALAR al
IDENTIFICADOR_ARCHIVO especificado, utilizando L<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 C<sysread)>), L<C<print>|/print
IDENTIFICADOR_ARCHIVO LISTA>, L<C<write>|/write IDENTIFICADOR_ARCHIVO>,
L<C<seek>|/seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>, L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO>, o L<C<eof>|/eof IDENTIFICADOR_ARCHIVO> pueden provocar
confusión porque las capas perlio y stdio normalmente almacenan datos.
Devuelve el número de bytes realmente escritos, o L<C<undef>|/undef EXPR> si
hubo un error (en este caso, también se establece la variable
L<C<$!>|perlvar/$!>). 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.

B<ADVERTENCIA>: Si el identificador de archivo está marcado como C<:utf8>, se
escriben caracteres Unicode codificados en UTF-8 en lugar de bytes, y la
LONGITUD, DESPLAZAMIENTO y el valor de retorno de L<C<syswrite>|/syswrite
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO> se basarán en
caracteres (Unicode codificados en UTF-8). La capa C<:encoding(...)>
implícitamente introduce la capa C<: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 L<C<binmode>|/binmode IDENTIFICADOR_ARCHIVO, CAPA>,
L<C<open>|/open IDENTIFICADOR_ARCHIVO,EXPR> y el I<pragma> L<open>.

=item tell IDENTIFICADOR_ARCHIVO
X<tell>

=item tell

=for Pod::Functions get current seekpointer on a filehandle

Devuelve la posición actual I<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 I<en bytes>: incluso si el identificador de archivo se ha
establecido para operar en caracteres (por ejemplo usando la capa de open
C<:encoding(utf8)>), L<C<tell>|/tell IDENTIFICADOR_ARCHIVO> devolverá
desplazamientos en bytes, no en caracteres (porque esto convertirían en lentas
a L<C<seek>|/seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE> y L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO>).

El valor de retorno de L<C<tell>|/tell IDENTIFICADOR_ARCHIVO> para los flujos
estándares como STDIN depende del sistema operativo: puede devolver -1 o algo
más. L<C<tell>|/tell IDENTIFICADOR_ARCHIVO> en tuberías, colas, y I<sockets>,
por lo general, devuelve -1.

No existe la función C<systell>. Use C<sysseek($fh, 0, 1)> para eso.

No utilice L<C<tell>|/tell IDENTIFICADOR_ARCHIVO> (u otras operaciones de E/S
con búfer) en un identificador de archivo que se ha manipulado con
L<C<sysread>|/sysread IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>,
L<C<syswrite>|/syswrite IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>
o L<C<sysseek>|/sysseek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE>. Esas funciones
ignoran el sistema de búfer, mientras que L<C<tell>|/tell
IDENTIFICADOR_ARCHIVO>, no.

=item telldir IDENTIFICADOR_DIR
X<telldir>

=for Pod::Functions get current seekpointer on a directory handle

Devuelve la posición actual de las rutinas L<C<readdir>|/readdir
IDENTIFICADOR_DIR> en IDENTIFICADOR_DIR. El valor se puede indicar a
L<C<seekdir>|/seekdir IDENTIFICADOR_DIR,POSICIÓN> para acceder a un lugar
determinado en un directorio. L<C<telldir>|/telldir IDENTIFICADOR_DIR> también
tiene las mismas advertencias sobre la posible compactación del directorio
como la correspondiente rutina del sistema.

=item tie VARIABLE,NOMBRE_CLASE,LISTA
X<tie>

=for Pod::Functions +5.002 bind a variable to an object class

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, C<TIESCALAR>, C<TIEHANDLE>,
C<TIEARRAY>, o C<TIEHASH>). Por lo general estos son argumentos que se podrían
transmitir a la función del C L<dbm_open(3)>. El objeto devuelto por el
constructor también se devuelve por la función L<C<tie>|/tie
VARIABLE,NOMBRE_CLASE,LISTA>, que será útil si desea tener acceso a otros
métodos en CLASE.

Note que las funciones como L<C<keys>|/keys HASH> y L<C<values>|/values HASH>
pueden devolver listas largas cuando se usan con grandes objetos, como los
archivos DBM. Puede preferir usar la función L<C<each>|/each HASH> 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 L<perltie>,
L<Tie::Hash>, L<Tie::Array>, L<Tie::Scalar>, y L<Tie::Handle>.

A diferencia de L<C<dbmopen>|/dbmopen HASH,NOMBRE_BASE_DATOS,MÁSCARA>, la
función L<C<tie>|/tie VARIABLE,NOMBRE_CLASE,LISTA> no usará L<C<use>|/use
Módulo VERSIÓN LISTA> o L<C<require>|/require VERSIÓN> de un módulo por
usted; necesitará hacerlo de forma explícita. Vea L<DB_File> o el módulo
L<Config> para implementaciones interesantes de L<C<tie>|/tie
VARIABLE,NOMBRE_CLASE,LISTA>.

Para más detalles, vea L<perltie>, L<C<tied>|/tied VARIABLE>.

=item tied VARIABLE
X<tied>

=for Pod::Functions get a reference to the object underlying a tied variable

Devuelve una referencia al objeto subyacente en VARIABLE (el mismo valor que
fue devuelto originalmente por la llamada L<C<tie>|/tie
VARIABLE,NOMBRE_CLASE,LISTA> que enlazaba la variable a un paquete). Devuelve
el valor indefinido si la VARIABLE no está atada a un paquete.

=item time
X<time> X<epoch>

=for Pod::Functions return number of seconds since 1970

Devuelve el número de segundos no bisiestos desde el momento en que el sistema
considera que es el I<epoch>, apto para alimentar a L<C<gmtime>|/gmtime EXPR> y
L<C<localtime>|/localtime EXPR>. En la mayoría de los sistemas el I<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
L<Time::HiRes> de Perl 5.8 (o desde CPAN antes de él), o si tiene
L<gettimeofday(2)>, puede utilizar el interfaz L<C<syscall>|/syscall NÚMERO,
LISTA> de Perl. Vea L<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 L<DateTime>.

=item times
X<times>

=for Pod::Functions return elapsed time for self and child processes

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, L<C<times>|/times> devuelve C<$usuario>.

Los tiempos de los hijos solo se incluyen de los hijos terminados.

Cuestiones de portabilidad: L<perlport/times>.

=item tr///

=for Pod::Functions transliterate a string

El operador de transliteración. Lo mismo que
L<C<yE<sol>E<sol>E<sol>>|/yE<sol>E<sol>E<sol>>. Vea L<perlop/"Operadores
entrecomillados">.

=item truncate IDENTIFICADOR_ARCHIVO,LONGITUD
X<truncate>

=item truncate EXPR,LONGITUD

=for Pod::Functions shorten a file

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 L<C<undef>|/undef
EXPR> 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
L<seek|/"seek IDENTIFICADOR_ARCHIVO,POSICIÓN,DÓNDE"> antes de escribir al
archivo.

Cuestiones de portabilidad: L<perlport/truncate>.

=item uc EXPR
X<uc> X<uppercase> X<toupper> X<mayúsculas>

=item uc

=for Pod::Functions return upper-case version of a string

Devuelve una versión de EXPR, en mayúsculas. Esta es la función interna del
escapado C<\U> en las cadenas doblemente entrecomilladas. No intentará hacer
un mapeo de mayúsculas con tilder en las letras iniciales. Vea
L<C<ucfirst>|/ucfirst EXPR> para eso.

Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

Esta función se comporta de la misma manera bajo varios I<pragmas>, como por
ejemplo en una configuración regional, como lo hace L<C<lc>|/lc EXPR>.

=item ucfirst EXPR
X<ucfirst> X<uppercase> X<mayúscula>

=item ucfirst

=for Pod::Functions return a string with just the next letter in upper case

Devuelve el valor de EXPR con el primer carácter en mayúsculas. Esta es la
función interna del escapado C<\u> en las cadenas doblemente entrecomilladas.

Si se omite EXPR, usa L<C<$_>|perlvar/$_>.

Esta función se comporta de la misma manera bajo varios I<pragmas>, como por
ejemplo en una configuración regional, como lo hace L<C<lc>|/lc EXPR>.

=item umask EXPR
X<umask>

=item umask

=for Pod::Functions set file creation mode mask

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 C<rwxr-x---> son representados como tres conjuntos de tres
bits, o tres dígitos octales: C<0750> (el 0 precedente indica que es octal, y
que no es uno de los dígitos). El valor de L<C<umask>|/umask EXPR> es un
número que representa los bits de los permisos que quedan desactivados. El
valor de permiso (o "modo") que se pasa a L<C<mkdir>|/mkdir
NOMBRE_ARCHIVO,MÁSCARA> o L<C<sysopen>|/sysopen
IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO> se modifican por su umask, así que
incluso si usted le pide a L<C<sysopen>|/sysopen
IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO> crear un archivo con permisos
C<0777>, y su umask es C<0022>, entonces el archivo realmente se crea con
permisos C<0755>. Si su L<C<umask>|/umask EXPR> fuera C<0027> (el grupo no
puede escribir; los otros no pueden leer, escribir o ejecutar), entonces
pasando a L<C<sysopen>|/sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO>
C<0666> creará un archivo con el modo C<0640> (porque C<0666 &~ 027> es
C<0640>).

Aquí, un consejo: suministre un modo de creación de C<0666> para archivos
regulares (en L<C<sysopen>|/sysopen IDENTIFICADOR_ARCHIVO,NOMBRE_ARCHIVO,MODO>)
y uno de C<0777> para directorios (en L<C<mkdir>|/mkdir
NOMBRE_ARCHIVO,MÁSCARA>) 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 C<022>, C<027>, o incluso la máscara,
particularmente antisocial, de C<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 I<cookies> del navegador web, archivos F<.rhosts>, y
así sucesivamente.

Si L<umask(2)> no está implementada en su sistema y está tratando de
restringir el acceso por I<sí mismo> (es decir, C<< (EXPR & 0700) > 0 >>), se
lanza una excepción. Si L<umask(2)> no está implementado y usted no está
tratando de restringir el acceso por sí mismo, devuelve L<C<undef>|/undef
EXPR>.

Recuerde que un umask es un número, generalmente indicado en octal; I<no> es
una cadena de dígitos octales. Vea también L<C<oct>|/oct EXPR> si todo lo que
tiene es una cadena.

Cuestiones de portabilidad: L<perlport/umask>.

=item undef EXPR
X<undef> X<undefine> X<indefine>

=item undef

=for Pod::Functions remove a variable or function definition

Indefine el valor de EXPR, que debe ser un valor-izquierda. Use solamente sobre
un valor escalar, un array (usando C<@>), un hash (con C<%>), una subrutina
(con C<&>), o un typeglob (usando C<*>). Decir C<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
L<C<delete>|/delete EXPR>. 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.

=item unlink LISTA
X<unlink> X<delete> X<remove> X<rm> X<del> X<elimina> X<borra>

=item unlink

=for Pod::Functions remove one link to a file

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 L<C<$!>|perlvar/$!> (errno):

    my $unlinked = unlink 'a', 'b', 'c';
    unlink @goners;
    unlink glob "*.bak";

En caso de error, L<C<unlink>|/unlink LISTA> 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: L<C<unlink>|/unlink LISTA> no intentará eliminar directorios a menos que
usted sea superusuario y se suministre a Perl el indicador B<-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 L<C<unlink>|/unlink
LISTA> en directorios no está soportado en muchos sistemas operativos. Use en
su lugar L<C<rmdir>|/rmdir NOMBRE_DIRECTORIO>.

Si LISTA se omite, L<C<unlink>|/unlink LISTA> utiliza L<C<$_>|perlvar/$_>.

=item unpack PLANTILLA,EXPR
X<unpack>

=item unpack PLANTILLA

=for Pod::Functions convert binary structure into normal perl variables

L<C<unpack>|/unpack PLANTILLA,EXPR> hace lo contrario de L<C<pack>|/pack
PLANTILLA,LISTA>: 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 L<C<$_>|perlvar/$_>. Vea
L<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 L<C<pack>|/pack PLANTILLA,LISTA>, 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 L<C<pack>|/pack
PLANTILLA,LISTA>. 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 L<C<pack>|/pack PLANTILLA,LISTA>, 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 C<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 C<p> y C<P> deben utilizarse con cuidado. Dado que Perl no tiene
manera de comprobar si el valor pasado a L<C<unpack>|/unpack PLANTILLA,EXPR>
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 L<C<unpack>|/unpack PLANTILLA,EXPR> 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 L<C<pack>|/pack PLANTILLA,LISTA> para más ejemplos y notas.

=item unshift ARRAY,LISTA
X<unshift>

=for Pod::Functions prepend more elements to the beginning of a list

Hace lo opuesto de un L<C<shift>|/shift ARRAY>. O lo contrario de un
L<C<push>|/push ARRAY,LISTA>, 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
L<C<reverse>|/reverse LISTA> para hacer lo contrario.

A partir de Perl 5.14, una característica experimental permitía a
L<C<unshift>|/unshift ARRAY,LISTA> tomar una expresión escalar. Se ha
considerado que este experimento no ha funcionado, y se quitó a partir de Perl
5.24.

=item untie VARIABLE
X<untie>

=for Pod::Functions break a tie binding to a variable

Rompe el enlace entre una variable y un paquete. (Vea L<tie|/tie
VARIABLE,NOMBRE_CLASE,LISTA>). No tiene efecto si la variable no está atada.

=item use Módulo VERSIÓN LISTA
X<use> X<module> X<import> X<módulo> X<importar>

=item use Módulo VERSIÓN

=item use Módulo LISTA

=item use Módulo

=item use VERSIÓN

=for Pod::Functions load in a module at compile time and import its namespace

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 I<debe> ser una palabra simple. La importación puede
estar condicionada por medio del módulo L<if>.

En la forma peculiar C<use VERSIÓN>, VERSIÓN puede ser tanto un número
fraccionario decimal positivo, como 5.006, que será comparado con
L<C<$]>|perlvar/$]>, o como una v-cadena de la forma v5.6.1, que se comparará
con L<C<$^V>|perlvar/$^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
L<C<require>|/require VERSIÓN>, que puede hacer un control similar en tiempo
de ejecución. Simétricamente, C<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
L<C<use>|/use Módulo VERSIÓN LISTA> módulos que no funcionarán con
versiones anteriores de Perl. (Tratamos de no hacer esto no más de lo
necesario).

C<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
L<feature>, desactivando cualquier característica no incluida en la versión
solicitada. Ver L<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 L<C<use strict>|strict>. Cualquier uso
explícito de C<use strict> o C<no strict> anula C<use VERSIÓN>, incluso si se
coloca antes de él. Uso posterior de C<use VERSION> sobrecargará todos los
comportamientos de un anterior C<use VERSION>, posiblemente eliminando el
C<strict> y C<feature> añadidos por C<use VERSION>. C<use VERSION> no carga
los archivos F<feature.pm> o F<strict.pm>.

El C<BEGIN> fuerza a ejecutar a L<C<require>|/require VERSIÓN> e
L<C<import>|/import LISTA> en tiempo de compilación. El L<C<require>|/require
VERSIÓN> se asegura que el módulo esté cargado en memoria, si todavía no lo
está. El L<C<import>|/import LISTA> no es una función predefinida; es sólo
una llamada al método estático ordinario en el paquete C<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 L<C<import>|/import
LISTA> de la forma que desee, aunque la mayoría de los módulos sólo eligen
derivar su método L<C<import>|/import LISTA> vía herencia desde la clase
C<Exporter> que se define en el módulo L<C<Exporter>|Exporter>. Ver
L<Exporter>. Si no se puede encontrar ningún método L<C<import>|/import
LISTA> entonces la llamada se pasa por alto, incluso si hay un método
AUTOLOAD.

Si no desea llamar al método L<C<import>|/import LISTA> 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
L<C<use>|/use Módulo VERSIÓN LISTA> 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 L<default C<VERSION> method|UNIVERSAL/C<VERSION ( [ REQUIRE ] )>>
por defecto, heredado de la clase L<C<UNIVERSAL>|UNIVERSAL>, croa si la
versión dada es mayor que el valor de la variable C<$Módulo::VERSIÓN>.

Una vez más, hay una distinción entre omitir LISTA (L<C<import>|/import
LISTA> llamado sin argumentos) y una explícita LISTA vacía C<()>
(L<C<import>|/import LISTA> 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 I<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 L<C<strict>|strict> o L<C<integer>|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 L<C<use>|/use Módulo VERSIÓN LISTA> entra en vigor en tiempo de
compilación, no respeta el control de flujo de operaciones del código
compilado. En particular, poniendo un L<C<use>|/use Módulo VERSIÓN LISTA>
dentro de la rama falsa de un condicional no impide que se procese. Si un
módulo o I<pragma> sólo necesita cargarse en forma condicional, se puede
hacer uso del I<pragma> L<if>:

    use if $] < 5.008, "utf8";
    use if WANT_WARNINGS, warnings => qw(all);

Existe un correspondiente comando L<C<no>|/no Módulo VERSIÓN LISTA> que
des-importa los significados importados por L<C<use>|/use Módulo VERSIÓN
LISTA>, es decir, llama a C<< Módulo->unimport(LISTA) >> en lugar de
L<C<import>|/import LISTA>. Se comporta igual que L<C<import>|/import LISTA> 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 C<no VERSIÓN> de L<C<no>|/no
Módulo VERSIÓN LISTA>. I<Sólo> es para asegurarse de que el perl que se
está ejecutando es de una versión anterior a su argumento y I<no> para
deshacer los efectos colaterales activados por C<use VERSION>.

Ver L<perlmodlib> para una lista de módulos y pragmas estándar. Vea
L<perlrun> para las opciones en línea de comandos C<-M> y C<-m> para Perl que
dan la funcionalidad de L<C<use>|/use Módulo VERSIÓN LISTA> en la línea de
comandos.

=item utime LISTA
X<utime>

=for Pod::Functions set a file's last access and modify times

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 L<touch(1)> de Unix cuando los archivos I<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
L<C<undef>|/undef EXPR>, se llama a la biblioteca del sistema C L<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 L<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 L<C<undef>|/undef EXPR> es
equivalente a pasar un 0 y no tendrá el efecto descrito cuando ambos son
L<C<undef>|/undef EXPR>. Esto también desencadena una advertencia de datos no
inicializados.

En sistemas que soporten L<futimes(2)>, puede pasar identificadores de archivo
entre los archivos. En sistemas que no admiten L<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: L<perlport/utime>.

=item values HASH
X<values>

=item values ARRAY

=for Pod::Functions return a list of the values in a hash

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 L<C<each>|/each
HASH> o L<C<keys>|/keys HASH> se puede borrar sin que cambie el orden. Siempre
y cuando no se modifique un determinado hash puede confiar en que
L<C<keys>|/keys HASH>, L<C<values>|/values HASH> y L<C<each>|/each HASH>
devuelvan repetidamente lo mismo en el mismo orden. Vea L<perlsec/"Ataques de
complejidad algorítmica"> 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 L<C<values>|/values HASH> reinicia el
iterador interno del HASH o ARRAY (vea L<C<each>|/each HASH>). De forma
particular, llamando a L<C<values>|/values HASH> en contexto nulo (void)
reinicia el iterador sin otro efecto. Además de restablecer el iterador,
C<values @array> en contexto lista es lo mismo que un simple C<@array>. (Le
recomendamos que para esto utilice el contexto vacío C<keys @array>, pero
razonando que quitar C<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
L<C<values>|/values HASH> 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
I<sólo> en versiones Perl de cosechas recientes:

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

Vea también L<C<keys>|/keys HASH>, L<C<each>|/each HASH> y L<C<sort>|/sort
NOMBRE_SUB LISTA>.

=item vec EXPR,DESPLAZAMIENTO,BITS
X<vec> X<bit> X<bit vector> X<vectores de bit>

=for Pod::Functions test or set particular bits in a string

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
L<C<pack>|/pack PLANTILLA,LISTA>/L<C<unpack>|/unpack PLANTILLA,EXPR> con
formatos I<big-endian> C<n>/C<N> (Y, análogamente para BITS==64). Vea
L<C<pack>|/pack PLANTILLA,LISTA> 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 C<0x01>, C<0x02>, C<0x04>, C<0x08>,
C<;0x10>, C<0x20>, C<0x40>; C<0x80>. Por ejemplo, rompiendo el byte de entrada
C<chr(0x36)> en dos grupos da una lista C<(0x6, 0x3)>; dividiéndolo en 4
grupos da C<(0x2, 0x1, 0x3, 0x0)>.

L<C<vec>|/vec EXPR,DESPLAZAMIENTO,BITS> 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 L<C<vec>|/vec
EXPR,DESPLAZAMIENTO,BITS>, 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 L<C<vec>|/vec EXPR,DESPLAZAMIENTO,BITS> también se pueden
manipular con los operadores lógicos C<|>, C<&>, C<^>, y C<~>. Estos
operadores asumirán una operación de vector de bits cuando ambos operandos
sean cadenas. Ver L<perlop/"Operadores de bit en cadenas"> .

El código siguiente construirá una cadena ASCII diciendo C<'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 C<*>.

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

=item wait
X<wait>

=for Pod::Functions wait for any child process to die

Se comporta como L<wait(2)> de su sistema: espera a que un proceso hijo termine
y devuelve el PID del proceso que ha fallecido, o C<-1> si no hay procesos
hijos. El estado se devuelve en L<C<$?>|perlvar/$?> y
L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>. Tenga en cuenta
que un valor devuelto de C<-1> podría significar que los procesos hijos se
están automáticamente desechando, como se describe en L<perlipc>.

Si utiliza L<C<wait>|/wait> en su controlador de L<C<$SIG{CHLD}>|perlvar/%SIG>,
puede esperar, accidentalmente, por el hijo creado por
L<C<qx>|/qxE<sol>CADENAE<sol>> o L<C<system>|/system LISTA>. Vea L<perlipc>
para más detalles.

Cuestiones de portabilidad: L<perlport/wait>.

=item waitpid PID,INDICADORES
X<waitpid>

=for Pod::Functions wait for a particular child process to die

Espera que termine un proceso hijo en particular y devuelve el PID del proceso
que ha fallecido, o C<-1> si no existe tal proceso hijo. Una espera no
bloqueante (con L<WNOHANG|POSIX/C<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 L<C<$?>|perlvar/$?> y
L<C<${^CHILD_ERROR_NATIVE}>|perlvar/${^CHILD_ERROR_NATIVE}>.

Un PID de C<0> indica esperar por cualquier proceso hijo cuyo ID de grupo de
proceso es igual al del proceso actual. Un PID de menos que C<-1> indica
esperar por cualquier proceso hijo cuyo ID de grupo de proceso es igual a -PID.
Un PID de C<-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 L<POSIX/WAIT>). Espera no bloqueante está disponible en
máquinas que soporten las llamadas del sistema, tanto L<waitpid(2)> como
L<wait4(2)>. Sin embargo, esperar por un particular pid con INDICADORES a C<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 C<-1> podría
significar que los procesos hijos se están automáticamente desechando. Ver
L<perlipc> para más detalles, y para otros ejemplos.

Cuestiones de portabilidad: L<perlport/waitpid>.

=item wantarray
X<wantarray> X<context> X<contexto>

=for Pod::Functions get void vs scalar vs list context of current subroutine call

Devuelve verdadero si el contexto de ejecución de la subrutina actual o
L<C<eval>|/eval EXPR> 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 L<C<wantarray>|/wantarray> no está especificado en el nivel
superior de un archivo, en un C<BEGIN>, C<UNITCHECK>, C<CHECK>, C<INIT> o
bloque C<END>, o en un método C<DESTROY>.

Esta función debería haber sido nombrada wantlist().

=item warn LISTA
X<warn> X<warning> X<STDERR> X<avisos>

=for Pod::Functions print debugging info

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 L<C<die>|/die LISTA>.

Si la salida está vacía y L<C<$@>|perlvar/$@> ya contiene un valor
(típicamente de un eval anterior) este valor se utiliza después de añadirle
C<"\t...caught"> a L<C<$@>|perlvar/$@>. Esto es útil para mantenerse casi,
pero no del todo, similar a L<C<die>|/die LISTA>.

Si L<C<$@>|perlvar/$@> está vacía entonces se usa la cadena C<"Warning:
Something's wrong">.

Ningún mensaje se imprime si hay instalado un controlador
L<C<$SIG{__WARN__}>|perlvar/%SIG>. Es responsabilidad del controlador tratar el
mensaje como lo considere oportuno (como, por ejemplo, convertirlo en un
L<C<die>|/die LISTA>). 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 L<C<warn>|/warn LISTA>
de nuevo en el controlador. Tenga en cuenta que esto es bastante seguro y no
producirá un bucle sin fin, puesto que los enganches C<__WARN__> no son
llamados desde el interior de uno mismo.

Encontrará que este comportamiento es ligeramente diferente a la de los
controladores L<C<$SIG{__DIE__}>|perlvar/%SIG> (que no suprimen el texto de
error, pero puede llamar, en su lugar, a L<C<die>|/die LISTA> de nuevo para
cambiarlo).

El uso de un controlador C<__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 L<perlvar> para más detalles sobre la configuración de las entradas
L<C<%SIG>|perlvar/%SIG> y para ver más ejemplos. Vea el módulo L<Carp> para
otros tipos de avisos mediante sus funciones C<carp> y C<cluck>.

=item write IDENTIFICADOR_ARCHIVO
X<write>

=item write EXPR

=item write

=for Pod::Functions print a picture record

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 L<C<select>|/select IDENTIFICADOR_ARCHIVO>) se puede establecer de
forma explícita mediante la asignación del nombre del formato a la variable
L<C<$~>|perlvar/$~>.

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 C<_TOP> añadido, o C<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
L<C<$^>|perlvar/$^> mientras esté seleccionado el identificador de archivo. El
número de líneas restantes de la página actual está en la variable
L<C<$->|perlvar/$->, que se puede fijar a C<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
L<C<select>|/select IDENTIFICADOR_ARCHIVO>. 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 L<perlform>.

Tenga en cuenta que write I<no> es lo contrario de L<C<read>|/read
IDENTIFICADOR_ARCHIVO,ESCALAR,LONGITUD,DESPLAZAMIENTO>. Por desgracia.

=item y///

=for Pod::Functions transliterate a string

El operador de transliteración. Lo mismo que
L<C<trE<sol>E<sol>E<sol>>|/trE<sol>E<sol>E<sol>>. Vea L<perlop/"Operadores
entrecomillados">.

=back

=head2 Referencias externas a identificadores que no son funciones

=head3 perldata

=over

=item __DATA__

=item __END__

Estas palabras clave están documentadas en L<perldata/"Literales especiales">.

=back

=head3 perlmod

=over

=item BEGIN

=item CHECK

=item END

=item INIT

=item UNITCHECK

Estas palabras clave de la fase de compilación están documentadas en
L<perlmod/"BEGIN, UNITCHECK, CHECK, INIT y END">.

=back

=head3 perlobj

=over

=item DESTROY

Esta palabra clave de método está documentada en L<perlobj/"Destructores">.

=back

=head3 perlop

=over

=item and

=item cmp

=item eq

=item ge

=item gt

=item le

=item lt

=item ne

=item not

=item or

=item x

=item xor

Estos operadores están documentados en L<perlop>.

=back

=head3 perlsub

=over

=item AUTOLOAD

Esta palabra clave está documentada en L<perlsub/"Autocarga">.

=back

=head3 perlsyn

=over

=item else

=item elsif

=item for

=item foreach

=item if

=item unless

=item until

=item while

Estas palabras clave de control de flujo están documentadas en
L<perlsyn/"Instrucciones complejas">.

=item elseif

La palabra "else if" se escribe como C<elsif> en Perl. No existe ni C<elif> ni
C<else if>. Interpreta C<elseif>, pero solo para avisarle de que no debe
usarlo.

Vea la documentación sobre las palabras clave de control de flujo en
L<perlsyn/"Instrucciones complejas">.

=back

=over

=item default

=item given

=item when

Estas palabras clave de control de flujo relacionadas con la función
experimental switch están documentadas en L<perlsyn/"Instrucciones switch">.

=back

=cut

=head1 TRADUCTORES

=over

=item * Joaquín Ferrero (Tech Lead)

=item * Enrique Nell (Language Lead)

=back