Ist 'shift' schlecht für die Verarbeitung von Perl-Unterprogrammparametern?

Den Einsatz von shift zum entpacken der Argumente ist nicht böse. Es ist eine Allgemeine Konvention und kann der Schnellste Weg, um Prozess-Argumente (je nachdem, wie viele es sind und wie Sie sind) übergeben. Hier ist ein Beispiel für ein Recht häufiges Szenario, in dem das der Fall ist: eine einfache accessor.

use Benchmark qw(cmpthese);

sub Foo::x_shift { shift->{'a'} }
sub Foo::x_ref   { $_[0]->{'a'} }
sub Foo::x_copy  { my $s = $_[0]; $s->{'a'} }

our $o = bless {a => 123}, 'Foo';

cmpthese(-2, { x_shift => sub { $o->x_shift },
               x_ref   => sub { $o->x_ref   },
               x_copy  => sub { $o->x_copy  }, });

Der Ergebnisse auf perl 5.8.8 auf meinem Rechner:

            Rate  x_copy   x_ref x_shift
x_copy  772761/s      --    -12%    -19%
x_ref   877709/s     14%      --     -8%
x_shift 949792/s     23%      8%      --

Nicht dramatisch, aber es ist so. Immer testen Sie Ihr Szenario, in dem Sie Ihre perl-version auf der Ziel-hardware, um herauszufinden, für sicher.

shift ist auch nützlich in Fällen, wo Sie verschieben möchten, aus der invocant und rufen dann eine SUPER:: Methode übergeben, die restlichen @_.

sub my_method
{
  my $self = shift;
  ...
  return $self->SUPER::my_method(@_);
}

Wenn ich hatte eine sehr lange Reihe von my $foo = shift; Operationen an der Spitze einer Funktion, jedoch, könnte ich überlegen, ein Massen kopieren von @_ statt. Aber im Allgemeinen, wenn Sie eine Funktion oder Methode, die dauert mehr als eine Handvoll Argumente, benannte Parameter verwenden (d.h., fangen alle @_ im %args hash oder erwartet einen einzigen hash-Referenz-argument), ist ein viel besserer Ansatz.

InformationsquelleAutor der Antwort John Siracusa

Dies ist, wie die anderen gesagt haben, ist eine Frage des Geschmacks.

Ich in der Regel lieber meine shift-Parameter in lexikale, weil es mir einen standard-Ort zu erklären, eine Gruppe von Variablen, werden im Unterprogramm verwendet. Die extra Ausführlichkeit gibt mir einen schönen Ort zu hängen Kommentare. Es macht es auch einfach default Werte in eine ordentliche Mode.

sub foo {
    my $foo = shift;       # a thing of some sort.
    my $bar = shift;       # a horse of a different color.
    my $baz = shift || 23; # a pale horse.

    # blah
}

Wenn Sie wirklich besorgt über die Geschwindigkeit der Aufruf der Routinen, nicht entpacken, deine Argumente überhaupt-greifen Sie direkt über @_. Seien Sie vorsichtig, das sind Verweise auf die Anrufer-Daten, die Sie arbeiten mit. Dies ist eine gemeinsame Redewendung in POE. POE bietet eine Reihe von Konstanten, die Sie verwenden, um get-Parameter mit Namen:

sub some_poe_state_handler {
    $_[HEAP]{some_data} = 'chicken';
    $_[KERNEL]->yield('next_state');
}

Nun die dummen großen Fehler, den Sie bekommen können, wenn Sie Ihren gewöhnlichen entpacken params mit shift ist:

sub foo {
    my $foo = shift;
    my $bar = shift;
    my @baz = shift;

    # I should really stop coding and go to bed.  I am making dumb errors.

}

Ich denke, dass eine konsequente code-Stil ist wichtiger als eine bestimmte Stil. Wenn alle meine Mitarbeiter verwendet, die Liste der Zuordnung der Art, ich würde es auch benutzen.

Wenn mein Mitarbeiter sagte, es sei ein großes problem mit shift zu entpacken, ich würde Fragen, für eine demonstration, warum es schlecht ist. Wenn der Fall solide ist, dann würde ich etwas lernen. Wenn der Fall Humbug ist, dann könnte ich es widerlegen und zu stoppen, die Verbreitung von anti-Kenntnisse. Dann würde ich vorschlagen, dass wir bestimmen einen standard-Methode und Folgen für die zukünftige code. Ich könnte sogar versuchen, eine Perl::Critic-Richtlinie zu prüfen, für die entschieden ist standard.

InformationsquelleAutor der Antwort daotoad

Ich glaube nicht, dass shift ist böse. Die Verwendung von shift zeigt Ihre Bereitschaft, eigentlich der name Variablen - statt mit $_[0].

Persönlich benutze ich shift wenn es nur einen einzigen parameter in einer Funktion. Wenn ich mehr als einen parameter, ich werde die Liste Kontext.

 my $result = decode($theString);

 sub decode {
   my $string = shift;

   ...
 }

 my $otherResult = encode($otherString, $format);

 sub encode {
   my ($string,$format) = @_;
   ...
 }

InformationsquelleAutor der Antwort Kevin

Gibt es eine Optimierung für die Listen-Zuweisung.

Die einzige Referenz, die ich finden konnte, ist diese eine.

5.10.0 versehentlich deaktiviert eine Optimierung, die verursacht
messbare performance-drop in der Liste
Zuordnung, wie oft verwendet, um
weisen Sie die Funktion Parameter aus @_ .
Die Optimierung wurde wiederhergestellt,
und die performance regression behoben.

Dies ist ein Beispiel für die betroffene Leistung regression.

sub example{
  my($arg1,$arg2,$arg3) = @_;
}

InformationsquelleAutor der Antwort Brad Gilbert