Perl - Pacotes e Módulos

O que são pacotes?

o packageinstrução muda o contexto de nomenclatura atual para um namespace especificado (tabela de símbolos). Assim -

Um pacote é uma coleção de código que reside em seu próprio namespace.
Um namespace é uma coleção nomeada de nomes de variáveis exclusivos (também chamada de tabela de símbolos).
Os namespaces evitam colisões de nomes de variáveis entre pacotes.
Os pacotes permitem a construção de módulos que, quando usados, não afetam variáveis e funções fora do próprio namespace dos módulos.
O pacote permanece em vigor até que outra instrução de pacote seja chamada ou até o final do bloco ou arquivo atual.
Você pode referir-se explicitamente a variáveis dentro de um pacote usando o :: qualificador de pacote.

A seguir está um exemplo com os pacotes principal e Foo em um arquivo. Aqui, a variável especial __PACKAGE__ foi usada para imprimir o nome do pacote.

#!/usr/bin/perl

# This is main package
$i = 1; 
print "Package name : " , __PACKAGE__ , " $i\n"; 

package Foo;
# This is Foo package
$i = 10; 
print "Package name : " , __PACKAGE__ , " $i\n"; 

package main;
# This is again main package
$i = 100; 
print "Package name : " , __PACKAGE__ , " $i\n"; 
print "Package name : " , __PACKAGE__ ,  " $Foo::i\n"; 

1;

Quando o código acima é executado, ele produz o seguinte resultado -

Package name : main 1
Package name : Foo 10
Package name : main 100
Package name : main 10

Blocos BEGIN e END

Você pode definir qualquer número de blocos de código chamados BEGIN e END, que atuam como construtores e destruidores, respectivamente.

BEGIN { ... }
END { ... }
BEGIN { ... }
END { ... }

Cada BEGIN bloco é executado após o script perl ser carregado e compilado, mas antes que qualquer outra instrução seja executada.
Cada bloco END é executado logo antes da saída do interpretador perl.
Os blocos BEGIN e END são particularmente úteis ao criar módulos Perl.

O exemplo a seguir mostra seu uso -

#!/usr/bin/perl

package Foo;
print "Begin and Block Demo\n";

BEGIN { 
   print "This is BEGIN Block\n" 
}

END { 
   print "This is END Block\n" 
}

1;

Quando o código acima é executado, ele produz o seguinte resultado -

This is BEGIN Block
Begin and Block Demo
This is END Block

O que são módulos Perl?

Um módulo Perl é um pacote reutilizável definido em um arquivo de biblioteca cujo nome é igual ao nome do pacote com uma extensão .pm.

Um arquivo de módulo Perl chamado Foo.pm pode conter declarações como esta.

#!/usr/bin/perl

package Foo;
sub bar { 
   print "Hello $_[0]\n" 
}

sub blat { 
   print "World $_[0]\n" 
}
1;

Alguns pontos importantes sobre os módulos Perl

As funções require e use irá carregar um módulo.
Ambos usam a lista de caminhos de pesquisa em @INC para encontrar o módulo.
Ambas as funções require e use Ligar para eval função para processar o código.
o 1; na parte inferior faz com que o eval seja avaliado como TRUE (e, portanto, não falhe).

A função necessária

Um módulo pode ser carregado chamando o require funcionar da seguinte forma -

#!/usr/bin/perl

require Foo;

Foo::bar( "a" );
Foo::blat( "b" );

Você deve ter notado que os nomes das sub-rotinas devem ser totalmente qualificados para chamá-los. Seria bom habilitar a sub-rotinabar e blat para ser importado em nosso próprio namespace, para que não tenhamos que usar o qualificador Foo ::.

A Função de Uso

Um módulo pode ser carregado chamando o use função.

#!/usr/bin/perl

use Foo;

bar( "a" );
blat( "b" );

Observe que não precisamos qualificar totalmente os nomes das funções do pacote. ouse A função exportará uma lista de símbolos de um módulo, dadas algumas instruções adicionadas dentro de um módulo.

require Exporter;
@ISA = qw(Exporter);

Em seguida, forneça uma lista de símbolos (escalares, listas, hashes, sub-rotinas, etc) preenchendo a variável da lista chamada @EXPORT: Por exemplo -

package Module;

require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(bar blat);

sub bar { print "Hello $_[0]\n" }
sub blat { print "World $_[0]\n" }
sub splat { print "Not $_[0]\n" }  # Not exported!

1;

Crie a árvore de módulos Perl

Quando você estiver pronto para enviar seu módulo Perl, haverá uma maneira padrão de criar uma Árvore de Módulos Perl. Isso é feito usandoh2xsUtilitário. Este utilitário vem junto com o Perl. Aqui está a sintaxe para usar h2xs -

$h2xs -AX -n  ModuleName

Por exemplo, se o seu módulo está disponível em Person.pm arquivo, então simplesmente emita o seguinte comando -

$h2xs -AX -n Person

Isso produzirá o seguinte resultado -

Writing Person/lib/Person.pm
Writing Person/Makefile.PL
Writing Person/README
Writing Person/t/Person.t
Writing Person/Changes
Writing Person/MANIFEST

Aqui está a descrição dessas opções -

-A omite o código do Autoloader (melhor usado por módulos que definem um grande número de sub-rotinas usadas com pouca frequência).
-X omite elementos XS (sub-rotina eXternal, onde eXternal significa externo ao Perl, ou seja, C).
-n especifica o nome do módulo.

Portanto, o comando acima cria a seguinte estrutura dentro do diretório Person. O resultado real é mostrado acima.

Changes
Makefile.PL
MANIFEST (contém a lista de todos os arquivos do pacote)
README
t / (arquivos de teste)
lib / (o código-fonte real vai aqui

Então finalmente, você taresta estrutura de diretório em um arquivo Person.tar.gz e você pode enviá-lo. Você terá que atualizar o arquivo README com as instruções adequadas. Você também pode fornecer alguns arquivos de exemplos de teste no diretório t.

Instalando Módulo Perl

Baixe um módulo Perl no arquivo tar.gz do formato. Use a seguinte sequência para instalar qualquer Módulo PerlPerson.pm que foi baixado como Person.tar.gz Arquivo.

tar xvfz Person.tar.gz
cd Person
perl Makefile.PL
make
make install

O interpretador Perl tem uma lista de diretórios nos quais procura por módulos (array global @INC).