my @data = qw( Mon Tue Wed Thurs Fri Sat Sun );

print get_day( $today, \@data );

sub get_day
{
    my ( $index, $datar ) = @_;
    return $datar->[$index];
}
[download]

Update: You know, it helps to have a @_ in a sub too :-/

use warnings;
use strict;
sub multipop(\@$);

my @array  = (1 .. 10);
my @result = multipop @array, 3;
print "@array\n";
print "@result\n";

sub multipop(\@$) {
    my $count = pop;
    my @vars;
    $count = 1 if ! defined $count; # default to normal pop behavior
    if ( $count =~ /^\d+$/ ) {
        my $length = scalar @{$_[0]};
        $count =  $length if $count > $length;
        # Using @{$_[0]} to ensure that we modify original array
        push @vars, splice ( @{$_[0]}, -$count, $count ) if $count > 0
+;
        return @vars;
    } else {
        warn "Second argument to multipop must be numeric: '$count'";
    }
}
[download]

my @result = multipop @array, 3;
[download]

And yeah, that code above is a bit of a hack. If anyone sees problems with it, I'd love to know. It's basically the same thing as pop, but with an optional second argument specifying the number of elements to remove. It could be expanded to take a third argument specifying if the order of elements to remove is to be reversed. It does have a couple of advantages over splice (IMHO): it's easier to read and will not die if you try to pop more elements than the array has. Of course, some may not appreciate the latter "feature".

Oh, and it's slower than splice, too :)

Cheers,
Ovid

Update: Ugh! Stupid me. No third argument. Just make the second one negative for a reverse pop (and add the appropriate code, of course). Sheesh. I try to make things too hard, at times :)

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

A sledgehammer for a nut in his/her case I think,
Nice sledgehammer though.....

  sub doStuff
  {
    my($arg1, $arg2, $arg3, $ar4, @data) = @_;
    ..... # other stuff here
  }
[download]

Meanwhile this should get the the array.
Now if your array were huge (not the two element array mentioned here) then passing by reference might be the way to go.

But I figure if you're scaling the challenge of just getting data in, there's no point throwing variables by reference at you just yet.

But do bookmark the thought it can be useful.
HTH
Claude p.s.

    my($arg1, $arg2, $arg3, $ar4, @data, $arg5) = @_;
[download]

I use shift and references like in the following example. Hope this helps.
Roberto


#!/usr/bin/perl

use strict;

my %hash;
my @array;

# here you pass the references and get them back
my ($ref_hash,$ref_array) = load_variables(\%hash,\@array);

# and then you pass these for printout
print_variables($ref_hash,$ref_array);

##################
sub load_variables {
##################

    my %hash1   = %{ shift() };
    my @array1  = @{ shift() };

### Load array
    @array1 = ('a','b','c');

### Populate the hash (for each character
### set the hash to the next

    map { 
        my $tmp = ++$_;
        $hash1{$_} = qq($tmp);
    } @array1;

### Return the references
    return (\%hash1,\@array1);

}

###################
sub print_variables {
###################

    my %hash2  = %{ shift() };
    my @array2 = @{ shift() };

    map { printf q(hash: ).qq($hash2{$_}\n) } keys %hash2;
}
[download]

$_[0] = $arg1, 
$_[1] = $arg2, 
$_[2] = $arg3, 
$_[3] = $arg4, 
$_[4] = $data[0], 
$_[5] = $data[1]
[download]

Ouch. Please. @foo[0] hurts my eyes. Surely you meant to say:

$_[0] = $arg1,
$_[1] = $arg2,
$_[2] = $arg3,
$_[3] = $arg4,
$_[4] = $data[0],
$_[5] = $data[1]
[download]

A single-element slice is almost never what people want. Warnings-on would have told you that.

-- Randal L. Schwartz, Perl hacker

sub doStuff
{
  @info = @_;
  print "@info";
}
[download]

stephen

Among other advantages is that there will be a d/l link that people can use to get your code directly so they can test it...

    $array = \@array;

    pass_this($anythingelse,$array); 

    sub pass_this(){
      my($firstpassedthing,$array_ref) = (@_);

      @local_array = @{$array_ref}; 
      # now you can play with $local_array[] 
    }
[download]

Edit: chipmunk 2001-03-30