Paquets et modules Perl


Chaque package en Perl a une table de symboles distincte, et la syntaxe de définition est : 

package mypack;

Cette instruction définit un package nommé monpack, et tous les symboles définis par la suite. les noms des variables et des sous-programmes sont stockés dans la table des symboles associée au package jusqu'à ce qu'une autre instruction package soit rencontrée.

Chaque table de symboles a son propre ensemble de variables et de noms de sous-programmes. Chaque ensemble de noms n'est pas pertinent, donc le même nom de variable peut être utilisé dans différents packages pour représenter différentes variables.

Pour accéder aux variables d'un autre package à partir d'un package, vous pouvez le spécifier par "nom du package + double deux-points ( :: ) + nom de la variable".

La table des symboles par défaut qui stocke les noms des variables et des sous-programmes est associée au package nommé main. Si d'autres packages sont définis dans le programme et que vous souhaitez revenir à l'utilisation de la table des symboles par défaut, vous pouvez re-spécifier le package principal : 


package main;

De cette façon, le programme suivant ressemblera à partir de Comme si aucun package n'avait été défini, les noms des variables et des sous-programmes sont stockés comme d'habitude.

Les fichiers de l'exemple suivant incluent les packages main et Foo. La variable spéciale __PACKAGE__ est utilisée pour afficher le nom du package : 


#!/usr/bin/perl

#  main 包
$i = 1; 
print "包名 : " , __PACKAGE__ , " $i\n"; 

package Foo;
#  Foo 包
$i = 10; 
print "包名 : " , __PACKAGE__ , " $i\n"; 

package main;
# 重新指定 main 包
$i = 100; 
print "包名 : " , __PACKAGE__ , " $i\n"; 
print "包名: " , __PACKAGE__ ,  " $Foo::i\n"; 

1;

Exécutez le programme ci-dessus, le résultat de sortie est : 

包名 : main 1
包名 : Foo 10
包名 : main 100
包名: main 10

Module BEGIN et END

Le langage Perl fournit deux mots-clés : BEGIN, END. Ils peuvent chacun contenir un ensemble de scripts à exécuter avant ou après l'exécution du corps du programme.


Le format de syntaxe est le suivant : 

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

  • Chaque BEGIN ​​​​​​module est chargé et compilé par le script Perl Mais il est exécuté avant que les autres instructions ne soient exécutées.

  • Chaque bloc d'instructions END est exécuté avant la sortie de l'interpréteur. Les blocs

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

Si vous ne comprenez toujours pas, nous pouvons regarder un exemple : 

#!/usr/bin/perl

package Foo;
print "Begin 和 Block 实例\n";

BEGIN { 
    print "这是 BEGIN 语句块\n" 
}

END { 
    print "这是 END 语句块\n" 
}

1;

Exécutez le programme ci-dessus, le résultat de sortie est : 

这是 BEGIN 语句块
Begin 和 Block 实例
这是 END 语句块

Que sont les modules Perl ?

Perl5 utilise les packages Perl pour créer des modules.

Le module Perl est un package réutilisable. Le nom du module est le même que le nom du package. Le suffixe du fichier défini est .pm.

Ci-dessous nous définissons un module Foo.pm, le code est le suivant : 

#!/usr/bin/perl

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

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

Les points suivants doivent être notés concernant les modules en Perl :

  • Les fonctions require et use chargeront un module.

  • @INC est un tableau spécial intégré à Perl qui contient le chemin du répertoire vers l'emplacement des routines de la bibliothèque. Les fonctions

  • require et use appellent la fonction eval pour exécuter du code.

  • Fin 1; l'exécution renvoie TRUE, ce qui est obligatoire, sinon une erreur est renvoyée.

Fonctions Require et Use Le module

peut être appelé via la fonction require comme suit : 

#!/usr/bin/perl

require Foo;

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

Il peut également être référencé via la fonction use : 

<pre>
#!/usr/bin/perl

use Foo;

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

Nous avons remarqué que require reference doit utiliser le nom du package pour spécifier la fonction, mais use ne le fait pas. La principale différence entre les deux est la suivante :

  • 1. pour charger un module ou un programme Perl (le suffixe .pm peut être omis, mais .pl doit être présent)

  • 2 L'instruction Perl use est introduite lors de la compilation et require est introduite lors de l'exécution.

  • 3. Lorsque l'utilisation de Perl introduit des modules, elle introduit également des sous-modules de modules. Et require ne peut pas être importé, il doit être re-déclaré

  • 4. USE se trouve dans le @INC par défaut actuel. Une fois que le module n'est pas dans @INC, il ne peut pas être importé en utilisant. USE Oui, mais require peut spécifier le chemin

  • 5. Lorsque USE fait référence à un module, si le nom du module contient un :: double deux-points, le double deux-points sera utilisé comme chemin séparateur, qui est équivalent à celui sous Unix /Ou sous Windows. Par exemple : 


    use MyDirectory::MyModule

Vous pouvez exporter des symboles de liste à partir du module en ajoutant l'instruction suivante use module : 

require Exporter;
@ISA = qw(Exporter);

@EXPORT le tableau contient les noms des variables et des fonctions exportées par défaut : 

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 un module Perl


Il peut être facilement créé grâce à l'outil h2xs fourni avec la distribution Perl.

Vous pouvez taper h2xs en mode ligne de commande pour voir sa liste de paramètres.

Format de syntaxe h2xs : 

$ h2xs -AX -n  ModuleName

Description du paramètre :

  • -A Ignorer le mécanisme de chargement automatique

  • -X Ignorer les éléments XS

  • -n Préciser le nom du module d'extension

Par exemple, si votre module est dans le fichier Person.pm, utilisez la commande suivante : 

$ h2xs -AX -n Person

L'exécution du programme ci-dessus affichera : 

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

Répertoire de personnes dans votre Vous pouvez voir le répertoire nouvellement ajouté et la description du fichier :

  • LISEZMOI : Ce fichier contient des informations d'installation, des dépendances de module, des informations de droits d'auteur, etc.

  • Modifications : ce fichier sert de fichier journal des modifications pour votre projet.

  • Makefile.PL : Il s'agit du constructeur Perl Makefile standard. Utilisé pour créer un fichier Makefile.PL pour compiler le module.

  • MANIFEST : Ce fichier est utilisé pour construire automatiquement la distribution des versions du module de type tar.gz. De cette façon, vous pouvez apporter votre module au CPAN et le publier ou le distribuer à d'autres. Il contient une liste de tous les fichiers que vous avez dans ce projet.

  • Person.pm : Il s'agit du fichier de module principal qui contient le code de votre gestionnaire mod_perl.

  • Person.t : Quelques scripts de test pour ce module. Par défaut, il vérifie simplement le chargement du module, vous pouvez ajouter de nouvelles unités de test.

  • t/ : fichier de test

  • lib/ : répertoire où est stocké le code source réel

vous Le répertoire ci-dessus peut être empaqueté sous Person.tar.gz à l'aide de la commande tar (sous Linux).

Installer le module Perl

Nous pouvons décompresser et installer le fichier Person.tar.gz que nous venons de compresser. Les étapes sont les suivantes : 

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

Exécutez d'abord "perl Makefile.PL" pour générer le Makefile dans le répertoire courant

;

Ensuite, exécutez « make » pour compiler et créer les fichiers de bibliothèque requis ;

Utilisez ensuite « make test » pour tester si le résultat de la compilation est correct, puis exécutez « make install » pour installer les fichiers de bibliothèque sur ; le répertoire système, et c'est tout. L'ensemble du processus de compilation se termine.