my @array = (0,1,2,3,4,5,6);
delete $array[3];
print join(':', @array),"\n";
splice(@array, 3, 1);
print join(':', @array),"\n";
This snippet produces the following output:
Use of uninitialized value in join or string at - line 3.
0:1:2::4:5:6
0:1:2:4:5:6
You can see that the delete() function only deletes the value at index
3 in the array, while the splice() function removes the slot entirely
and shifts the remainder of the array down to fill in the gap.
The delete() function can also be used on an array slice as well as a
single element. That slice need not be a contiguous range of elements:
# delete a range
delete @array[0..3];
# or a discontiquous slice
delete @array[0,3,5];
The splice() function may also be used to remove a range of elements
from an array, but not a discontiguous slice:
splice(@array,0,3); # remove 3 elements starting at index 0.
One may think that the delete() function (formerly only allowed on hash
elements) is nothing more than simply undef()'ing elements in an array,
assigning either multiple undef values to multiple elements, or perhaps
assigning an empty list to multiple values:
my @array = (0,1,2,3,4,5,6);
$array[0] = undef;
@array[1,2] = ();
@array[3,4] = (undef,undef);
print join(':', @array),"\n";
This snippet prints (ignoring warnings):
:::::5:6
We'd expect this if we'd used delete() as well; however, the methods
are not entirely equivalent. The delete() function has a companion
exists() function (also formerly only used with hashes) that detects
the difference between an array element that has been deleted and one
that has been undefined:
my @array = (0,1,2,3,4,5,6);
@array[0,3,5] = (undef,undef,undef);
print "1: Still there\n" if exists $array[3];
@array[0,3,5] = ();
print "2: Still there\n" if exists $array[3];
delete @array[0,3,5];
print "3: Still there\n" if exists $array[3];
Which produces:
1: Still there
2: Still there
So even though a given element is undefined (i.e., the defined()
function would return false), Perl can still tell if it has been delete
()'ed or not. In many situations the delete() function applied to an
array element or slice is no better than the other methods shown, and
somewhat slower. But, some algorithms may find it useful to be able to
determine if the value of an array element is undefined because it was
assigned an undefined value or because it was intentionally deleted.
This discussion brings up one additional warning: Assigning an empty
list to an array slice does not remove any array elements (it merely
assigns an undefined value to the slice elements). Thus the following
two statements do not produce the same result (even if it might seem
that they are logically equivalent):
my @array = (0,1,2,3,4,5,6);
@array[0..$#array] = ();
print join(':', @array),"\n";
my @array = (0,1,2,3,4,5,6);
@array = ();
print join(':', @array),"\n";
Even though the first snippet assigns an empty list to a slice covering
the entire array, the array slots themselves are still considered to be
in the array. The second snippet assigns the empty list to the array
itself and therefore results in an empty array.
