view release on metacpan or  search on metacpan

lib/POD2/ES/perlmod.pod  view on Meta::CPAN

        my $glob = shift;
        print 'He recibido ', *{$glob}{PACKAGE},
            '::', *{$glob}{NAME}, "\n";
    }
    identificar_typeglob *foo;
    identificar_typeglob *bar::baz;

Esto imprime

    Recibí main::foo
    Recibí bar::baz

También se puede usar la notación C<*foo{COSA}> para obtener referencias a
los elementos individuales de *foo. Vea L<perlref>.

Las definiciones de subrutinas (y las definiciones de declaraciones) no tienen
por qué ubicarse en el paquete al que pertenece la tabla de símbolos en que
aparecen. Es posible definir una subrutina fuera del paquete calificando
explícitamente el nombre de la subrutina:

    package main;
    sub Un_paquete::foo { ... }   # &foo definida en Un_paquete

Esto no es más que una forma abreviada de asignación de I<typeglob> en tiempo
de compilación:

    BEGIN { *Un_paquete::foo = sub { ... } }

y I<no> es lo mismo que escribir:

    {
	package Un_paquete;
	sub foo { ... }
    }

En las dos primeras versiones, el cuerpo de la subrutina se define en el
paquete C<main>, I<no> en Un_paquete. De forma que el código siguiente:

    package main;

    $Un_paquete::nombre = "Pedro";
    $main::nombre = "Pablo";

    sub Un_paquete::foo {
	print "en ", __PACKAGE__, ": \$nombre es '$nombre'\n";
    }

    Un_paquete::foo();

imprime:

    en main: $nombre es 'Pablo'

en lugar de:

    en Un_paquete: $nombre es 'Pedro'

Esto también tiene implicaciones para el uso del calificador SUPER:: (vea
L<perlobj>).

=head2 BEGIN, UNITCHECK, CHECK, INIT y END
X<BEGIN> X<UNITCHECK> X<CHECK> X<INIT> X<END>

Hay cinco bloques de código con un nombre especial que se ejecutan al
principio y final de la ejecución de un programa Perl. Son los bloques
C<BEGIN>, C<UNITCHECK>, C<CHECK>, C<INIT> y C<END>.

Estos bloques de código pueden usarse con el prefijo C<sub> para dar la
apariencia de ser subrutinas (aunque esto no se recomienda). Debe tenerse en
cuenta que estos bloques de código no existen realmente como subrutinas con
nombres, aunque así lo parezca. Esto es así porque se puede incluir B<más de
uno> de estos bloques de código en un programa y B<todos> ellos se ejecutarán
en el momento adecuado. Por esta razón no puede ejecutar ninguno de estos
bloques usando su nombre.

Un bloque de código C<BEGIN> se ejecuta tan pronto como es posible, es decir,
en el momento en que está completamente definido, incluso antes del análisis
del resto del archivo (o cadena) que lo contiene. Es posible disponer de varios
bloques C<BEGIN> en el mismo archivo (o cadena evaluada); se ejecutarán por
orden de definición. Puesto que el bloque de código C<BEGIN> se ejecuta
inmediatamente, puede obtener definiciones de subrutinas, etc. de otros
archivos a tiempo para que sean visibles en tiempo de compilación y
ejecución. Una vez ejecutado el bloque C<BEGIN>, pasa a estar no definido y el
código usado se devuelve al banco de memoria de Perl.

El bloque de código C<END> se ejecuta tan tarde como sea posible, es decir,
una vez que Perl ha finalizado la ejecución del programa y justo antes de que
se produzca la salida del intérprete, incluso si la salida se debe a la
ejecución de la función die() (esto no ocurre si se transforma en otro
programa mediante C<exec> o si se desencadena por una señal; el código debe
encargarse de capturar esta señal, si es posible). Puede disponer de
múltiples bloques C<END> en un mismo archivo; se ejecutarán en orden inverso
al de la definición: es decir, siguiendo el orden "primero en llegar, último
en salir" (LIFO, I<last in, first out>). Los bloques C<END> no se ejecutarán
si se inicia perl con el modificador C<-c> o si se produce un error de
compilación.

Tenga en cuenta que los bloques de código C<END> B<no> se ejecutan al final de
una evaluación C<eval()> de cadena: si se crea un bloque C<END> mediante una
función C<eval()> de cadena, se ejecutará como cualquier otro bloque C<END>
del mismo paquete en orden LIFO, justo antes de que se produzca la salida del
intérprete.

Dentro de un bloque de código C<END>, C<$?> contiene el valor que el programa
va a pasar a C<exit()>. Puede modificar C<$?> para cambiar el valor de salida
del programa. Evite cambiar C<$?> accidentalmente (por ejemplo, ejecutando algo
mediante C<system>). X<$?>

Dentro de un bloque C<END>, el valor de C<${^GLOBAL_PHASE}> es C<"END">.

Los bloques C<UNITCHECK>, C<CHECK> e C<INIT> son útiles para capturar la
transición entre la fase de compilación y la de ejecución del programa
principal.

Los bloques C<UNITCHECK> se ejecutan inmediatamente después de que se haya
compilado la unidad que los definió. El archivo del programa principal y cada
módulo que carga son unidades de compilación, como lo son los resultados de
aplicar C<eval> a cadenas, el código compilado en tiempo de ejecución con la
construcción C<(?{ })> en una expresión regular, las llamadas a C<do FILE>,
C<require FILE>,  o el código que hay a continuación del modificador C<-e> en
la línea de comandos.

