<?php
 $r1 = array( 1 );
 $r2 = array( 2, &$r1 );
 array_push( $r1, &$r2 );

 print_r($r1);
?>
[download]

(
    [0] => 1
    [1] => Array
        (
            [0] => 2
            [1] => Array
                (
                    [0] => 1
                    [1] => Array
 *RECURSION*
                )

        )

)
[download]

recursion check:

sub print_r {
    
    my $level="";
    my @level_index=();
    my @print_r_Recursion=();
    print_rec (@_);
    undef @level_index;
    undef @print_r_Recursion;
    undef $level;
    
    sub print_rec {

        if ( ! defined $level ) { $level = 0 };
        if ( ! defined @level_index ) { $level_index[$level] = 0 };

        for ( @_ ) {

            my $element = $_;
            my $index   = $level_index[$level];
            
            if (ref($element) eq 'ARRAY' || ref($element) eq 'HASH'){
                my $loop=0;
                for (@print_r_Recursion){
                    if (($element."") eq ($_."")){
                        $loop=1;
                        last;
                    }
                }
                if ($loop==1){
                    print "\t" x $level . "[$index] => ". ref($elem
+ent) ." *recursion*\n";
                    next;
                }
                push @print_r_Recursion,$element;
            }
            
            print "\t" x $level . "[$index] => ";

            if ( ref($element) eq 'ARRAY' ) {
                my $array = $_;

                $level_index[++$level] = 0;

                print "(Array)\n";

                for ( @$array ) {
                    print_rec( $_ ); 
                }
                --$level if ( $level > 0 );
            } elsif ( ref($element) eq 'HASH' ) {
                my $hash = $_;

                print "(Hash)\n";

                ++$level;

                for ( keys %$hash ) {
                    $level_index[$level] = $_;
                    print_rec( $$hash{$_} );
                }
            } else {
                print "$element\n";
            }

            $level_index[$level]++;
        }
    }
}
[download]

This will recurse endlessly until the heat death of the universe or you run out of swap, whichever comes first. Then again, perhaps the PHP implementation does as well.

Minor issue: you don't want to explicitly state the package (main::print_r) when you call the function within itself. Using the unqualified name will allow it to work regardless of which package defines the routine.

Undefined subroutine &print_r::print_r called at ./print_r.pl line 55.
[download]

--
-- Ghodmode

I did this initially, but I got the following error: Undefined subroutine &print_r::print_r called at ./print_r.pl line 55.

Odd. If I take out the main:: prefix, and the package declaration I receive no error. In fact, I've never seen a package declaration within a subroutine. It seems strange, to say the least, and I wonder if it does what you think it does. What do you think it does?

Looking more closely at the code, I suspect you want my variables and not our.

As to why you want to have an object reference itself, one answer is "it makes life easier". It most frequently occurs in hierarchical structures, where one of the keys at a node will be a reference to an ancestor or sibling. It makes it easier to move around in the object without having to maintain context. Have a look at an XML::Twig object some time.

• another intruder with the mooring in the heart of the Perl

grinder wrote:
Odd. If I take out the main:: prefix, and the package declaration I receive no error. In fact, I've never seen a package declaration within a subroutine. It seems strange, to say the least, and I wonder if it does what you think it does. What do you think it does?

The scope of a package declaration is from the declaration itself to the end of the enclosing block (ref: package). So, declaring the package after the opening brace of the subroutine allows me to define variables (with our) that don't pollute the main namespace, but still maintain their value outside of the scope of the current instance of the subroutine.

By prefixing the name of the subroutine with main::, I'm saying that I want to call the print_r() subroutine which is defined in the main namespace rather than the current namespace, which is print_r when it's called from the subroutine. I didn't even have this in there until the error message told me that it was necessary.

Are you sure you used the same code as me? This doesn't seem like the kind of error that would be different between different versions of Perl.

I could declare the package before the subroutine definition and remove main:: from the lines where the function calls itself, but then I would have to add print_r:: to the function call in the main body of the code. This would make it a little more annoying to use. Also, this would force the subroutine definition to appear at the end of the script because the package declaration would apply to everything after it.

I suppose that I could fix this with Exporter if I wrote a proper module, but this isn't meant to be a module, just a snippet.

If I take out the package entirely and use regular variables which are defined in the main namespace anyway, then this problem goes away, but then I have a couple of variables ($level and @level_index) which have to be defined by the user in addition to just pasting the code at the end of an existing program and calling print_r(). Another potential problem is that the user needs to know about the two variables and make sure he doesn't use them in the main namespace.

The way I wrote it, the user needs only to paste the subroutine into their own code and call print_r(), passing a variable reference as the argument.

grinder wrote:
Looking more closely at the code, I suspect you want my variables and not our.

I need to use our because I need the variables to maintain their value between calls to the subroutine. If I used my it would be a new and undefined variable each time the subroutine was called and this would break the recursion. To be specific, the $level would be 0 on each recursion.

--
-- Ghodmode

Blessed is he who has found his work; let him ask no other blessedness.
-- Thomas Carlyle