错误处理 #

my $file = "nonexistent.txt";
open my $fh, "<", $file or die "Cannot open $file: $!";

my $file = "nonexistent.txt";
open my $fh, "<", $file or warn "Cannot open $file: $!";

open my $fh, "<", "nonexistent.txt"
    or die "Error: $!";

use Carp qw(croak confess cluck);

sub process {
    my $file = shift;
    open my $fh, "<", $file or croak "Cannot open $file: $!";
}

sub debug_process {
    my $file = shift;
    open my $fh, "<", $file or confess "Cannot open $file: $!";
}

my $result = eval {
    my $a = 10;
    my $b = 0;
    $a / $b;
};

if ($@) {
    print "Error: $@\n";
} else {
    print "Result: $result\n";
}

my $code = 'print "Hello\n"';
eval $code;

if ($@) {
    print "Error: $@\n";
}

sub safe_divide {
    my ($a, $b) = @_;
    
    my $result = eval { $a / $b };
    
    if ($@) {
        warn "Division error: $@";
        return undef;
    }
    
    return $result;
}

my $result;

eval {
    $result = some_operation();
    1;
} or do {
    my $error = $@;
    handle_error($error);
};

use Try::Tiny;

try {
    my $result = 10 / 0;
} catch {
    warn "Error: $_";
} finally {
    print "Cleanup\n";
};

use Try::Tiny;

my $result = try {
    return some_operation();
} catch {
    warn "Error: $_";
    return undef;
};

use Try::Tiny;

sub process_file {
    my $file = shift;
    
    my $content = try {
        open my $fh, "<", $file or die "Cannot open: $!";
        local $/;
        my $data = <$fh>;
        close $fh;
        return $data;
    } catch {
        warn "Failed to read $file: $_";
        return undef;
    };
    
    return $content;
}

sub withdraw {
    my ($balance, $amount) = @_;
    
    if ($amount > $balance) {
        die "Insufficient funds: balance=$balance, requested=$amount";
    }
    
    return $balance - $amount;
}

eval {
    withdraw(100, 150);
};
if ($@) {
    print "Transaction failed: $@\n";
}

package MyException;
use overload '""' => \&stringify;

sub new {
    my ($class, %args) = @_;
    return bless \%args, $class;
}

sub message { shift->{message} }
sub code    { shift->{code} }

sub stringify {
    my $self = shift;
    return "Error [$self->{code}]: $self->{message}";
}

1;

use Try::Tiny;

try {
    die MyException->new(
        message => "Something went wrong",
        code    => 500,
    );
} catch {
    if (ref $_ eq 'MyException') {
        print "Custom error: $_\n";
    } else {
        print "Unknown error: $_\n";
    }
};

sub divide {
    my ($a, $b) = @_;
    
    return (undef, "Division by zero") if $b == 0;
    return ($a / $b, undef);
}

my ($result, $error) = divide(10, 0);
if ($error) {
    print "Error: $error\n";
} else {
    print "Result: $result\n";
}

sub read_config {
    my $file = shift;
    
    open my $fh, "<", $file or return;
    local $/;
    my $content = <$fh>;
    close $fh;
    
    return $content;
}

my $config = read_config("config.txt");
unless (defined $config) {
    die "Failed to read config";
}

sub process {
    my (%args) = @_;
    
    my $on_success = $args{on_success} // sub {};
    my $on_error   = $args{on_error}   // sub { die @_ };
    
    my $result = eval { do_something() };
    
    if ($@) {
        $on_error->($@);
    } else {
        $on_success->($result);
    }
}

process(
    on_success => sub { print "Success: $_[0]\n" },
    on_error   => sub { warn "Error: $_[0]" },
);

sub log_error {
    my $msg = shift;
    my $timestamp = localtime();
    print STDERR "[$timestamp] ERROR: $msg\n";
}

sub log_info {
    my $msg = shift;
    my $timestamp = localtime();
    print STDERR "[$timestamp] INFO: $msg\n";
}

eval {
    log_info("Starting operation");
    some_operation();
    log_info("Operation completed");
};
if ($@) {
    log_error($@);
}

use Log::Log4perl;

Log::Log4perl->init(\<<'END');
log4perl.rootLogger=DEBUG, Screen

log4perl.appender.Screen=Log::Log4perl::Appender::Screen
log4perl.appender.Screen.layout=PatternLayout
log4perl.appender.Screen.layout.ConversionPattern=%d %p %m %n
END

my $logger = Log::Log4perl->get_logger();

$logger->debug("Debug message");
$logger->info("Info message");
$logger->warn("Warning message");
$logger->error("Error message");
$logger->fatal("Fatal message");

#!/usr/bin/perl
use strict;
use warnings;
use Try::Tiny;
use v5.10;

sub safe_read_file {
    my $file = shift;
    
    my $content = try {
        open my $fh, "<", $file or die "Cannot open: $!";
        local $/;
        my $data = <$fh>;
        close $fh;
        return $data;
    } catch {
        warn "Error reading $file: $_";
        return undef;
    };
    
    return $content;
}

my $content = safe_read_file("test.txt");
if (defined $content) {
    say "Read " . length($content) . " bytes";
}

#!/usr/bin/perl
use strict;
use warnings;
use Try::Tiny;
use v5.10;

sub db_query {
    my ($sql, @params) = @_;
    
    my $result = try {
        die "Connection failed" unless connect_db();
        my $sth = prepare($sql);
        $sth->execute(@params);
        return $sth->fetchall_arrayref();
    } catch {
        log_error($_);
        return undef;
    };
    
    return $result;
}

sub log_error {
    my $msg = shift;
    my $time = localtime();
    print STDERR "[$time] ERROR: $msg\n";
}

sub connect_db { return 1; }
sub prepare { return bless {}, 'STH'; }

package STH;
sub execute {}
sub fetchall_arrayref { return []; }

#!/usr/bin/perl
use strict;
use warnings;
use Try::Tiny;
use v5.10;

sub validate_config {
    my $config = shift;
    my @errors;
    
    try {
        die "Missing 'host'" unless $config->{host};
        die "Invalid 'port'" unless $config->{port} && $config->{port} > 0;
        die "Missing 'database'" unless $config->{database};
    } catch {
        push @errors, $_;
    };
    
    return @errors ? \@errors : undef;
}

my $config = {
    host => "localhost",
    port => 3306,
    database => "mydb",
};

my $errors = validate_config($config);
if ($errors) {
    say "Validation errors:";
    say "  $_" foreach @$errors;
} else {
    say "Config is valid";
}