I came to this Is there an advantage to storing references to objects in an attribute instead of the object itself?. Applying find_cycle from Devel::Cycle in my own script showed that I had a lot of circular references.
I realized most of them were due to storing "external" objects' reference in $self current object, many of these were in fact not needed in methods call. But in some methods I had to use an object received in the constructor.
See for example the code below. The circular reference is suppress with a call to weaken (but the second call to do_something fails).
use strict; use warnings; use Devel::Cycle; package A; sub new { my ( $class, $href ) = @_; my $self = { dbi => $$href{dbi} }; $self->{helper} = Helper->new( helper_function => sub { $self->this_is_from_A(@_ +) } ); bless $self, $class; } sub do_something { my $self = shift; $self->{helper}->called_from_helper(); } sub this_is_from_A { my ( $self, $arg ) = @_; print "$arg\nthis_is_from_A using $self->{dbi}\n"; } package Helper; #use Scalar::Util qw/weaken/; sub new { my $class = shift; my %def = ( a => "something" ); my %arg = ( ref $_[0] eq "HASH" ? ( %def, %{ $_[0] } ) : ( %def, + @_ ) ); my $self = \%arg; bless $self, $class; } sub called_from_helper { my $self = shift; print "called_from_helper\n"; $self->{helper_function}->("param from Helper"); #weaken($self->{helper_function}); } package main; my $a = A->new( { dbi => "some dbi object" } ); $a->do_something(); $a->do_something(); find_cycle($a);
Using a sub ref instead of a method calls to this_is_from_A in the code ref pass with helper_function eliminates the circular reference because the code can access the $href->{dbi} directly.
use strict; use warnings; use Devel::Cycle; package A; sub new { my ( $class, $href ) = @_; my $self = { dbi => $$href{dbi} }; $self->{helper} = Helper->new( helper_function => sub { print "$_[0]\nthis_is_from_A using $$href{dbi}\n" +; } ); bless $self, $class; } sub do_something { my $self = shift; $self->{helper}->called_from_helper(); } =for comment sub this_is_from_A { my ($self, $arg) = @_; print "$arg\nthis_is_from_A using $self->{dbi}\n"; } =cut package Helper; sub new { my $class = shift; my %def = ( a => "something"); my %arg = ( ref $_[0] eq "HASH" ? ( %def, %{ $_[0] } ) : ( %def, + @_ ) ); my $self = \%arg; bless $self, $class; } sub called_from_helper { my $self = shift; print "called_from_helper\n"; $self->{helper_function}->("param from Helper"); } package main; my $a = A->new( { dbi => "some dbi object" } ); $a->do_something(); $a->do_something(); find_cycle($a)
But if the code from this_is_from_A was a long and complicated thing, wouldn't it clutter A->new and make it hard to understand and maintain ? Is there another solution ?
Thanks for any comment
frazap
Update: complete the example 2 (end was missing). Update 2 with the correct lines of code.In reply to Avoiding circular references by frazap
| For: | Use: | ||
| & | & | ||
| < | < | ||
| > | > | ||
| [ | [ | ||
| ] | ] |