my ($blah) = @_;   # note the ()s. w/o them $blah is the size of @_.
my  $blah  = shift;
[download]

shift modifies @_, which *typically* you don't need to do. For that reason, and for consistency with cases where my method takes args, I prefer the @_ syntax.

my ($first, $second, @rest) = @_;

In OOP, occasionally you want to delegate part of your work to another method. In that case shift sometimes makes sense. You might see code like this.

sub frontend { shift->backend("an extra arg", @_) }

Update: Perl6 - how could I forget :)

In Perl6, you don't normally need to access @_ explicitly. Declare the formal argument and that's that.

sub mine ($blah) {
    say "$blah is now visible here.";
}
[download]

my (@blah) = @_;
[download]

my $blah = shift;
[download]

Are you sure you are quoting Learning Perl fairly? I suspect that what you saw was

my ($blah) = @_;
[download]

my $blah = shift;
[download]

my @blah = @_;
[download]

In contrast, what you quoted,

my $blah = @_;
[download]

I also find the shift idiom useful when I have a function that acts on a list of arguments based on the very first parameters; in this way, instead of:

sub somesub {
   my ($first, $second, @list) = @_
   foreach my $element (@list) {
      # do something, possibly intelligent
   }
}
[download]

sub somesub_nocopy {
   my $first = shift;
   my $second = shift;
   foreach my $element (@_) {
      # do something, possibly intelligent
   }
}
[download]

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.

Update: rephrased to avoid implying that gaal is suggesting to actually use shift other than for facade methods.

I just started reading Learning Perl Objects, References and Modules this morning, so I should get to the shift soon.

Thanks.

Walking the road to enlightenment... I found a penguin and a camel on the way.....
Fancy a yourname@perl.me.uk? Just ask!!!

use strict;

my $a = 1;

change($a);
print "a is now: $a\n";

not_change($a);
print "a is now: $a\n";

sub change{
    ++$_[0];
}

sub not_change{
    my $b = shift;
    ++$b;
}
__OUTPUT__
a is now: 2
a is now: 2
[download]

my @a = 1..10;

{
        my $s = shift @a;

        print "$s\n"

        #result: 1 which is the 1st @a array element
}

{
        my $s = @a;

        print "$s\n"
     
        #result: 9 which is the number of @a array elements
}
[download]