Respuesta.

Historia de la cuestión:

En Perl, los subprogramas han sido implementados de manera bastante flexible desde el principio: cualquier llamada a un subprograma puede aceptar un número ilimitado de parámetros, que se colocan en el arreglo @_. Este enfoque es adecuado para tareas de diferentes niveles de complejidad y apoya la dinámica de Perl.

Problema:

Muchos desarrolladores, especialmente los principiantes, se enfrentan a la confusión al trabajar con @_ — desestructuración incorrecta de parámetros, modificación accidental de datos de entrada (dado que las variables se pasan por valor, mientras que las estructuras complejas se pasan por referencia), inconsistencias en la cantidad y tipos de argumentos. Surgen problemas al devolver diferentes tipos de datos y al intentar implementar prototipos de funciones.

Solución:

Para obtener argumentos, el subprograma debe desestructurarlos explícitamente del arreglo @_. La devolución de valores se realiza con el operador return, y el comportamiento depende del contexto (escalar o listado). Para evitar efectos secundarios, los parámetros a menudo se reciben como copias o por referencia, si se requiere su modificación dentro del subprograma. Para estructuras complejas se utiliza la transmisión por referencia.

Ejemplo de código:

sub add {
    my ($a, $b) = @_;
    return $a + $b;
}

sub change_array {
    my ($arr_ref) = @_;
    push @$arr_ref, 100;
}

my @nums = (1, 2, 3);
my $sum = add(5, 10);
change_array(\@nums);
print join(", ", @nums); # 1, 2, 3, 100

Características clave:

Transmisión de argumentos sin tipificación, a través del arreglo @_
Devolución de diferentes tipos según el contexto de llamada
Transmisión por referencia para modificar los datos originales

Preguntas capciosas.

¿La función modifica los parámetros que se le pasan si se trabaja con escalar simple?

No, los escalares se copian al pasarse, sus modificaciones no afectan al original. Sin embargo, si el argumento es una referencia, los datos originales pueden cambiar.

¿Pueden asignarse valores predeterminados a los parámetros de los subprogramas como en otros lenguajes?

Directamente no. En Perl es necesario implementar la gestión de valores por defecto dentro del cuerpo de la función, utilizando la comprobación defined o la cantidad de argumentos.

Ejemplo de código:

sub foo {
    my ($arg1, $arg2) = @_;
    $arg2 //= 10;
    print "$arg1 $arg2
";
}
foo(5);    # 5 10

¿Qué ocurre con el acceso directo a @_ sin copiar — por ejemplo, $a = $_[0]?

Tal asignación crea un alias: cambiar $a afectará a $[0] y viceversa. Se recomienda crear copias usando my ($a) = @; para evitar cambios inesperados.

Errores comunes y anti-patrones

Manipulación directa de @_ dentro de la función
Descuido del contexto escalar o listado al devolver
Mutación de datos de entrada sin pasarlos por referencia

Ejemplo de la vida real

** Caso negativo

En una función para procesar un arreglo se olvidó copiar los parámetros de @_ en variables locales. Como resultado, el cambio de una variable local modificó el arreglo original, causando errores en otras partes del programa.

Pros:

Código compacto

Contras:

Difícil de rastrear los efectos secundarios
La lectura del código se vuelve más complicada

** Caso positivo

En el equipo se implementó la práctica de desestructurar obligatoriamente @_ al inicio de cada subprograma, y solo se pasan objetos grandes por referencia.