Existe-t-il une différence entre le décalage de Perl et l'affectation de @_ pour les paramètres de sous-programme?
https://stackoverflow.com/questions/415297
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Ignorons un instant la meilleure pratique de Damian Conway consistant à ne pas adopter plus de trois paramètres de position pour un sous-programme donné.
Existe-t-il une différence entre les deux exemples ci-dessous en ce qui concerne les performances ou les fonctionnalités?
Utilisation de shift :
sub do_something_fantastical {
my $foo = shift;
my $bar = shift;
my $baz = shift;
my $qux = shift;
my $quux = shift;
my $corge = shift;
}
Utilisation de @_ :
sub do_something_fantastical {
my ($foo, $bar, $baz, $qux, $quux, $corge) = @_;
}
À condition que les deux exemples soient identiques en termes de performances et de fonctionnalités, que pensent les gens d’un format à l’autre? Évidemment, l'exemple utilisant @_ correspond à moins de lignes de code, mais l'utilisation de shift n'est-elle pas plus lisible, comme indiqué dans l'autre exemple? Les avis avec un bon raisonnement sont les bienvenus.
La solution
Il y a une différence fonctionnelle. Le décalage modifie @_ et l'affectation de @_ ne le fait pas. Si vous n'avez pas besoin d'utiliser @_ par la suite, cette différence ne vous concerne probablement pas. J'essaie de toujours utiliser l'affectation de liste, mais j'utilise parfois shift .
Cependant, si je commence avec shift , comme suit:
my( $param ) = shift;
Je crée souvent ce bug:
my( $param, $other_param ) = shift;
C'est parce que je n'utilise pas souvent shift . J'oublie donc de passer du côté droit de l'affectation pour le changer en @_ . C’est la raison de ne pas utiliser shift . Je pourrais créer des lignes séparées pour chaque décalage comme vous l'avez fait dans votre exemple, mais c'est fastidieux.
Autres conseils
Au moins sur mes systèmes, cela semble dépendre de la version de Perl et de l'architecture:
#!/usr/bin/perl -w
use strict;
use warnings;
use autodie;
use Benchmark qw( cmpthese );
print "Using Perl $] under $^O\n\n";
cmpthese(
-1,
{
shifted => 'call( \&shifted )',
list_copy => 'call( \&list_copy )',
}
);
sub call {
Au moins sur mes systèmes, cela semble dépendre de la version de Perl et de l'architecture:
Using Perl 5.008008 under cygwin
Rate shifted list_copy
shifted 492062/s -- -10%
list_copy 547589/s 11% --
Using Perl 5.010000 under MSWin32
Rate list_copy shifted
list_copy 416767/s -- -5%
shifted 436906/s 5% --
Using Perl 5.008008 under MSWin32
Rate shifted list_copy
shifted 456435/s -- -19%
list_copy 563106/s 23% --
Using Perl 5.008008 under linux
Rate shifted list_copy
shifted 330830/s -- -17%
list_copy 398222/s 20% --
Résultats:
<*>
Il semble donc que list_copy est généralement 20% plus rapide que le décalage, sauf sous Perl 5.10, où le décalage est en fait légèrement plus rapide!
Notez que ces résultats ont été rapidement dérivés. Les différences de vitesse réelles seront plus grandes que ce qui est répertorié ici, car Benchmark compte également le temps nécessaire pour appeler et renvoyer les sous-routines, ce qui aura un effet modérateur sur les résultats. Je n'ai fait aucune enquête pour savoir si Perl procédait à une optimisation particulière. Votre kilométrage peut varier.
Paul
[0]->(1..6); # Call our sub with six dummy args.
}
sub shifted {
my $foo = shift;
my $bar = shift;
my $baz = shift;
my $qux = shift;
my $quux = shift;
my $corge = shift;
return;
}
sub list_copy {
my ($foo, $bar, $baz, $qux, $quux, $corge) = @_;
return;
}
Résultats:
<*>Il semble donc que list_copy est généralement 20% plus rapide que le décalage, sauf sous Perl 5.10, où le décalage est en fait légèrement plus rapide!
Notez que ces résultats ont été rapidement dérivés. Les différences de vitesse réelles seront plus grandes que ce qui est répertorié ici, car Benchmark compte également le temps nécessaire pour appeler et renvoyer les sous-routines, ce qui aura un effet modérateur sur les résultats. Je n'ai fait aucune enquête pour savoir si Perl procédait à une optimisation particulière. Votre kilométrage peut varier.
Paul
J'imagine que l'exemple de décalage est plus lent que d'utiliser @_ car il s'agit de 6 appels de fonction au lieu de 1. Que ce soit perceptible ou même mesurable est une question différente. Jetez chacun dans une boucle de 10 000 itérations et chronométrez-les.
En ce qui concerne l’esthétique, je préfère la méthode @_. Il semble qu'il serait trop facile de gâcher l'ordre des variables en utilisant la méthode shift avec un copier-coller accidentel. De plus, j'ai vu beaucoup de gens faire quelque chose comme ça:
sub do_something {
my $foo = shift;
$foo .= ".1";
my $baz = shift;
$baz .= ".bak";
my $bar = shift;
$bar .= ".a";
}
Ceci, à mon humble avis, est très méchant et pourrait facilement conduire à des erreurs, par exemple. si vous coupez le bloc baz et collez-le sous le bloc-barres. Je suis tout à fait en faveur de la définition de variables proches de leur utilisation, mais je pense que la définition des variables passées en haut de la fonction a la priorité.
D'habitude j'utilise la première version. C'est parce que j'ai généralement besoin de vérifier les erreurs en même temps que les changements, ce qui est plus facile à écrire. Dis,
sub do_something_fantastical {
my $foo = shift || die("must have foo");
my $bar = shift || 0; # $bar is optional
# ...
}
Je préfère décompresser @_ sous forme de liste (votre deuxième exemple). Bien que, comme tout dans Perl, il existe des cas où utiliser shift peut être utile. Par exemple, les méthodes passthru destinées à être remplacées dans une classe de base, mais vous voulez vous assurer que les choses fonctionnent toujours si elles ne sont pas remplacées.
package My::Base;
use Moose;
sub override_me { shift; return @_; }
Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
sub raise {
my $inc = shift;
map { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
sub _switch #(type, treeNode, transform[, params, ...])
{
my $type = shift;
my ( $treeNode, $transform ) = @_;
unless ( defined $type ) {
require Data::Dumper;
die "Broken node: " . Data::Dumper->Dump( $treeNode, ['treeNode'] );
}
goto &{ $transform->{$type} } if exists $transform->{$type};
goto &{ $transform->{unknown} } if exists $transform->{unknown};
die "Unknown type $type";
}
sub switchExTree #(treeNode, transform[, params, ...])
{
my $treeNode = Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
sub raise {
my $inc = shift;
map { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
+ $inc} @_;
}
sub moreSpecial {
my ($inc, $power) = (shift(), shift());
map {( Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
+ $inc) ** $power} @_;
}
sub quadratic {
my ($a, $b, $c) = splice @_, 0, 3;
map {$a* Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
* Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
+ $b* Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
+ $c} @_;
}
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0];
unshift @_, $treeNode->{type}; # set type
goto &_switch; # tail call
}
sub switchCompact #(treeNode, transform[, params, ...])
{
my $treeNode = Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
sub raise {
my $inc = shift;
map { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
+ $inc} @_;
}
sub moreSpecial {
my ($inc, $power) = (shift(), shift());
map {( Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
+ $inc) ** $power} @_;
}
sub quadratic {
my ($a, $b, $c) = splice @_, 0, 3;
map {$a* Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
* Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[1]) }
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
+ $b* Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Mais revenons à votre question. Je préfère également @_ l'affectation dans une rangée par rapport aux décalages de nombreux paramètres de cette manière
<*>
Quand Suspect @rest ne sera pas trop gros. Dans les autres cas
<*>
Dans de rares cas, j'ai besoin d'optimisation de l'appel final (à la main, bien sûr), alors je dois travailler directement avec @_, ce qui vaut la peine pour une fonction courte.
<*>
Où% transformExTree2Compact et% transformCompact2ExTree sont des hachages avec une clé de type et une référence de code dans une valeur pouvant appeler les commutateurs switchExTree ou switchCompact. Mais cette approche est rarement vraiment nécessaire et doit garder moins de valeur pour les étudiants . .
En conclusion, la lisibilité et la maintenabilité sont essentielles, surtout en perl, et l’affectation de @_ dans une ligne est préférable. Si vous voulez définir des valeurs par défaut, vous pouvez le faire juste après.
[0]->call("a", Je préfère utiliser
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Parce que c'est plus lisible. Lorsque ce code n'est pas appelé trop souvent, il vaut la peine. Dans de très rares cas, vous souhaitez créer une fonction appelée souvent et utiliser directement @_. Elle n’est efficace que pour des fonctions très courtes et vous devez être sûr que cette fonction n’évolue pas à l’avenir (fonction Write once). Dans ce cas, je me suis référencé en 5.8.8 que pour un seul paramètre, le décalage était plus rapide que $ _ [0], mais que pour deux paramètres utilisant $ _ [0] et que $ _ [1] était plus rapide que shift, shift.
<*>
Ma
La meilleure façon, à mon humble avis, est un léger mélange des deux, comme dans la nouvelle fonction d'un module:
our $Class;
sub new {
my $Class = shift;
my %opts = @_;
my $self = \%opts;
# validate %opts for correctness
...
bless $self, $Class;
}
Ensuite, tous les arguments d'appel au constructeur sont passés sous forme de hachage, ce qui rend le code beaucoup plus lisible qu'une simple liste de paramètres.
De plus, comme brian a déclaré , la variable @_ n'est pas modifiée, ce qui peut être utile dans des cas inhabituels.
Je suppose que si vous faites l'équivalent (approximatif) de:
push @bar, shift @_ for (1 :: $ big_number);
Ensuite, vous faites quelque chose de mal. J'utilise presque toujours la forme mon ($ foo, $ bar) = @_; car je me suis tiré une balle dans le pied en utilisant ce dernier un peu trop souvent ...
je préfère
sub factorial{
my($n) = @_;
...
}
Pour la simple raison que Komodo pourra alors me dire quels sont les arguments, quand je vais l’utiliser.
