How to use eval for exception handling in Perl?

In Perl, eval is a built-in function commonly used for exception handling. It allows you to catch runtime errors and continue program execution gracefully instead of crashing your script.

There are two forms of eval in Perl: eval BLOCK and eval STRING. For exception handling, the block form (eval { ... }) is preferred because it is safer and more efficient.

How eval works for exception handling

• The code inside an eval block is executed in a protected environment.
• If a runtime error (such as die) occurs within the block, eval traps it and puts the error message into the special variable $@.
• Your script can then test $@ to determine if an error occurred and respond accordingly.
• If no errors occur, $@ is cleared (set to the empty string).

Basic example of eval for exception handling

#!/usr/bin/perl
use strict;
use warnings;

# This subroutine will throw an exception (die) if input is negative
sub check_positive {
    my ($num) = @_;
    die "Negative number: $num\n" if $num < 0;
    return "Number $num is positive";
}

my @nums = (10, 5, -1, 7);

foreach my $n (@nums) {
    my $result = eval {
        # Protected code block
        check_positive($n);
    };

    if ($@) {
        # $@ contains the error from die
        print "Caught error for input $n: $@";
    } else {
        print "Success: $result\n";
    }
}

When you run this code, it will output:

Success: Number 10 is positive
Success: Number 5 is positive
Caught error for input -1: Negative number: -1
Success: Number 7 is positive

Important Perl-specific details

• Sigils: $@ is a scalar variable that holds the error message string from the last eval.
• Context: The eval block returns the last evaluated expression in scalar or list context. You can capture that return value to handle success cases.
• TMTOWTDI: Perl allows various ways to handle exceptions, including using eval, modules like Try::Tiny, or object-oriented exception handling. But eval remains the classic and core way to catch errors.

Common pitfalls and gotchas

• $@ is global and can be overwritten. Always check it immediately after eval before running other code.
• A common mistake is forgetting to localize $@ if your code might be running inside other eval blocks. Use local $@ to avoid clobbering errors.
• eval STRING evaluates a string as code at runtime. This is slower, potentially unsafe, and not recommended for exception handling.
• While eval catches die exceptions and runtime errors, it does not catch syntax errors occurring before runtime.

Summary

Using eval { ... } is the canonical way to add exception handling in Perl. Wrap potentially error-throwing code inside eval, then check $@ for errors. This approach enables safe, controlled error handling without stopping your entire program abruptly.