Perl Language
Paquetes y módulos

Sintaxis

• requiere Módulo :: Nombre; # Requerir por nombre de @INC
• requiere "ruta / a / archivo.pm"; # Requerir por ruta relativa de @INC
• use Module :: Name; # requiere y la importación por defecto en BEGIN
• use Module :: Name (); # requiere y no importa en BEGIN
• use Module :: Name (@ARGS); # requiere e importa con args en BEGIN
• use Module :: Name VERSION; # requiere, verificación de versión e importación predeterminada en BEGIN
• use Module :: Name VERSION (); # requiere, verifica versión, y no importa en BEGIN
• use Module :: Name VERSION (@ARGS); # require, version check, import con args en BEGIN
• hacer "ruta / a / archivo.pl"; # cargar y evaluar el archivo dado

Ejecutando los contenidos de otro archivo.

do './config.pl';

Esto leerá el contenido del archivo config.pl y lo ejecutará. (Ver también: perldoc -f do .)

NB: Evite do menos que juegue al golf o algo así, ya que no hay comprobación de errores. Para incluir módulos de biblioteca, use require o use .

Cargando un módulo en tiempo de ejecución

require Exporter;

Esto asegurará que el módulo Exporter se cargue en tiempo de ejecución si aún no se ha importado. (Ver también: perldoc -f require .)

NB: La mayoría de los usuarios deberían use módulos en lugar de require . A diferencia del use , require no llama al método de importación del módulo y se ejecuta en tiempo de ejecución, no durante la compilación.

Esta forma de cargar módulos es útil si no puede decidir qué módulos necesita antes del tiempo de ejecución, como con un sistema de complementos:

package My::Module;
my @plugins = qw( One Two );
foreach my $plugin (@plugins) {
    my $module = __PACKAGE__ . "::Plugins::$plugin";
    $module =~ s!::!/!g;
    require "$module.pm";
}

Esto intentaría cargar My::Package::Plugins::One y My::Package::Plugins::Two . @plugins supuesto, @plugins debería provenir de alguna entrada del usuario o un archivo de configuración para que esto tenga sentido. Tenga en cuenta el operador de sustitución s!::!/!g que reemplaza cada par de dos puntos con una barra. Esto se debe a que puede cargar módulos utilizando la sintaxis de nombre de módulo familiar de use solo si el nombre del módulo es una simple palabra. Si pasa una cadena o una variable, debe contener un nombre de archivo.

Usando un modulo

use Cwd;

Esto importará el módulo Cwd en el momento de la compilación e importará sus símbolos predeterminados, es decir, hará que algunas de las variables y funciones del módulo estén disponibles para el código que lo usa. (Ver también: perldoc -f use .)

Generalmente esto es lo que hará lo correcto. A veces, sin embargo, deseará controlar qué símbolos se importan. Agregue una lista de símbolos después del nombre del módulo para exportar:

use Cwd 'abs_path';

Si lo hace, solo se importarán los símbolos que especifique (es decir, el conjunto predeterminado no se importará).

Cuando se importan varios símbolos, es idiomático utilizar la qw() list-building:

use Cwd qw(abs_path realpath);

Algunos módulos exportan un subconjunto de sus símbolos, pero se les puede decir que exporten todo con :all :

use Benchmark ':all';

(Tenga en cuenta que no todos los módulos reconocen o utilizan la etiqueta :all ).

Usando un módulo dentro de un directorio

use lib 'includes';
use MySuperCoolModule;

use lib 'includes'; agrega el directorio relativo includes/ como otra ruta de búsqueda de módulo en @INC . Así que suponga que tiene un archivo de módulo MySyperCoolModule.pm en MySyperCoolModule.pm interior includes/ , que contiene:

package MySuperCoolModule;

Si lo desea, puede agrupar tantos módulos como desee dentro de un solo directorio y hacer que se puedan encontrar con un solo use lib .

En este punto, el uso de las subrutinas en el módulo requerirá el prefijo del nombre de la subrutina con el nombre del paquete:

MySuperCoolModule::SuperCoolSub_1("Super Cool String");

Para poder usar las subrutinas sin el prefijo, debe exportar los nombres de las subrutinas para que el programa las reconozca. La exportación se puede configurar para que sea automática, por lo que:

package MySuperCoolModule;
use base 'Exporter';
our @EXPORT = ('SuperCoolSub_1', 'SuperCoolSub_2');

Luego, en el archivo que use el módulo, esas subrutinas estarán disponibles automáticamente:

use MySuperCoolModule;
SuperCoolSub_1("Super Cool String");

O puede configurar el módulo para exportar subrutinas condicionalmente, de esta manera:

package MySuperCoolModule;
use base 'Exporter';
our @EXPORT_OK = ('SuperCoolSub_1', 'SuperCoolSub_2');

En cuyo caso, debe solicitar explícitamente las subrutinas que desea exportar en el script que use el módulo:

use MySuperCoolModule 'SuperCoolSub_1';
SuperCoolSub_1("Super Cool String");

CPAN.pm

CPAN.pm es un módulo de Perl que permite consultar e instalar módulos desde los sitios de CPAN.

Es compatible con el modo interactivo invocado con

cpan

o

perl -MCPAN -e shell

Módulos de consulta

Por nombre:

cpan> m MooseX::YAML

Por una expresión regular contra el nombre del módulo:

cpan> m /^XML::/

Nota: para habilitar un buscapersonas o redirigir a un uso de archivos | o > redirección de shell (los espacios son obligatorios alrededor de | y > ), por ejemplo: m /^XML::/ | less

Por distribución:

cpan> d LMC/Net-Squid-Auth-Engine-0.04.tar.gz

Instalacion de modulos

Por nombre:

cpan> install MooseX::YAML

Por distribución:

cpan> install LMC/Net-Squid-Auth-Engine-0.04.tar.gz

Listar todos los módulos instalados

Desde la línea de comando:

cpan -l

De un script de Perl:

use ExtUtils::Installed;
my $inst = ExtUtils::Installed->new();
my @modules = $inst->modules();