¿Cómo se obtienen múltiples argumentos en las funciones de Perl?

Question

En mi código, estoy estado usando el método bastante primitiva de parámetros de extracción a partir de una llamada a la función de la siguiente manera:

sub addSix ($$$$$$) { 
    my ($a, $b, $c, $d, $e, $f) = (shift, shift, shift, shift, shift, shift); 
    return $a + $b + $c + $d + $e + $f; 
} 

print addSix (1, 2, 3, 4, 5, 6) . "\n"; 

(olvida el código primitivo, el bit saliente es el múltiplo shift llamadas).

Ahora que parece bastante complicado para mí y aunque Perl puede tener algo como:

my ($a, $b, $c, $d, $e, $f) = shift (6); 

o algo similar.

Pero no puedo encontrar nada como eso. Sé que puedo usar matrices para esto, pero creo que todavía tendría que descomprimir la matriz en escalares individuales. Eso no sería tan malo para el caso de ejemplo anterior, donde los seis parámetros son similares, pero estoy más interesado en el caso en que no son realmente adecuados como una matriz.

¿Cómo se pueden extraer los parámetros sin terminar con un marasmo de shift palabras clave?

Answer 1

Usted puede simplemente escribir:

my ($a, $b, $c, $d, $e, $f) = (@_); 

Si no tuviera ese prototipo, y si ese sub fue llamado con más de seis argumentos, los que después de la sexta son simplemente "no se corresponde", $f se establecería en el sexto argumento.

Si quiere ver todos los argumentos después del sexto, puede hacerlo así.

my ($a, $b, $c, $d, $e, $f, @others) = (@_); 

Si su lista de escalares es más larga que la lista en el lado derecho, los últimos elementos serán undef.

Answer 2

El uso de prototipos es altamente desaconsejable a menos que haya un real necesario para ello.

Como siempre con Perl, hay más de una forma de hacerlo.

Aquí es una manera de garantizar la adición de sólo los primeros seis parámetros que se pasan:

use List::Util 'sum'; 

sub addSix { sum @_[0..5] } 

O si lo desea código de auto-documentado:

sub addSix { 

    my @firstSix = @_[0..5]; # Copy first six elements of @_ 
    return sum @firstSix; 
} 

Answer 3

Sé que esto es un hilo de edad, pero me hizo pensar en una mejor manera de cambiar valores múltiples. Todo esto es solo un poco divertido ... Publicando principalmente esto con fines educativos.

Claro, ($x, $y) = @_ es genial si quiere retener @_, pero quizás quiera cambiar sus argumentos por alguna razón? Quizás desee alguna funcionalidad de subrutina adicional determinada por la cantidad de argumentos restantes en @_.

La forma más limpia de una sola línea de lo que podía pensar de hacerlo es con un simple mapa

sub shiftySub { 
    map { $_ = shift } my ($v, $w, $x, $y); 
    # @_ now has up to 4 items removed 
    if (@_) { ... } # do stuff if arguments remain 
} 

• Si se proporcionan argumentos 4, @_ es ahora vacío en el ámbito sub.
• Si se proporcionan 5 argumentos, @_ tiene 1 elemento restante en el ámbito secundario.
• Si se proporcionan 3 argumentos, @_ está vacío, y $y es undef en el alcance secundario.

---

En cuanto paxdiablo 's shift(6) operador teórico, podríamos crear nuestra propia función que realiza esta operación ...

sub shifter (\@;$) { 
    my ($array, $n) = (@_, 1); 
    splice(@$array, 0, $n); 
} 

La función se activa mediante la aplicación de un prototipo pase por ref (una de las razones muy limitadas por las que debe usar prototipos) para asegurarse de que la matriz se cambie en el alcance de la llamada. A continuación se usa simplemente como esto ...

my @items = ('one', 'two', 'three', 'four'); 
my ($x, $y) = shifter(@items, 2); 
# or as a replacement for shift 
my $z = shifter(@items) 
# @items has 1 item remaining in this scope! 

Por supuesto, también se puede utilizar esta función shifter dentro de sus otros submarinos. La desventaja principal de una función como esta es que debe realizar un seguimiento del número de asignaciones en ambos lados del operador.

espero my $post = 'informative' || 'interesting';