¿Hay alguna diferencia entre el cambio de Perl versus la asignación de @_ para los parámetros de subrutina?

StackOverflow https://stackoverflow.com/questions/415297

  •  03-07-2019
  •  | 
  •  

Pregunta

Ignoremos por un momento la mejor práctica de Damian Conway de no más de tres parámetros posicionales para una subrutina determinada.

¿Hay alguna diferencia entre los dos ejemplos a continuación con respecto al rendimiento o la funcionalidad?

Uso de shift : 

sub do_something_fantastical {
    my $foo   = shift;
    my $bar   = shift;
    my $baz   = shift;
    my $qux   = shift;
    my $quux  = shift;
    my $corge = shift;
}

Uso de @_ : 

sub do_something_fantastical {
    my ($foo, $bar, $baz, $qux, $quux, $corge) = @_;
}

Siempre que ambos ejemplos sean iguales en términos de rendimiento y funcionalidad, ¿qué piensa la gente sobre un formato sobre el otro? Obviamente, el ejemplo que usa @_ es menos líneas de código, pero ¿no es más legible usar shift como se muestra en el otro ejemplo? Las opiniones con buen razonamiento son bienvenidas.

¿Fue útil?

Solución

Hay una diferencia funcional. El shift modifica @_ , y la asignación de @_ no lo hace. Si no necesita usar @_ más adelante, esa diferencia probablemente no sea importante para usted. Intento usar siempre la asignación de lista, pero a veces uso shift .

Sin embargo, si empiezo con shift , así: 

 my( $param ) = shift;

A menudo creo este error: 

 my( $param, $other_param ) = shift;

Esto se debe a que no uso shift tan a menudo, por lo que me olvido de pasar al lado derecho de la tarea para cambiar eso a @_ . Ese es el punto de la mejor práctica en no usar shift . Podría hacer líneas separadas para cada shift como hiciste en tu ejemplo, pero eso es tedioso.

Otros consejos

Al menos en mis sistemas, parece depender de la versión de Perl y la arquitectura: 

#!/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 {
    
 Al menos en mis sistemas, parece depender de la versión de Perl y la arquitectura: 



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%        --




 Resultados: 


<*>


 Parece que list_copy suele ser un 20% más rápido que los cambios, excepto en Perl 5.10, ¡donde los cambios son en realidad un poco más rápidos! 



 Tenga en cuenta que estos fueron resultados rápidamente derivados. Las diferencias de velocidad reales serán  mayores  que las que se enumeran aquí, ya que Benchmark también cuenta el tiempo necesario para llamar y devolver las subrutinas, lo que tendrá un efecto moderador en los resultados. No he hecho ninguna investigación para ver si Perl está haciendo algún tipo especial de optimización. Su kilometraje puede variar. 



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;
}

Resultados:

<*>

Parece que list_copy suele ser un 20% más rápido que los cambios, excepto en Perl 5.10, ¡donde los cambios son en realidad un poco más rápidos!

Tenga en cuenta que estos fueron resultados rápidamente derivados. Las diferencias de velocidad reales serán mayores que las que se enumeran aquí, ya que Benchmark también cuenta el tiempo necesario para llamar y devolver las subrutinas, lo que tendrá un efecto moderador en los resultados. No he hecho ninguna investigación para ver si Perl está haciendo algún tipo especial de optimización. Su kilometraje puede variar.

Paul

Me imagino que el ejemplo de cambio es más lento que usar @_ porque son 6 llamadas de función en lugar de 1. Si es notable o incluso mensurable, es una pregunta diferente. Lance cada una en un bucle de 10k iteraciones y tómelas el tiempo.

En cuanto a la estética, prefiero el método @_. Parece que sería demasiado fácil desordenar el orden de las variables utilizando el método de cambio con un corte y pegado accidental. Además, he visto a muchas personas hacer algo como esto: 

sub do_something {
   my $foo = shift;
   $foo .= ".1";

   my $baz = shift;
   $baz .= ".bak";

   my $bar = shift;
   $bar .= ".a";
}

Esto, en mi humilde opinión, es muy desagradable y podría fácilmente dar lugar a errores, por ejemplo. si cortas el bloque de baz y lo pegas debajo del bloque de barra. Estoy a favor de definir las variables cerca de donde se usan, pero creo que tiene prioridad la definición de las variables pasadas en la parte superior de la función.

Usualmente uso la primera versión. Esto se debe a que generalmente necesito tener una verificación de errores junto con los turnos, que es más fácil de escribir. Decir, 

