What methods of passing arguments to subroutines in Perl exist and how to organize passing by reference? What are the nuances of working with @_ and when is passing by reference necessary?

Answer

In Perl, all function arguments are passed through the @_ array. When calling a subroutine, all passed parameters end up inside this array, and initially, it is a list, not a copy, meaning that if you modify $_[0], you modify the original.

Passing by value:

sub foo {
    my ($arg1, $arg2) = @_;
    $arg1 = 10;   # Only the local variable changes
}

Passing by reference:

sub bar {
    my ($array_ref) = @_;
    push @$array_ref, 42;
}
my @data = (1,2,3);
bar(\@data);
# @data is now (1,2,3,42)

Nuances:

• If you want to modify the original array or hash — pass a reference.
• Regular variables ($foo, $bar) inside @_ are aliases of the original arguments, but when unpacking via my ($a, $b) = @_, copies are created.
• For arrays and hashes, when passed normally, their contents are flattened into a list, and you lose boundaries: you need to pass a reference or use the specifics of shifts.

Trick Question

If you pass an array to a Perl function like this: myfunc(@arr), and inside the function refer to $_[0], what will be there?

Correct answer: There will be the first element value of the array, not a reference to the entire array! To pass an array as a whole object, use a reference: myfunc(\@arr).

Example:

sub print_first {
    print $_[0], "
";
}
my @a = qw/foo bar baz/;
print_first(@a); # Will print 'foo', not a reference to the array
print_first(\@a); # Will print ARRAY(0x...) — a reference to the entire array

---

History

In one project, to modify a global hash, the function was called like this: update_hash(%global). Inside, $_[0] was modified. As a result, only the local slice of the argument array was changed, while the global hash remained unmodified. The correct solution was to pass a reference: update_hash(\%global).

History

When writing an API framework, multiple named arguments were passed to functions using a hash. Sometimes an array was passed to the function (but not a reference!), and the arguments "mixed", leading to confusion: myfunc(@arr, %opts). It turned out that some hash keys were replaced by the values of the array, and it was not easy to detect the error.

History

When implementing recursive tree traversal, there was a need to modify internal elements. Arrays were passed "as is" to the function, not by reference. They created copies, and changes did not affect the external context. The problem was resolved by switching to reference-style passing.