Movatterモバイル変換


[0]ホーム

URL:


functions /die
(source,CPAN)
You are viewing the version of this documentation from Perl 5.34.3.View the latest version
#die LIST

die raises an exception. Inside aneval the exception is stuffed into$@ and theeval is terminated with the undefined value. If the exception is outside of all enclosingevals, then the uncaught exception is printed toSTDERR and perl exits with an exit code indicating failure. If you need to exit the process with a specific exit code, seeexit.

Equivalent examples:

die "Can't cd to spool: $!\n" unless chdir '/usr/spool/news';chdir '/usr/spool/news' or die "Can't cd to spool: $!\n"

Most of the time,die is called with a string to use as the exception. You may either give a single non-reference operand to serve as the exception, or a list of two or more items, which will be stringified and concatenated to make the exception.

If the string exception does not end in a newline, the current script line number and input line number (if any) and a newline are appended to it. Note that the "input line number" (also known as "chunk") is subject to whatever notion of "line" happens to be currently in effect, and is also available as the special variable$.. See"$/" in perlvar and"$." in perlvar.

Hint: sometimes appending", stopped" to your message will cause it to make better sense when the string"at foo line 123" is appended. Suppose you are running script "canasta".

die "/etc/games is no good";die "/etc/games is no good, stopped";

produce, respectively

/etc/games is no good at canasta line 123./etc/games is no good, stopped at canasta line 123.

If LIST was empty or made an empty string, and$@ already contains an exception value (typically from a previouseval), then that value is reused after appending"\t...propagated". This is useful for propagating exceptions:

eval { ... };die unless $@ =~ /Expected exception/;

If LIST was empty or made an empty string, and$@ contains an object reference that has aPROPAGATE method, that method will be called with additional file and line number parameters. The return value replaces the value in$@; i.e., as if$@ = eval { $@->PROPAGATE(__FILE__, __LINE__) }; were called.

If LIST was empty or made an empty string, and$@ is also empty, then the string"Died" is used.

You can also calldie with a reference argument, and if this is trapped within aneval,$@ contains that reference. This permits more elaborate exception handling using objects that maintain arbitrary state about the exception. Such a scheme is sometimes preferable to matching particular string values of$@ with regular expressions.

Because Perl stringifies uncaught exception messages before display, you'll probably want to overload stringification operations on exception objects. Seeoverload for details about that. The stringified message should be non-empty, and should end in a newline, in order to fit in with the treatment of string exceptions. Also, because an exception object reference cannot be stringified without destroying it, Perl doesn't attempt to append location or other information to a reference exception. If you want location information with a complex exception object, you'll have to arrange to put the location information into the object yourself.

Because$@ is a global variable, be careful that analyzing an exception caught byeval doesn't replace the reference in the global variable. It's easiest to make a local copy of the reference before any manipulations. Here's an example:

use Scalar::Util "blessed";eval { ... ; die Some::Module::Exception->new( FOO => "bar" ) };if (my $ev_err = $@) {    if (blessed($ev_err)        && $ev_err->isa("Some::Module::Exception")) {        # handle Some::Module::Exception    }    else {        # handle all other possible exceptions    }}

If an uncaught exception results in interpreter exit, the exit code is determined from the values of$! and$? with this pseudocode:

exit $! if $!;              # errnoexit $? >> 8 if $? >> 8;    # child exit statusexit 255;                   # last resort

As withexit,$? is set prior to unwinding the call stack; anyDESTROY orEND handlers can then alter this value, and thus Perl's exit code.

The intent is to squeeze as much possible information about the likely cause into the limited space of the system exit code. However, as$! is the value of C'serrno, which can be set by any system call, this means that the value of the exit code used bydie can be non-predictable, so should not be relied upon, other than to be non-zero.

You can arrange for a callback to be run just before thedie does its deed, by setting the$SIG{__DIE__} hook. The associated handler is called with the exception as an argument, and can change the exception, if it sees fit, by callingdie again. See"%SIG" in perlvar for details on setting%SIG entries, andeval for some examples. Although this feature was to be run only right before your program was to exit, this is not currently so: the$SIG{__DIE__} hook is currently called even insideevaled blocks/strings! If one wants the hook to do nothing in such situations, put

die @_ if $^S;

as the first line of the handler (see"$^S" in perlvar). Because this promotes strange action at a distance, this counterintuitive behavior may be fixed in a future release.

See alsoexit,warn, and theCarp module.

Perldoc Browser is maintained by Dan Book (DBOOK). Please contact him via theGitHub issue tracker oremail regarding any issues with the site itself, search, or rendering of documentation.

The Perl documentation is maintained by the Perl 5 Porters in the development of Perl. Please contact them via thePerl issue tracker, themailing list, orIRC to report any issues with the contents or format of the documentation.


[8]ページ先頭

©2009-2025 Movatter.jp