Comment lire les arguments passés au constructeur et les arguments passés par `use Module` en Perl?

Question

Actuellement, je fais un nouveau module et je me demandais comment mettre en œuvre dans mon module 2 choses.

On voit souvent le use comme:

use My::Module qw(something); 

par exemple:

use CGI::Carp qw(fatalsToBrowser); 

1. La première question est, comment puis-je récupérer, je veux dire wether le l'utilisateur a spécifié quelque chose et ce il a spécifié?

2. deuxième question est, Comment puis-je passer et lire les args directement sur le constructeur comme ceci:

   mon mon_module de $ = Mon :: Module-> nouveau (arg1, arg2, arg3)

AS demandé sur le commentaire du code simple test du module:

package My::Module; 

# $Id$ 

use strict; 
use Carp; 

sub new { 
     my $class = shift; 
     my $self = {}; 

     $self->{ARG1}   = undef; 
     $self->{ARG2}   = undef; 
     $self->{ARG3}   = undef; 
     $self->{ARG4}   = undef; 

     bless($self,$class); 
     return $self; 
} 

sub arg1 { 
     my $self = shift; 
     if (@_) { $self->{ARG1} = shift } 
     return $self->{ARG1}; 
} 

sub arg2 { 
     my $self = shift; 
     if (@_) { $self->{ARG2} = shift } 
     return $self->{ARG2}; 
} 

sub arg3 { 
     my $self = shift; 
     if (@_) { $self->{ARG3} = shift } 
     return $self->{ARG3}; 
} 

sub arg4 { 
     my $self = shift; 
     if (@_) { $self->{ARG4} = shift } 
     return $self->{ARG4}; 
} 

sub dump { 
     my $self = shift; 

     require Data::Dumper; 
     my $d = Data::Dumper->new([$self], [ref $self]); 
     $d->Deepcopy(1); 
     return $d->Dump(); 
} 

1; # so the require or use succeeds 

Answer 1

Les exemples de code suivants devraient vous aider.

Fichier: Mon/Module.pm

package My::Module; 

use warnings; 
use strict; 

use Data::Dumper; 

sub import { 
    my ($package, @args) = @_; 

    print Dumper \@args; 
} 

1; 

fichier: module.pl

#!/usr/bin/env perl 

use warnings; 
use strict; 

use My::Module qw(something); 

Si vous programmez un module orienté objet, vous pouvez essayer Moose qui sauvera vous avez beaucoup de temps.

Answer 2

perldoc -f use explique que le use keyword est simple chargement d'un module au cours de la compilation, puis d'appeler ->import là-dessus. Les arguments qu'un appelant a donné à l'instruction use seront transmis à l'appel de la méthode d'importation. En ce qui concerne votre deuxième question, les constructeurs ne sont que des méthodes. Obtenir leurs arguments fonctionne comme il le fait pour toute autre méthode ou fonction, en utilisant le @_ variable. Subroutine obtient les arguments passés dans un use.