Partage de variables entre plusieurs sous-modules

Question

J'ai un module foo qui a étendu les sous-modules bar et baz. Je veux que bar et baz modifient le même ensemble de hachages qui sont dans foo.

En ce moment, j'ai quelque chose comme:

my $foo = new foo; 
my $bar = new foo::bar($foo); 
$bar->doStuff(); 
$bar->printSelf(); 
my $baz = new foo::bar($foo); 
$baz->doOtherStuff(); 
$baz->printSelf(); 

A l'intérieur d'un des sous-modules du constructeur ressemble:

sub new { 
    my $class = shift; 
    my $self = shift; 
    --stuff-- 
    bless $self, $class; 
    return $self; 
} 

S'il vous plaît ne riez pas trop fort. Y a-t-il un moyen de le faire sans passer par $ foo?

Merci d'avoir lu. :)

Answer 1

Je préfère partager des choses par des méthodes. De cette façon, on ne doit rien savoir sur les structures de données ou les noms de variables (bien que vous avez besoin de connaître le nom de la méthode):

{ 
package SomeParent; 

my %hash1 =(); 
my %hash2 =(); 

sub get_hash1 { \%hash1 } 
sub get_hash2 { \%hash2 } 

sub set_hash1_value { ... } 
sub set_hash1_value { ... } 
} 

Depuis SomeParent fournit l'interface pour obtenir les structures de données privées, c'est ce que vous utilisez dans SomeChild:

{ 
package SomeChild; 
use parent 'SomeParent'; 

sub some_method { 
     my $self = shift; 
     my $hash = $self->get_hash1; 
     ...; 
     } 

sub some_other_method { 
     my $self = shift; 
     $self->set_hash2_value('foo', 'bar'); 
     } 

} 

Answer 2

Votre question n'est pas très claire ni aucun code avec des hachages. Mais si vous avez besoin du module variables modifiées, vous pouvez utiliser le nom complet:

package Foo;  # don't use lowercase named, they are reserved for pragmas 

our %hash1 =(); 
our %hash2 =(); 


package Foo::Bar; 
use Data::Dump qw(dd); 

sub do_stuff { 
    $Foo::hash1{new_item} = 'thing'; 
} 

sub do_other_stuff { 
    dd \%Foo::hash1; 
} 


package main; 

Foo::Bar->do_stuff(); 
Foo::Bar->do_other_stuff(); 

Mais si vous avez besoin de modifier exemple les variables, vous devez avoir référence à cette instance. Je vois des stratégies qui fonctionnent:

• Hériter de Foo, de sorte que les hachages en instance de Foo::Bar
• référence passe à Foo dans le constructeur et l'enregistrer comme propriété Foo::Bar
• passe Foo référence paramètre à la méthode

La bonne solution dépend de ce que vous essayez de faire et comment vous allez l'utiliser.