sub do_something_fantastical {
    my $foo   = shift || die("must have foo");
    my $bar   = shift || 0;  # $bar is optional
    # ...
}

Prefiero descomprimir @_ como una lista (su segundo ejemplo). Sin embargo, como todo en Perl, hay casos en los que usar shift puede ser útil. Por ejemplo, los métodos passthru que están destinados a ser anulados en una clase base, pero desea asegurarse de que las cosas sigan funcionando si no se anulan. 


package My::Base;
use Moose;
sub override_me { shift; return @_; }

Prefiero usar 

sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}

Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 

sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 



sub raise {
    my $inc = shift;
    map {
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 



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 = 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 



sub raise {
    my $inc = shift;
    map {
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $inc} @_;
}

sub moreSpecial {
    my ($inc, $power) = (shift(), shift());
    map {(
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $inc) ** $power} @_;
}

sub quadratic {
    my ($a, $b, $c) = splice @_, 0, 3;
    map {$a*
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
*
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $b*
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $c} @_;
}




 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0];
    unshift @_, $treeNode->{type};    # set type
    goto &_switch;                    # tail call
}

sub switchCompact                     #(treeNode, transform[, params, ...])
{
    my $treeNode = 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 



sub raise {
    my $inc = shift;
    map {
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $inc} @_;
}

sub moreSpecial {
    my ($inc, $power) = (shift(), shift());
    map {(
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $inc) ** $power} @_;
}

sub quadratic {
    my ($a, $b, $c) = splice @_, 0, 3;
    map {$a*
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
*
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $b*
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub fast1 { shift->call(@_) }

sub fast2 { 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 



sub do_something_fantastical2 {
    my ( $foo, $bar, $baz, @rest ) = @_;
    ...
}




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
 + $c} @_;
}




 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0]->call("a", 
 Prefiero usar 



sub do_something_fantastical {
    my ( $foo, $bar, $baz, $qux, $quux, $corge ) = @_;
}




 Porque es más legible. Cuando este código no se llama con mucha frecuencia, vale la pena. En casos muy raros, desea que la función make se llame con frecuencia y luego use @_ directamente. Es efectivo solo para funciones muy cortas y debe estar seguro de que esta función no evolucionará en el futuro (función Escribir una vez). En este caso, comparé en 5.8.8 que para un solo parámetro es shift más rápido que $ _ [0] pero para dos parámetros que usan $ _ [0] y $ _ [1] es más rápido que shift, shift. 


<*>


 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[1]) }




 Pero volvamos a tu pregunta. & Nbsp; también prefiero la asignación @_ en una fila sobre los turnos para muchos parámetros de esta manera 


<*>


 Cuando Sospechoso @rest no será demasiado grande. En otro caso 


<*>


 En raras ocasiones necesito la optimización de llamadas de cola (a mano, por supuesto), entonces debo trabajar directamente con @_, que para una función corta vale la pena.

<*>


 Donde% transformExTree2Compact y% transformCompact2ExTree son hashes con tipo en clave y código ref. en el valor que puede llamar a switchExTree o switchCompact its. Pero  este enfoque rara vez es realmente necesario y debe mantener menos valiosos los dedos de la universidad . 



 En conclusión, la legibilidad y la facilidad de mantenimiento se deben especialmente en perl y la asignación de @_ en una fila es mejor. Si desea establecer valores predeterminados, puede hacerlo justo después. 
[0];
    unshift @_, (%$treeNode)[0];      # set type given as first key
    goto &_switch;                    # tail call
}

sub ExTreeToCompact {
    my $tree = shift;
    return switchExTree(

La mejor manera, en mi humilde opinión, es una ligera mezcla de los dos, como en la nueva función en un módulo: 

our $Class;    
sub new {
    my $Class = shift;
    my %opts = @_;
    my $self = \%opts;
    # validate %opts for correctness
    ...
    bless $self, $Class;
}

Entonces, todos los argumentos de llamada al constructor se pasan como un hash, lo que hace que el código sea mucho más legible que solo una lista de parámetros.

Además, como brian dijo , la variable @_ no se modifica, lo que puede ser útil en casos inusuales.

Sospecho que si estás haciendo el equivalente (aproximado) de:

push @bar, shift @_ for (1 :: $ big_number);

Entonces estás haciendo algo mal. Casi siempre uso el formulario my ($ foo, $ bar) = @_; porque me he disparado en el pie con este último demasiadas veces ...

Prefiero 

sub factorial{
  my($n) = @_;

  ...

}

Por la sencilla razón de que Komodo podrá decirme cuáles son los argumentos, cuando vaya a usarlo.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top