OK, here's the basic gist: splice is a bit to arrays, what substr is to strings. You can cut out a section of an array, and replace it with something else. There's no way to just get an excerpt from an array, and leaving it alone: use an array slice for that. To add to the confusion, the two words look much alike, don't they? I'll come back to slices later.

So here's the basic syntax. We'll make an array containing 9 lower case letters. Then we'll extract two items, skipping the first 3, so taking the fourth and fifth item, and replace them with 3 other items, each an uppercase letter.

Excelent, a good explination of the function. In my opinion you should consider putting this in the "Tutorials" section.

use strict;
use Data::Dumper;

my @table = (
   [qw(a b c)],
   [qw(d e f)],
   [qw(g h i)],
);

my @col = map { splice @$_,1,1 } @table;

print Dumper \@col;
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

The most important thing to learn about splice (and most perl functions for that matter) is that the documents for it come along with perl itself. Try typing: perldoc -f splice

-sauoq
"My two cents aren't worth a dime.";

my @array = qw(i do not like carrot);
print "@array\n"; # you know;
my @carrot = splice(@array,2,3,(qw(mow the lawn)));
print "@array but @carrot\n";
[download]

splice ARRAY, OFFSET, LENGTH, LIST
splice ARRAY, OFFSET, LENGTH
splice ARRAY, OFFSET

This function removes the elements designated by OFFSET and LENGTH fro
+m an array, and replaces them with the elements of LIST, if any. The 
+function returns the elements removed from the array. The array grows
+ or shrinks as necessary. If LENGTH is omitted, the function removes 
+everything from OFFSET onward. The following equivalences hold (assum
+ing $[ is 0):

Direct Method        Splice Equivalent
--------------------------------------------------- 
push(@a, $x, $y)    | splice(@a, $#a+1, 0, $x, $y) 
pop(@a)             | splice(@a, -1) 
shift(@a)           | splice(@a, 0, 1) 
unshift(@a, $x, $y) | splice(@a, 0, 0, $x, $y) 
$a[$x] = $y         | splice(@a, $x, 1, $y); 

The splice function is also handy for carving up the argument list pas
+sed to a subroutine. For example, assuming list lengths are passed be
+fore lists:

sub list_eq {       # compare two list values
    my @a = splice(@_, 0, shift);
    my @b = splice(@_, 0, shift);
    return 0 unless @a == @b;       # same len?
    while (@a) {
        return 0 if pop(@a) ne pop(@b);
    }
    return 1;
}
if (list_eq($len, @foo[1..$len], scalar(@bar), @bar)) { ... }
It would probably be cleaner just to use references for this, however.
[download]