Subroutines

Introduction

As programs grow, repeating the same logic in multiple places becomes error-prone and hard to maintain. Subroutines let you package a block of code under a name, run it whenever you need it, and pass in different data each time. Perl's subroutines are flexible and dynamically typed, with a couple of quirks that are worth understanding early.

Defining a Subroutine

A subroutine is defined with the sub keyword, a name, and a block of code. You call it later simply by writing its name, optionally followed by parentheses containing arguments.

use strict;
use warnings;

sub greet {
    print "Hello from a subroutine!\n";
}

greet();

Arguments via @_

Unlike many languages, Perl subroutines do not declare named parameters in their definition. Instead, every argument passed to a subroutine call lands in the special array @_. It is standard practice to immediately copy the values you need out of @_ into clearly named my variables.

use strict;
use warnings;

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

my $sum = add(4, 7);
print "4 + 7 = $sum\n";

my ($a, $b) = @_; unpacks the first two elements of @_ into $a and $b in one line — this is the idiomatic way nearly every Perl subroutine starts.

Return Values

The return keyword exits a subroutine immediately and hands back a value to the caller. You can return early from inside a conditional, which is a common pattern for guard clauses.

use strict;
use warnings;

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

    if ($n < 0) {
        return "negative";
    }
    if ($n == 0) {
        return "zero";
    }
    return "positive";
}

print classify_number(-5), "\n";
print classify_number(0), "\n";
print classify_number(42), "\n";

Default Return Value

If a subroutine does not explicitly call return, Perl returns the value of the last expression it evaluated. This is convenient for short subroutines, but relying on it in longer ones can hurt readability, so many style guides recommend using return explicitly everywhere.

use strict;
use warnings;

sub square {
    my ($n) = @_;
    $n * $n;   # no explicit return -- this becomes the return value
}

my $result = square(6);
print "6 squared is $result\n";

Named Arguments With a Hash

Positional arguments (like add($a, $b)) get confusing once a subroutine takes more than two or three parameters, especially if several are optional. A common Perl idiom is to accept a hash of named arguments instead, which makes call sites self-documenting.

use strict;
use warnings;

sub create_user {
    my %args = @_;
    my $name = $args{name} // 'Unknown';
    my $age  = $args{age}  // 0;

    return "$name ($age years old)";
}

print create_user(name => 'Alice', age => 30), "\n";
print create_user(name => 'Bob'), "\n";

The // operator above is the defined-or operator: it uses the right-hand value only if the left-hand one is undef, which is perfect for supplying defaults for missing named arguments.

Scope Inside Subroutines

Variables declared with my inside a subroutine are local to that subroutine call and disappear once it returns. Each call gets its own fresh set of my variables, which is essential for subroutines to be safely reusable, including when they call themselves recursively.

use strict;
use warnings;

sub factorial {
    my ($n) = @_;
    return 1 if $n <= 1;
    return $n * factorial($n - 1);
}

print "5! = ", factorial(5), "\n";

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Subroutines let you organize and reuse logic cleanly. To build genuinely complex programs, though, you will also need references — Perl's mechanism for pointing at data instead of copying it, which unlocks nested data structures. That is exactly where you are headed next.