C'è una differenza tra lo spostamento di Perl rispetto all'assegnazione da @_ per i parametri della subroutine?
https://stackoverflow.com/questions/415297
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Ignoriamo per un momento la migliore pratica di Damian Conway di non più di tre parametri posizionali per ogni subroutine.
C'è qualche differenza tra i due esempi seguenti in termini di prestazioni o funzionalità?
Uso di shift :
sub do_something_fantastical {
my $foo = shift;
my $bar = shift;
my $baz = shift;
my $qux = shift;
my $quux = shift;
my $corge = shift;
}
Uso di @_ :
sub do_something_fantastical {
my ($foo, $bar, $baz, $qux, $quux, $corge) = @_;
}
A condizione che entrambi gli esempi siano gli stessi in termini di prestazioni e funzionalità, cosa pensano le persone di un formato rispetto all'altro? Ovviamente l'esempio che usa @_ è meno righe di codice, ma non è più leggibile usare shift come mostrato nell'altro esempio? Le opinioni con buon ragionamento sono benvenute.
Soluzione
C'è una differenza funzionale. Il shift modifica @_ e l'assegnazione da @_ no. Se non hai bisogno di usare @_ in seguito, quella differenza probabilmente non ti interessa. Cerco di utilizzare sempre l'assegnazione dell'elenco, ma a volte utilizzo shift .
Tuttavia, se inizio con shift , in questo modo:
my( $param ) = shift;
Creo spesso questo errore:
my( $param, $other_param ) = shift;
Questo perché non uso shift così spesso, quindi dimentico di passare al lato destro del compito per cambiarlo in @_ . Questo è il punto della migliore pratica nel non usare shift . Potrei creare linee separate per ogni shift come hai fatto nel tuo esempio, ma è solo noioso.
Altri suggerimenti
Almeno sui miei sistemi, sembra dipendere dalla versione di Perl e dall'architettura:
#!/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 {
Almeno sui miei sistemi, sembra dipendere dalla versione di Perl e dall'architettura:
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% --
Risultati:
<*>
Quindi sembra che list_copy sia in genere più veloce del 20% rispetto allo spostamento, ad eccezione di Perl 5.10, dove lo spostamento è in realtà leggermente più veloce!
Nota che questi sono risultati rapidamente derivati. Le differenze di velocità effettive saranno maggiori rispetto a quanto elencato qui, poiché Benchmark conta anche il tempo impiegato per chiamare e restituire le subroutine, il che avrà un effetto moderatore sui risultati. Non ho fatto alcuna indagine per vedere se Perl sta facendo un tipo speciale di ottimizzazione. Il chilometraggio può variare.
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;
}
Risultati:
<*>Quindi sembra che list_copy sia in genere più veloce del 20% rispetto allo spostamento, ad eccezione di Perl 5.10, dove lo spostamento è in realtà leggermente più veloce!
Nota che questi sono risultati rapidamente derivati. Le differenze di velocità effettive saranno maggiori rispetto a quanto elencato qui, poiché Benchmark conta anche il tempo impiegato per chiamare e restituire le subroutine, il che avrà un effetto moderatore sui risultati. Non ho fatto alcuna indagine per vedere se Perl sta facendo un tipo speciale di ottimizzazione. Il chilometraggio può variare.
Paul
Immagino che l'esempio shift sia più lento dell'uso di @_ perché sono 6 chiamate di funzione anziché 1. Se è evidente o addirittura misurabile è una domanda diversa. Lancia ciascuno in un ciclo di 10k iterazioni e cronometri.
Per quanto riguarda l'estetica, preferisco il metodo @_. Sembra che sarebbe troppo facile confondere l'ordine delle variabili usando il metodo shift con un incolla e incolla accidentali. Inoltre, ho visto molte persone fare qualcosa del genere:
sub do_something {
my $foo = shift;
$foo .= ".1";
my $baz = shift;
$baz .= ".bak";
my $bar = shift;
$bar .= ".a";
}
Questo, IMHO, è molto brutto e potrebbe facilmente portare ad errori, ad es. se tagli il blocco baz e lo incolli sotto il blocco barra. Sono tutto per definire le variabili vicino a dove vengono utilizzate, ma penso che la definizione delle variabili passate nella parte superiore della funzione abbia la precedenza.
Di solito uso la prima versione. Questo perché di solito ho bisogno di avere un controllo degli errori insieme ai turni, che è più facile da scrivere. Dire,
sub do_something_fantastical {
my $foo = shift || die("must have foo");
my $bar = shift || 0; # $bar is optional
# ...
}
Preferisco decomprimere @_ come elenco (il tuo secondo esempio). Tuttavia, come tutto in Perl, ci sono casi in cui l'uso di shift può essere utile. Ad esempio, i metodi passthru che devono essere sovrascritti in una classe base ma si desidera assicurarsi che le cose funzionino ancora se non vengono ignorate.
package My::Base;
use Moose;
sub override_me { shift; return @_; }
Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
sub raise {
my $inc = shift;
map { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
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 = Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
sub raise {
my $inc = shift;
map { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $inc} @_;
}
sub moreSpecial {
my ($inc, $power) = (shift(), shift());
map {( Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $inc) ** $power} @_;
}
sub quadratic {
my ($a, $b, $c) = splice @_, 0, 3;
map {$a* Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
* Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $b* Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $c} @_;
}
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0];
unshift @_, $treeNode->{type}; # set type
goto &_switch; # tail call
}
sub switchCompact #(treeNode, transform[, params, ...])
{
my $treeNode = Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
sub raise {
my $inc = shift;
map { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $inc} @_;
}
sub moreSpecial {
my ($inc, $power) = (shift(), shift());
map {( Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $inc) ** $power} @_;
}
sub quadratic {
my ($a, $b, $c) = splice @_, 0, 3;
map {$a* Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
* Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $b* Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub fast1 { shift->call(@_) }
sub fast2 { Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
sub do_something_fantastical2 {
my ( $foo, $bar, $baz, @rest ) = @_;
...
}
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
+ $c} @_;
}
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[1]) }
Ma torniamo alla tua domanda. Preferisco anche l'assegnazione @_ in una riga rispetto ai turni per molti parametri in questo modo
<*>
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0];
unshift @_, (%$treeNode)[0]; # set type given as first key
goto &_switch; # tail call
}
sub ExTreeToCompact {
my $tree = shift;
return switchExTree( $tree, \%transformExTree2Compact );
}
sub CompactToExTree {
my $tree = shift;
return switchCompact( $tree, \%transformCompact2ExTree );
}
Quando Suspect @rest non sarà troppo grande. Nell'altro caso
<*>
In rari casi ho bisogno dell'ottimizzazione delle chiamate in coda (ovviamente a mano) quindi devo lavorare direttamente con @_, per quanto valga la pena una funzione breve.
<*>
Dove% transformExTree2Compact e% transformCompact2ExTree sono hash con il tipo in chiave e il valore di riferimento del codice che può chiamare tailExTree o switchCompact. Ma questo approccio raramente è davvero necessario e deve tenere meno le dita del college .
In conclusione, la leggibilità e la manutenibilità sono specialmente in perl e l'assegnazione di @_ in una riga è migliore. Se vuoi impostare le impostazioni predefinite puoi farlo subito dopo.
[0]->call("a", Preferisco usare
sub do_something_fantastical {
my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}
Perché è più leggibile. Quando questo codice non viene chiamato molto spesso vale la pena. In casi molto rari si desidera che la funzione venga chiamata spesso e che si usi direttamente @ È efficace solo per funzioni molto brevi e devi essere sicuro che questa funzione non si evolverà in futuro (funzione Scrivi una volta). In questo caso ho confrontato con 5.8.8 che per singolo parametro è shift più veloce di $ _ [0] ma per due parametri usando $ _ [0] e $ _ [1] è più veloce di shift, shift.
<*>
Ma torniamo alla tua domanda. Preferisco anche l'
Il modo migliore, IMHO, è una leggera miscela dei due, come nella nuova funzione di un modulo:
our $Class;
sub new {
my $Class = shift;
my %opts = @_;
my $self = \%opts;
# validate %opts for correctness
...
bless $self, $Class;
}
Quindi, tutti gli argomenti di chiamata al costruttore vengono passati come hash, il che rende il codice molto più leggibile di un semplice elenco di parametri.
Inoltre, come ha detto brian , la variabile @_ non è modificata, il che può essere utile in casi insoliti.
Sospetto che tu stia facendo l'equivalente (approssimativo) di:
push @bar, shift @_ for (1 :: $ big_number);
Quindi stai facendo qualcosa di sbagliato. Uso sempre il my ($ foo, $ bar) = @_; perché mi sono sparato al piede usando quest'ultimo un paio di volte troppe volte ...
Preferisco
sub factorial{
my($n) = @_;
...
}
Per la semplice ragione che Komodo sarà quindi in grado di dirmi quali sono gli argomenti, quando vado a usarlo.
