I need a subroutine that completely removes an array element in place. The following code fails:
sub del
{
splice(@_,2,1);
}
@array=(0..5);
print "@array"."\n";
del(@array);
print "@array"."\n";
The same array is printed again, i.e. the element has not been removed.
However, if I use the splice() in the main body of the program instead of calling a subroutine, it works.
While the scalar elements of @_ are aliased to the data which is passed in, @_ itself is a different variable. This means $_[1] = "foo" will alter $_[1] but push @_, "foo" will not alter @_. Otherwise my $self = shift would be a Bad Thing.
You need to pass in the array as a reference.
sub del {
my $array_ref = shift;
splice @$array_ref, 2, 1;
return;
}
del \@array;
If you absolutely must keep the del @array interface, this is one of the few places where it's appropriate to use a prototype.
sub del(\@) {
my $array_ref = shift;
splice @$array_ref, 2, 1;
return;
}
del @array;
The \@ prototype tells Perl to pass in @array by reference. I would recommend against doing this for two reasons. First, prototypes have a pile of caveats which make them not worth the trouble.
More importantly, it makes it non-obvious that del will modify its arguments. Normally user defined Perl functions copy their arguments, so you can look at foo @array and be reasonably sure @array will not be altered by foo. This enables one to skim the code quickly for things which will affect a variable. A reference prototype throws this out the window. Now every function must be examined for a possible hidden pass-by-reference.
The answer can be found with perldoc perlsub:
Any arguments passed in show up in the array @. Therefore, if you called a function with two arguments, those would be stored in $[0] and $[1]. The array @ is a local array, but its elements are aliases for the actual scalar parameters. In particular, if an element $[0] is updated, the corresponding argument is updated (or an error occurs if it is not updatable). If an argument is an array or hash element which did not exist when the function was called, that element is created only when (and if) it is modified or a reference to it is taken. (Some earlier versions of Perl created the element whether or not the element was assigned to.) Assigning to the whole array @ removes that aliasing, and does not update any arguments.
In short, the individual elements can be modified, but not the list itself, if you need the changes to be visible outside of the sub. But you could probably return @_, which would return the modified list which you would then need to capture as the return value.
