Answer.

Background:

In Perl, subroutines have been implemented quite flexibly from the very beginning: any subroutine call can accept an unlimited number of parameters, which are placed in the array @_. This approach is suitable for tasks of various complexities and supports the dynamism of Perl.

Problem:

Many developers, especially beginners, encounter confusion when working with @_ — incorrect destructuring of parameters, accidental alteration of input data (since simple variables are passed by value, while complex structures are passed by reference), mismatches in the number and types of arguments. Issues arise when returning different data types and when trying to implement function prototypes.

Solution:

To obtain arguments, the subroutine must explicitly destructure them from the array @_. Return values are produced using the return operator, with behavior dependent on context (scalar or list). To avoid side effects, parameters are often accepted by copy or by reference if modification within the subroutine is required. For complex structures, pass by reference is used.

Example code:

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

Key features:

Passing arguments without typing, through the array @_
Returning different types depending on the call context
Passing by reference for modifying original data

Tricky questions.

Does a function change the parameters passed to it when working with simple scalars?

No, scalars are copied when passed, their changes do not affect the original. However, if the argument is a reference, then the original data may change.

Can default values for arguments be set in subroutines, like in other languages?

Not directly. In Perl, it is necessary to implement default value handling within the function body, using a defined check or the number of arguments.

Example code:

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

What happens when directly accessing @_ without copying — for example, $a = $_[0]?

Such an assignment creates an alias: changing $a will change $[0], and vice versa. It is recommended to create copies using my ($a) = @ to avoid unexpected changes.

Common mistakes and anti-patterns

Direct manipulation of @_ within the function
Neglecting scalar or list context during return
Mutating input data without passing it by reference

Real-life example

** Negative case

In a function for processing an array, the parameters were forgotten to be copied from @_ to local variables. As a result, changing the local variable led to alterations of the original array, causing bugs in other parts of the program.

Pros:

Compact code

Cons:

Difficult to track side effects
Code reading becomes harder

** Positive case

The team implemented a practice of mandatory destructuring of @_ at the beginning of each subroutine, and large objects are passed only by reference.