'Deleting' elements from an array might mean two things: deleting the value for a particular index (or indices) in the array (while still leaving the slot in the array open), or, actually removing a slot (and its contents) from the array. The first case can be accomplished with the delete() function and the second with the splice function.

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), & quot; \n & quot; ;
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 onethat 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.

» posted by ITworld staff

ITworld

• Email
• Print
• Share
  • Slashdot
  • Digg
  • Stumble
  • Reddit
  • Newsvine