Warum sollten Sie NICHT ein array zurückgeben, ref?

Nicht. Außer tun "return $result;" für Klarheit.

Ich erinnere mich an die Prüfung der Effizienz und der performance-Unterschied war minimal für kleine arrays. Für große arrays, die einen Verweis war viel schneller.

Es ist wirklich eine Komfort-Sache für das kleine Ergebnis. Würden Sie lieber tun:

($foo,$bar) = barbaz();

Oder Rückgabe einer Referenz:

 $foobar = barbaz();
 $foobar->[0]; # $foo
 $foobar->[1]; # $bar

Einen anderen Weg für die Rückgabe einer Referenz:

($foo,$bar) = @{barbaz()};

Regel, sobald Sie sich entscheiden, welchen Weg zu gehen, halten Sie sich nur an für Sie Modul, da es macht es verwirrend, wechseln von einer Methode zur nächsten.

Ich in der Regel Rückgabe-array von Referenzen auf Listen von ähnlichen Dingen, und ein array, wenn die Antwort besteht aus zwei bis vier verschiedenen Elementen. Mehr als das, ich mache einen hash, da nicht alle Aufrufer kümmert sich um alle response-Elemente.

Da niemand erwähnt über wantarray werde ich 🙂

Halte ich für eine gute Praxis, lassen Sie die Anrufer entscheiden welchem Kontext Sie will das Ergebnis. Zum Beispiel, im code unten, Fragen Sie perl für den Kontext die subroutine aufgerufen wurde, und entscheiden, was Sie zurück.

sub get_things {
    my @things;
    ... # populate things
    return wantarray ? @things : \@things;
}

Dann

for my $thing ( get_things() ) {
    ...
}

und

my @things = get_things();

funktioniert richtig, weil die Liste Kontext, und:

my $things = get_things();

zurückkehren wird, die array-Referenz.

Weitere Infos über wantarray möchten Sie vielleicht, um perldoc -f wantarray.

Edit: ich über-sehenden eine der ersten Antworten, die die bereits erwähnten wantarray, aber ich denke, das ist Antwort ist immer noch gültig, weil es macht es ein wenig klarer.

Ich will einfach nur einen Kommentar auf die Idee, über unbeholfene syntax für die Abwicklung einer array-Referenz im Gegensatz zu einem Liste. Als brian erwähnt, sollten Sie wirklich nicht tun, wenn der rest des Systems ist mithilfe von Listen. Es ist eine unnötige Optimierung in den meisten Fällen.

Wenn das allerdings nicht der Fall, und Sie sind frei, zu erstellen Sie Ihren eigenen Stil, dann eine Sache, die machen die Codierung weniger stinkend ist mit autobox. autobox dreht SCALAR, ARRAY und HASH (sowie andere) in "Pakete", so dass Sie kann code:

my ( $name, $number ) = $obj->get_arrayref()->items( 0, 1 );

anstelle der etwas mehr ungeschickt:

my ( $name, $number ) = @{ $obj->get_arrayref() };

durch die Kodierung so etwas wie dieses:

