The reason this won't work the way you think: (@ary1, $num) = read_data(\@tmpary, $tmpsclr);is documented in the documentation on subs. The return from a sub is always a flat list. Perl shoves everything into @ary1, leaving $num empty.

A reasonable alternative is to return an array ref and a scalar:

($ary1ref, $num) = read_data(...);
@ary1 = @$ary1ref;      # silly, but gets the point across
# ... later ...
sub read_data
{
    # ...
    return \@retary, $count;
}
[download]

HTH

First, if you know that the first n will be your array and the last will be a seperate value then you can use that when picking up your information.

#callMult returning an array and a scalar
my @ret = callMult();
my $foo = pop @ret;
[download]

sub callMult {
  return \@result, $count;
}

my ($result, $count) = callMult();

# you can then use
$result->[$i]; # to access the array elements
# or
@result_array = @$result; # to dereference it
[download]

You can't easily return an array and a scalar - the array is going to consume all the returned values (the scalar included).

In this case it's best to just return a ref to the array as well as the scalar like so:

sub do_something
{
    ...
    return \@someValues, $someValue;
}

($someValues_aref, $endValue) = do_something();
[download]

(@someValues) = do_something();
$endValue = pop(@someValues);
[download]

    return @retary, $count;
[download]

There are two ways to accomplish what you're trying to do. First, you can pass $count before the array contents:

    return $count, @retary;
    ...
    ($count, @ary1) = read_data(...);
[download]

The other method is to return a reference to @retary instead of returning the array's contents:

    return \@retary, $count;
    ...
    ($ary1, $count) = read_data(...);
[download]

Finally, let me add that, if $count is just the number of elements in @retary, there's really no need to pass it as a separate value. The caller can derive the size of the array from the array itself:

    @ary1 = read_data(...);
    $num = @ary1;
OR
    $ary1 = read_data(...);
    $num = @$ary1;
[download]

use strict;
use warnings;

sub getStuff { return 6, qw(one two three four five six) }

my ($thing, @list) = getStuff();

print "my thing is $thing\n";
print "my list is @list\n";
[download]

$ perl list.pl
my thing is 6
my list is one two three four five six
[download]

Hope this helps,
Ira,

"So... What do all these little arrows mean?"
~unknown

... return $count,@retary;

...

($num,@ary1)=blablabla
[download]

Thanks for all your suggestions. Reversing the scalar and array worked great, and the other ideas I'll keep for if I need to return mixed and multiple.

Brother Descartes

Why return the count at all?

If the caller wants the count it can get it directly from the returned array.

#useful caller code goes here

my(@arr,$count);
@arr=myfunction();
$count=@arr;

#more caller here
[download]

An array evaluated in a scalar context such as assigning to a scalar gives the number of elements in the array.

Update: seems that this is bad for some reason. The question could have been (or probably will be read by) new perl users and so knowing that you need not return the count of an array to access it is valuable? The original node said nothing about the array being multidimensional.

The reason for returning a count is that the returned array is multi-dimensional, and while I could just divide the array count by the number of fields, if the table changed in the future, it would could potentially be a pain for someone else to debug.

Brother Descartes

-- Programmus, ergo sum.

—John