Los bloques C<BEGIN> y C<UNITCHECK> no están directamente relacionados con la
fase del intérprete. Se pueden crear y ejecutar en cualquier fase.

Los bloques de código C<CHECK> se ejecutan inmediatamente después de que
finalice la fase B<inicial> de compilación de Perl y antes de que comience el
tiempo de ejecución, en orden LIFO. Los bloques de código C<CHECK> se usan en
el compilador de Perl para guardar el estado compilado del programa.

Dentro de un bloque C<CHECK>, el valor de C<${^GLOBAL_PHASE}> es C<"CHECK">.

Los bloques C<INIT> se ejecutan justo antes de iniciar el tiempo de ejecución
de Perl, en orden "primero en entrar, primero en salir " (FIFO, I<first in,
first out>).

Dentro de un bloque C<INIT> el valor de C<${^GLOBAL_PHASE}> será C<"INIT">.

Los bloques C<CHECK> e C<INIT> en código compilado por C<require> y en
funciones C<do> o C<eval> de cadena no se ejecutarán si están después del
final de la fase principal de compilación; esto puede suponer un problema en
el entorno mod_perl y otros entornos permanentes que usan esas funciones para
cargar código en tiempo de ejecución.

Cuando se usan los modificadores B<-n> y B<-p> en Perl, C<BEGIN> y C<END>
funcionan como lo harían en B<awk>, es decir, como un caso degenerado. Los
bloques C<BEGIN> y C<CHECK> se ejecutan cuando se usa el modificador B<-c> para
llevar a cabo únicamente una compilación de comprobación de la sintaxis,
aunque no se ejecute el código principal.

El programa B<begincheck> expone esto de forma clara (o eso esperamos):

  #!/usr/bin/perl

  # begincheck

  print         "10. El código normal se ejecuta en tiempo de ejecución.\n";

  END { print   "16.   Y este cuento se ha acabado.\n" }
  INIT { print  " 7. Los bloques INIT se ejecutan en orden FIFO antes del tiempo de ejecución.\n" }
  UNITCHECK {
    print       " 4.   Y, por tanto, antes que los bloques CHECK.\n"
  }
  CHECK { print " 6.   Esta es la sexta línea.\n" }

  print         "11.   Por supuesto, se ejecuta por orden.\n";

  BEGIN { print " 1. Los bloques BEGIN se ejecutan en orden FIFO durante la compilación.\n" }
  END { print   "15.   Lea perlmod para obtener más información.\n" }
  CHECK { print " 5. Los bloques CHECK se ejecutan en orden LIFO tras la compilación.\n" }
  INIT { print  " 8.   Volvemos a ejecutar esto, ahora con el modificador -c de perl.\n" }

  print         "12.   Esto es lo contrario de código ofuscado.\n";

  END { print   "14. Los bloques END se ejecutan en orden LIFO al finalizar.\n" }
  BEGIN { print " 2.   Así que esta línea será la segunda.\n" }
  UNITCHECK {
   print " 3. Los bloques UNITCHECK se ejecutan en orden LIFO tras compilar cada archivo.\n"
  }
  INIT { print  " 9.   Verá la diferencia inmediatamente.\n" }

  print         "13.   Puede que parezca lioso, pero no lo es en realidad.\n";

  __END__

=head2 Clases en Perl
X<class> X<clase> X<@ISA>

No hay una sintaxis especial para clases en Perl, pero un paquete puede actuar
como una clase si proporciona subrutinas que se comportan como métodos.   Un
paquete así también pueden derivar alguno de sus métodos de otra clase
(paquete) especificando el nombre de este paquete en su array global @ISA, que
debe ser una variable global (no léxica) del paquete.

Encontrará más información en L<perlootut> y L<perlobj>.

=head2 Módulos Perl
X<module> X<módulo>

Un módulo no es más que un conjunto de funciones relacionadas y ubicadas en
un archivo de biblioteca, es decir, un paquete Perl con el mismo nombre que el
archivo. Está diseñado específicamente para que otros módulos o programas
lo puedan reutilizar. Para ello puede proporcionar un mecanismo que exporte
algunos de sus símbolos a la tabla de símbolos de cualquier paquete que lo
use, o puede funcionar como una definición de clase y hacer que su semántica
esté disponible implícitamente mediante llamadas a métodos de la clase y sus
objetos, sin exportar nada de forma explícita. También se pueden combinar
ambos mecanismos.

Por ejemplo, para empezar a desarrollar un módulo tradicional, no orientado a
objetos, llamado Mi::Modulo, cree el archivo F<Mi/Modulo.pm> y use esta
plantilla:

    package Mi::Modulo;  # se supone que está en Mi/Modulo.pm

    use strict;
    use warnings;

    BEGIN {
        require Exporter;

        # establecer la versión para la comprobación de versión
        our $VERSION     = 1.00;

        # heredar de Exporter para exportar funciones y variables
        our @ISA         = qw(Exporter);

        # funciones y variables que se exportan de forma predeterminada
        our @EXPORT      = qw(func1 func2);

        # funciones y variables que se exportan de forma opcional
        our @EXPORT_OK   = qw($Var1 %Hash1 func3);
    }

    # las variables globales de paquete exportadas van aquí
    our $Var1    = '';
    our %Hash1  = ();