sub ARRAY::slice { 
    my $arr_ref = shift;
    my $length  = @$arr_ref;
    my @subs    = map { abs($_) < $length ? $_ : $_ < 0 ? 0 : $#$arr_ref } @_;
    given ( scalar @subs ) { 
        when ( 0 ) { return $arr_ref; }
        when ( 2 ) { return [ @{$arr_ref}[ $subs[0]..$subs[1] ] ]; }
        default    { return [ @{$arr_ref}[ @subs ] ]; }
    }
    return $arr_ref; # should not get here.
}

sub ARRAY::items { return @{ &ARRAY::slice }; }

Beachten Sie, dass autobox erfordert, dass Sie alle implementieren das Verhalten, die Sie wollen, aus diesen. $arr_ref->pop() funktioniert nicht, bis Sie definieren sub ARRAY::pop es sei denn, Sie verwenden autobox::Core

Einen wichtigen Auslassungen in den oben genannten Antworten: nicht wieder Verweise auf private Daten!

Beispiel:

package MyClass;

sub new {
  my($class) = @_;
  bless { _things => [] } => $class;
}

sub add_things {
  my $self = shift;
  push @{ $self->{_things} } => @_;
}

sub things {
  my($self) = @_;
  $self->{_things};  # NO!
}

Ja, die Benutzer können peek direkt unter die Haube mit Perl-Objekten implementiert diese Weise aber nicht machen es einfach für die Nutzer unwissentlich Schießen selbst in den Fuß, z.B.,

my $obj = MyClass->new;
$obj->add_things(1 .. 3);

...;

my $things = $obj->things;
my $first = shift @$things;

Besser wäre, um wieder eine (vielleicht zu tief) kopieren Sie Ihre privaten Daten, wie in

sub things {
  my($self) = @_;
  @{ $self->{_things} };
}

Ich bin nicht sicher, ob die Rückkehr eine Referenz ist in diesem Fall effizienter; D. H. ist in Perl kopieren zurückgegebenen Daten durch Unterprogramme?

Im Allgemeinen, wenn dein array aufgebaut ist, vollständig innerhalb des Unterprogramms, dann gibt es keine offensichtliche problem mit der Rückgabe einer Referenz, da sonst das array wäre sowieso verworfen. Allerdings, wenn der Verweis ist auch bestanden woanders zurückgeben können, haben Sie möglicherweise zwei Kopien der gleichen Referenz-und Sie kann geändert werden, in einem Ort, aber nicht zu erwarten, dass anderswo.

Rückgabe eines array gibt einige schöne Vorteile:

my @foo = get_array(); # Get list and assign to array.
my $foo = get_array(); # Get magnitude of list.
my ($f1, $f2) = get_array(); # Get first two members of list.
my ($f3,$f6) = (get_array())[3,6]; # Get specific members of the list.

sub get_array {
   my @array = 0..9;

   return @array;
}

Wenn Sie return array refs, haben Sie zu schreiben, mehrere subs, um die gleiche Arbeit tun. Auch ein leeres array zurückgibt false in einem booleschen Kontext, aber ein leeres array ref nicht.

if ( get_array() ) {
    do_stuff();
}

Wenn Sie return array refs, dann haben Sie zu tun:

if ( @{ get_array_ref() } ) {
    do_stuff();
}

Außer wenn get_array_ref() nicht zurück, ein ref, sprich statt und undef, Wert, Sie haben ein Programm-Absturz aufzuhalten. Eine der folgenden helfen:

if ( @{ get_array() || [] } ) {
    do_stuff();
}

if ( eval{ @{get_array()} } ) {
    do_stuff();
}

So, wenn der speed-Leistungen erforderlich sind, oder wenn Sie eine array-ref (vielleicht möchten Sie ermöglichen die direkte manipulation eines Objekts collection-element--pfui, aber manchmal muss es geschehen), gibt ein array zurück. - ref. Ansonsten find ich die Vorteile von standard-arrays zu bewahren.

Update: Es ist wirklich wichtig zu erinnern, dass das, was du bei einer Rücksendung aus einer routine ist nicht immer ein array oder eine Liste. Was Sie zurückgeben, ist das, was folgt, die return oder das Ergebnis der letzten operation. Ihr Rückgabewert wird ausgewertet im Kontext. Die meisten der Zeit, wird alles in Ordnung sein, aber manchmal kann man unerwartete Verhalten.

sub foo {
    return $_[0]..$_[1];
}

my $a = foo(9,20);
my @a = foo(9,20);

print "$a\n";
print "@a\n";

Vergleichen mit:

sub foo {
    my @foo = ($_[0]..$_[1]);
    return @foo;
}

my $a = foo(9,20);
my @a = foo(9,20);

print "$a\n";
print "@a\n";

So, wenn Sie sagen, "geben ein array zurück," werden Sie sicher, dass Sie meinen wirklich "ein array zurückgeben". Sich bewusst sein, was Sie nach Ihrer Routinen.