These are also used (though not as often as shift).
Shift is used the most because it removes and returns the next item in an array. This is ideal for subroutines, where each call to shift() gets the next argument passed to the subroutine.

Example:

#!/usr/bin/perl
use strict;

&doIt("foo", "bar", "foobar");

sub doIt() {

print shift, "\n"; #prints "foo"
print shift, "\n"; #prints "bar"
print shift, "\n"; #prints "foobar"

}
[download]

Or, if you are demented in the head, you could use pop() and pass the arguments backwards:

#!/usr/bin/perl
use strict;

&doIt("foo", "bar", "foobar");

sub doIt() {

print pop, "\n"; #prints "foobar"
print pop, "\n"; #prints "bar"
print pop, "\n"; #prints "foo"

}
[download]

Though as far as subroutines go, I have been getting used to using 'named arguments' I suppose you might call them:

#!/usr/bin/perl
use strict;

&doIt(-first => "foo", -second => "bar", -third => "foobar");

sub doIt() {
my %params = @_; #turns the passed arguments into an array

print $params{'-first'}, "\n"; #prints "foo"
print $params{'-second'}, "\n"; #prints "bar"
print $params{'-third'}, "\n"; #prints "foobar"

}
[download]

See shift :-)

Update: From perlfunc:shift...

Shifts the first value of the array off and returns it, shortening the array by 1 and moving everything down.

Is that what you're looking for, or have I missed the mark completely?

So, if you have an array, initialized like this:

my @a = ( 'a', 'b', 'c');

my $x = shift @a;
[download]

then after this code executes, $x will contain the scalar value, 'a', and @a will contain, ( 'b', 'c' ).

In lexical scope (i.e., within a subroutine), shift by itself, without any arguments, implicitly acts upon the variable @_, which contains the subroutine's arguments.

At file scope (i.e., outside of any subroutine), it implicitly operates instead upon @ARGV (also known as ::@ARGV, or main::@ARGV), which contains the command line parameters passed to the script.

See the docs, "shift".

dmm

So, why exactly was it needed at all in my example?

Wouldn't:

send_http_header('text/plain');
print("mod_perl rules!\n");
[download]

be identical? (guess I should try this, huh?)

It didn't work... Undefined subroutine !

P.S. the original example was the ENTIRE program, not within a subroutine, that's why I was so puzzled as to what was shifting (and why).

sub greet {
    my $name = shift;
    print "Hello, $name\n";
}

greet('dev2000');
[download]

In mod_perl, with Apache::Registry, your script is cached in a sub, and that sub gets the Apache object as its argument. You could of course write this:

$_[0]->send_http_header('text/plain');
$_[0]->print("mod_perl rules!\n");
[download]

But it's easier to have a named variable for that, especially when you use other subs and your @_ gets overwritten.

Back to the point, your script:

my $r = shift;
...
[download]

is wrapped in a sub so it can be cached:

package Some::URL::Based::Package::Name;use Apache qw(exit);sub handle
+r {
#line 1 script.pl
my $r = shift;
...

}
[download]

And suddenly, it all makes sense.

- Yes, I reinvent wheels.
- Spam: Visit eurotraQ.

Because $r is being used as an object, by calling its send_http_header() and print() methods. Without the shift (I presume this is inside a subroutine), the object represented by the reference $r would never be referenced and the code would not work.

P.S., without seeing the context in which your example lives, it I do not exactly know what kind of object $r is , but from its method names, I suspect it's one of the Http::XXX'en.

dmm

If you GIVE a man a fish you feed him for a day
But, TEACH him to fish and you feed him for a lifetime

Apache=SCALAR(0x87e40c0)
[download]

Apache::Registry is one of the simplest ways to use mod_perl. It takes a CGI-like script from a CGI-program-like-file, and turns it into a specific subroutine invoked when a particular URL is requested.

It's running at full mod_perl speed, but you'll find for more flexibility, you'll want to get away from the "persistent CGI" model and more towards "content handler" and "web application" models as you progress in your mod_perl knowledge.

-- Randal L. Schwartz, Perl hacker