Recursively printing data structures in Perl

maybe Data::Dumper is what you want:

use Data::Dumper; $str = Dumper($foo); print($str); 

If you are new to perl, I'd recommend running your code through perl-critic (there is also a script you can install from CPAN, normally I use it as a test so it gets run from the command line whenever I do "make test"). In addition to its output, you might want to break up your functions a bit more. recurseErrors has three cases that could be split into sub functions (or even put into a hash of ref-type to sub-function ref).

If this were a production job, I'd use Data::Dumper, but it sounds like this is homework, so your teacher might not be too pleased.

Here is one simple example why your code is not easily readable:

$delimiter = "\n--------------------------------------------" unless (defined $delimiter); 

You could use the defined or operator:

$delimiter //= "\n" . '-' x 44; 

If you are worried about earlier Perls:

defined $delimeter or $delimeter = "\n" . '-' x 44; 

Conditionals going off the right margin are enough of a turn-off for me not to read the rest of the code.

My guess is that he doesn't like that you

1. expect a hash in the str function.
2. call the same function to print arrays as hashes, despite that there appears to be no common function between them.
3. allow various ways to call str, but it never figures into the final result.
4. allow configurable space to be passed in to the root function, but have a tab hardcoded in the recursive function.
5. omit undefined values that actually hold a place in the arrays

Those are issues that I can see, pretty quickly.

You could have separated out the code blocks that dealt with arrays, and hashes.

sub recurse{ ... recurse_A(@_) if $ref eq 'ARRAY'; recurse_H(@_) if $ref eq 'HASH'; ... } sub recurse_A{ ... } sub recurse_H{ ... } 

I would recommend starting out your subroutines like this, unless you have a real good reason for doing otherwise.

sub example{ my( $one, $two, $three, $optional_four ) = @_; 

( If you do it like this then Komodo, at least, will be able to figure out what the arguments are to your subroutine )

There is rarely any reason to put a variable into a string containing only the variable.

"$var" eq $var; 

The only time I can think I would ever do that is when I am using an object that has an overloaded "" function, and I want to get the string, without also getting the object.

package My_Class; use overload '""' => 'Stringify', ; sub new{ my( $class, $name ) = @_; my $self = bless { name => $name }, $class; return $self; } sub Stringify{ my( $self ) = @_; return $self->{name}; } 

my $object = My_Class->new; my $string = "$object"; 

I've struggled with this same problem before, and found my way here. I almost used a solution posted here, but found a more suitable one (for me anyway). Read about Depth First Recursion here.

The sub in the above article works perfectly with a reference containing other Hashes, Arrays, or Scalars. It did not print Hash key names, though, so I slightly modified it:

#!/usr/bin/perl # # See: # # http://perldesignpatterns.com/?DepthFirstRecursion # use strict; use warnings; my %hash = ( 'a' => { 'one' => 1111, 'two' => 222, }, 'b' => [ 'foo', 'bar' ], 'c' => 'test', 'd' => { 'states' => { 'virginia' => 'richmond', 'texas' => 'austin', }, 'planets' => [ 'venus','earth','mars' ], 'constellations' => ['orion','ursa major' ], 'galaxies' => { 'milky way' => 'barred spiral', 'm87' => 'elliptical', }, }, ); &expand_references2(\%hash); sub expand_references2 { my $indenting = -1; my $inner; $inner = sub { my $ref = $_[0]; my $key = $_[1]; $indenting++; if(ref $ref eq 'ARRAY'){ print ' ' x $indenting,'ARRAY:'; printf("%s\n",($key) ? $key : ''); $inner->($_) for @{$ref}; }elsif(ref $ref eq 'HASH'){ print ' ' x $indenting,'HASH:'; printf("%s\n",($key) ? $key : ''); for my $k(sort keys %{$ref}){ $inner->($ref->{$k},$k); } }else{ if($key){ print ' ' x $indenting,$key,' => ',$ref,"\n"; }else{ print ' ' x $indenting,$ref,"\n"; } } $indenting--; }; $inner->($_) for @_; } 

 #use strict ; use warnings ; # use module use XML::Simple; use Data::Dumper; #debug print "START SCRIPT " ; my $fileToParse = 'C:/Temp/CDIP/scripts/perl/nps_all_workflows.xml' ; # create object my $objXml= new XML::Simple; # read XML file my $data = $objXml->XMLin("$fileToParse"); # #debug print "\n FirstLevel is " . $objXml->{'POWERMART'} ; my $level = 1 ; # printHashKeyValues ($data ) ; sub printHashKeyValues { $level ++ ; my $refHash = shift ; my $parentKey = shift ; my $parentValue = shift ; while( my ($key, $value) = each %$refHash) { if ( defined ( $key ) ) { if ( ref ($refHash->{"$key"}) eq 'HASH' ) { my $newRefHash = $refHash->{"$key"} ; #debug print " \n The key is a hash " ; printHashKeyValues ($newRefHash , $key , $value) ; } if ( ref ($refHash->{"$key"}) eq 'ARRAY' ) { #debug print " \n the key is an ARRAY " ; printArrayValues ( $refHash->{"$key"} ) ; } } #eof if ( defined ( $key )) if ( defined ( $value) ) { if ( ref ($refHash->{"$value"}) eq 'HASH' ) { my $newRefHash = $refHash->{"$value"} ; #debug print " \n The value is a hash " ; printHashKeyValues ($newRefHash , $key , $value) ; } if ( ref ($refHash->{"$value"}) eq 'ARRAY' ) { #debug print " \n the value is an ARRAY " ; printArrayValues ( $refHash->{"$value"} ) ; } } #eof if defined ( $value ) #debug print "\n key: $key, value: $value.\n"; } #eof while } #eof sub sub printArrayValues { my $arrRef = shift ; my @array = @$arrRef; my $parrentArrayElement = shift ; #debug print "printArrayValues CALLED " ; foreach my $arrayElement ( @array ) { if (defined ( $arrayElement ) ) { if ( ref ($arrayElement) eq 'HASH' ) { #debug print " \n The \$arrayElement is a hash FROM THE ARRAY " ; printHashKeyValues ($arrayElement ) ; } #eof if if ( ref ($arrayElement) eq 'ARRAY' ) { #debug print " \n The \$arrayElement is a ARRAY FROM THE ARRAY " ; printArrayValues ($arrayElement ) ; } #eof if #debug print "\n \$arrayElement is $arrayElement " ; } #eof if ( defined ( $arrayElement ) ) } #eof foreach } #eof sub # #debug print output ##debug print Dumper($data); 1 ;