By calling trim() as &trim(), you’re bypassing protocols altogether. Try removing all the & from your calls and you’ll see that nothing gets trimmed. Also, supposing it did work, you would be limiting the use of any data structures other than scalars.

Let me comment on your code. It has to do with what Christine Morton commented on and I explained on that reply about passing variables by value and by reference.

My original subroutine works. It runs a loop on each element of @_ handling them as references to the original input parameter. That’s why you don’t see shift() in my subroutine. When you call shift() like you did on yours, you’re no longer working on references but on copies of the values. Yes, when you’re working on copies the originals don’t get changed, so you have to return the modified data and assign it to the original like you did for it to work, but I didn’t really want that – I wanted it to work like push(), auto-increment/decrement and many other Perl unary functions (no lvalue!).

Your code works – but it’s a different approach (the one Christine Morton was asking about).

Cheers,
Vinny

First test code:

#!/usr/bin/perl -w
use strict;
use Data::Dumper;
my $data = [
{
key1 => ' trim me! ',
key2 => ' trim me too! ',
},
[
'some element to trim ',
' another one ',
],
' a simple string needing trimming ',
];

sub trim {
my $input = shift;
if (ref($input) eq "ARRAY") {
print "ARRAY:".Dumper($input);
foreach my $element (@{$input}) {
&trim($element);
}
} elsif (ref($input) eq "HASH") {
print "HASH:".Dumper($input);
foreach my $element (values %{$input}) {
&trim($element);
}
} else {
$input =~ s%(^\s+|\s+$)%%g;
print "STRING:\'".$input."\'\n";
}
}
__END__


As we see, each value for each nested element have been processed properly, but not modified at original source.

ARRAY:$VAR1 = [
{
'key2' => ' trim me too! ',
'key1' => ' trim me! '
},
[
'some element to trim ',
' another one '
],
‘ a simple string needing trimming ‘
];
HASH:$VAR1 = {
‘key2′ => ‘ trim me too! ‘,
‘key1′ => ‘ trim me! ‘
};
STRING:’trim me too!’
STRING:’trim me!’
ARRAY:$VAR1 = [
'some element to trim ',
' another one '
];
STRING:’some element to trim’
STRING:’another one’
STRING:’a simple string needing trimming’
result : $VAR1 = [
{
'key2' => ' trim me too! ',
'key1' => ' trim me! '
},
[
'some element to trim ',
' another one '
],
‘ a simple string needing trimming ‘
];

It is expected result in this case. When we will do other small code modification to set processed data it is returns desirable result.

Second test code:

#!/usr/bin/perl -w
use strict;
use Data::Dumper;
my $data = [
{
key1 => ' trim me! ',
key2 => ' trim me too! ',
},
[
'some element to trim ',
' another one ',
],
' a simple string needing trimming ',
];

sub trim {
my $input = shift;
if (ref($input) eq "ARRAY") {
for (my $key=0; $key<scalar(@{$input}); $key++) {
${$input}[$key] = &trim(${$input}[$key]);
}
} elsif (ref($input) eq "HASH") {
foreach my $key (keys %{$input}) {
${$input}{$key} = &trim(${$input}{$key});
}
} else {
$input =~ s%(^\s+|\s+$)%%g;
}
return $input;
}
__END__


This is output:

result : $VAR1 = [
{
'key2' => 'trim me too!',
'key1' => 'trim me!'
},
[
'some element to trim',
'another one'
],
'a simple string needing trimming'
];


Here’s another example of passing by reference:


my @array = (1,2,3,4,5);
for my $i (@array) { # each element is referenced into $i
$i++;
}
print "@array"; # 2 3 4 5 6


Now, if I had specified a lexical for each element…

my @array = (1,2,3,4,5);
for my $i (@array) { # each element is referenced into $i and then copied into $val
my $val = $i;
$val++;
}
print "@array"; # 1 2 3 4 5


The auto-incremented result stays in $val which is lost with each iteration of the loop. I would have had to assign it back into $i in order to change @array

Cheers!


#! /usr/bin/perl

my @test = (' first string ');
trim(@test);
print Dumper(@test);


prints:


main::trim() called too early to check prototype at trimtest.pl line 13.
main::trim() called too early to check prototype at trimtest.pl line 18.
$VAR1 = ' first string ';


But remove the prototype and the same code gives you:


$VAR1 = 'first string';


See also Prototypes Considered Harmful by Tom Christiansen.

#!/usr/bin/perl

use 5.008;
use strict;
use warnings;
use Test::More qw(no_plan);
sub trim {
…
}

my $c=’ test ‘;
trim($c);
is($c,’test’);
my @d=(‘ a ‘,’b');
trim(@d);
is($d[0],’a');
is($d[1],’b');