You can only pass a list of scalars to a subroutine. Arrays will automatically get flattened into a list:

mysub(@a);
[download]

is the same thing as

mysub($a[0], $a[1], $a[2], ...);
[download]

For example,

sub sortArray {
   return sort @_;
}

my @a = ('e', 'd', 'c', 'b', 'a');
my @sorted = sortArray(@a);
print("@sorted\n");  # a b c d e

# Same thing.
my @sorted = sortArray('e', 'd', 'c', 'b', 'a');
print("@sorted\n");  # a b c d e
[download]

If you want to modify the array, you can pass a reference to the array to the subroutine.

sub sortArray {
   my ($ar) = @_;
   @$ar = sort @$ar;
}

my @a = qw( e d c b a );
sortArray(\@a);
print("@a\n");  # a b c d e
[download]

Some references on references:

• perlref
• Dereferencing Syntax
• References Quick Reference

Update: Added reference links.
Update: Converted first example to sort its arguments.

What do you want to do with it? Just what you have (without the &) is fine:

my @updated = sortArray (@array);

...

sub sortArray {
    my @copy = @_;
    return sort @copy;
}
[download]

if you want to edit the array then passing it by reference may be what you want:

editArray (\@array);

...

sub editArray {
    my $arrayRef = shift;

    push @$arrayRef, 'new array element';
}
[download]

There are other variations and the choice of method mostly depends on things like how big the array is and readability of the code. In particular, if you pass an array by reference that may be a strong hint that it will be updated by the subroutine. Passing an array using (@array) is a strong hint that the contents of the array won't be affected by the subroutine.

Exactly like that. Are you having specific trouble?

I'm a fan of Params::Validate. It's a great module that help you deal with lack of parameter checking in Perl.

This is how you declare your module with it:

use Params::Validate ':all';

sub sortArray
{
    my ($unsorted) = validate_pos(@_, { type => ARRAYREF });

    my @sorted = sort @{ $unsorted };

    return @sorted;
}
[download]

And this is how you can use it:

my @unsorted = (9, 4, 2, 6, 1);
my @sorted = sortArray(\@unsorted);
[download]

You can also use it's validate method for named parameter if your subroutine is likely to get bigger

Hi Perl Monks!

I posted a message here was because I didn't find any reference in my reading book that mentioned about passing an array as the argument into the subrutine.

And i was writing a perl script, which will do exactly what quick sort does. In this script i need write some subrutine as my functions..there is no extra trouble here...

Anyway, I got all answers I wanted from your great replys.

Thank you!!

note that sort does exactly what quick sort does (for some versions of Perl anyway). Unless you are doing this as a learning exercise Perl's built in sort is generally a much better choice than rolling your own.

---

DWIM is Perl's answer to Gödel

sub sortArray(\@) {
    # Array is in @{$_[0]}
}
...
sortArray @arr;
[download]