Perl - Paquets et modules

Que sont les packages?

le packagebascule le contexte de dénomination actuel vers un espace de noms spécifié (table de symboles). Ainsi -

  • Un package est une collection de code qui vit dans son propre espace de noms.

  • Un espace de noms est une collection nommée de noms de variables uniques (également appelée table de symboles).

  • Les espaces de noms empêchent les collisions de noms de variables entre les packages.

  • Les packages permettent la construction de modules qui, lorsqu'ils sont utilisés, ne suppriment pas les variables et les fonctions en dehors de l'espace de noms des modules.

  • Le package reste en vigueur jusqu'à ce qu'une autre instruction package soit appelée, ou jusqu'à la fin du bloc ou du fichier en cours.

  • Vous pouvez explicitement faire référence à des variables dans un package en utilisant le :: qualificatif de package.

Voici un exemple de packages main et Foo dans un fichier. Ici, la variable spéciale __PACKAGE__ a été utilisée pour imprimer le nom du package.

#!/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;

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Blocs BEGIN et END

Vous pouvez définir n'importe quel nombre de blocs de code nommés BEGIN et END, qui agissent respectivement comme des constructeurs et des destructeurs.

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

  • Chaque BEGIN block est exécuté après le chargement et la compilation du script perl, mais avant l'exécution de toute autre instruction.

  • Chaque bloc END est exécuté juste avant la fermeture de l'interpréteur perl.

  • Les blocs BEGIN et END sont particulièrement utiles lors de la création de modules Perl.

L'exemple suivant montre son utilisation -

#!/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;

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -

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

Que sont les modules Perl?

Un module Perl est un package réutilisable défini dans un fichier bibliothèque dont le nom est le même que le nom du package avec l'extension .pm.

Un fichier de module Perl appelé Foo.pm peut contenir des déclarations comme celle-ci.

#!/usr/bin/perl

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

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

Quelques points importants sur les modules Perl

  • Les fonctions require et use chargera un module.

  • Les deux utilisent la liste des chemins de recherche dans @INC pour trouver le module.

  • Les deux fonctions require et use appeler le eval fonction pour traiter le code.

  • le 1; en bas, eval s'évalue à TRUE (et donc n'échoue pas).

La fonction Require

Un module peut être chargé en appelant le require fonction comme suit -

#!/usr/bin/perl

require Foo;

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

Vous devez avoir remarqué que les noms de sous-programmes doivent être pleinement qualifiés pour les appeler. Ce serait bien d'activer le sous-programmebar et blat à importer dans notre propre espace de noms pour ne pas avoir à utiliser le qualificatif Foo ::.

La fonction d'utilisation

Un module peut être chargé en appelant le use fonction.

#!/usr/bin/perl

use Foo;

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

Notez que nous n'avons pas eu à qualifier complètement les noms de fonctions du package. leuse function exportera une liste de symboles d'un module à partir de quelques instructions ajoutées à l'intérieur d'un module.

require Exporter;
@ISA = qw(Exporter);

Ensuite, fournissez une liste de symboles (scalaires, listes, hachages, sous-programmes, etc.) en remplissant la variable de liste nommée @EXPORT: Par exemple -

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;

Créer l'arborescence des modules Perl

Lorsque vous êtes prêt à expédier votre module Perl, il existe un moyen standard de créer une arborescence de modules Perl. Ceci est fait en utilisanth2xsutilitaire. Cet utilitaire est fourni avec Perl. Voici la syntaxe pour utiliser h2xs -

$h2xs -AX -n  ModuleName

Par exemple, si votre module est disponible dans Person.pm fichier, puis exécutez simplement la commande suivante -

$h2xs -AX -n Person

Cela produira le résultat suivant -

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

Voici la description de ces options -

  • -A omet le code de l'Autoloader (mieux utilisé par les modules qui définissent un grand nombre de sous-programmes rarement utilisés).

  • -X omet les éléments XS (eXternal Subroutine, où eXternal signifie externe à Perl, c'est-à-dire C).

  • -n spécifie le nom du module.

La commande ci-dessus crée la structure suivante dans le répertoire Person. Le résultat réel est indiqué ci-dessus.

  • Changes
  • Makefile.PL
  • MANIFEST (contient la liste de tous les fichiers du package)
  • README
  • t / (fichiers de test)
  • lib / (le code source réel va ici

Alors finalement, toi tarcette structure de répertoire dans un fichier Person.tar.gz et vous pouvez l'envoyer. Vous devrez mettre à jour le fichier README avec les instructions appropriées. Vous pouvez également fournir des fichiers d'exemples de test dans le répertoire t.

Installer le module Perl

Téléchargez un module Perl sous la forme de fichier tar.gz. Utilisez la séquence suivante pour installer n'importe quel module PerlPerson.pm qui a été téléchargé en tant que Person.tar.gz fichier.

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

L'interpréteur Perl a une liste de répertoires dans lesquels il recherche des modules (tableau global @INC).