delete $ref->[$x][$y][$index];
delete @{$ref->[$x][$y]}[$index1, $index2, @moreindices];
+The C<delete local EXPR> construct can also be used to localize the deletion
+of array/hash elements to the current block.
+See L<perlsub/"Localized deletion of elements of composite types">.
+
=item die LIST
X<die> X<throw> X<exception> X<raise> X<$@> X<abort>
See also exit(), warn(), and the Carp module.
-If LIST is empty and C<$@> already contains a value (typically from a
+If the output is empty and C<$@> already contains a value (typically from a
previous eval) that value is reused after appending C<"\t...propagated">.
This is useful for propagating exceptions:
eval { ... };
die unless $@ =~ /Expected exception/;
-If LIST is empty and C<$@> contains an object reference that has a
+If the output is empty and C<$@> contains an object reference that has a
C<PROPAGATE> method, that method will be called with additional file
and line number parameters. The return value replaces the value in
C<$@>. i.e. as if C<< $@ = eval { $@->PROPAGATE(__FILE__, __LINE__) }; >>
alive (even if only as a zombie) and hasn't changed its UID. See
L<perlport> for notes on the portability of this construct.
-Unlike in the shell, if SIGNAL is negative, it kills
-process groups instead of processes. (On System V, a negative I<PROCESS>
-number will also kill process groups, but that's not portable.) That
-means you usually want to use positive not negative signals. You may also
-use a signal name in quotes.
+Unlike in the shell, if SIGNAL is negative, it kills process groups instead
+of processes. That means you usually want to use positive not negative signals.
+You may also use a signal name in quotes.
+
+The behavior of kill when a I<PROCESS> number is zero or negative depends on
+the operating system. For example, on POSIX-conforming systems, zero will
+signal the current process group and -1 will signal all processes.
See L<perlipc/"Signals"> for more details.
be placed in parentheses. See L<perlsub/"Temporary Values via local()">
for details, including issues with tied arrays and hashes.
+The C<delete local EXPR> construct can also be used to localize the deletion
+of array/hash elements to the current block.
+See L<perlsub/"Localized deletion of elements of composite types">.
+
=item localtime EXPR
X<localtime> X<ctime>
The same template may generally also be used in unpack().
-=item package NAMESPACE
-X<package> X<module> X<namespace>
+=item package NAMESPACE VERSION
+X<package> X<module> X<namespace> X<version>
-=item package
+=item package NAMESPACE
Declares the compilation unit as being in the given namespace. The scope
of the package declaration is from the declaration itself through the end
C<$::sail> is equivalent to C<$main::sail> (as well as to C<$main'sail>,
still seen in older code).
+If VERSION is provided, C<package> also sets the C<$VERSION> variable in the
+given namespace. VERSION must be be a numeric literal or v-string; it is
+parsed exactly the same way as a VERSION argument to C<use MODULE VERSION>.
+C<$VERSION> should only be set once per package.
+
See L<perlmod/"Packages"> for more information about packages, modules,
and classes. See L<perlsub> for other scoping issues.
@dots = grep { /^\./ && -f "$some_dir/$_" } readdir($dh);
closedir $dh;
+As of Perl 5.11.2 you can use a bare C<readdir> in a C<while> loop,
+which will set C<$_> on every iteration.
+
+ opendir(my $dh, $some_dir) || die;
+ while(readdir $dh) {
+ print "$some_dir/$_\n";
+ }
+ closedir $dh;
+
=item readline EXPR
=item readline
Reads from the filehandle whose typeglob is contained in EXPR (or from
*ARGV if EXPR is not provided). In scalar context, each call reads and
returns the next line, until end-of-file is reached, whereupon the
-subsequent call returns undef. In list context, reads until end-of-file
+subsequent call returns C<undef>. In list context, reads until end-of-file
is reached and returns a list of lines. Note that the notion of "line"
used here is however you may have defined it with C<$/> or
C<$INPUT_RECORD_SEPARATOR>). See L<perlvar/"$/">.
-When C<$/> is set to C<undef>, when readline() is in scalar
+When C<$/> is set to C<undef>, when C<readline> is in scalar
context (i.e. file slurp mode), and when an empty file is read, it
returns C<''> the first time, followed by C<undef> subsequently.
$line = <STDIN>;
$line = readline(*STDIN); # same thing
-If readline encounters an operating system error, C<$!> will be set with the
-corresponding error message. It can be helpful to check C<$!> when you are
-reading from filehandles you don't trust, such as a tty or a socket. The
-following example uses the operator form of C<readline>, and takes the necessary
-steps to ensure that C<readline> was successful.
+If C<readline> encounters an operating system error, C<$!> will be set
+with the corresponding error message. It can be helpful to check
+C<$!> when you are reading from filehandles you don't trust, such as a
+tty or a socket. The following example uses the operator form of
+C<readline> and dies if the result is not defined.
- for (;;) {
- undef $!;
- unless (defined( $line = <> )) {
- last if eof;
- die $! if $!;
+ while ( ! eof($fh) ) {
+ defined( $_ = <$fh> ) or die "readline failed: $!";
+ ...
+ }
+
+Note that you have can't handle C<readline> errors that way with the
+C<ARGV> filehandle. In that case, you have to open each element of
+C<@ARGV> yourself since C<eof> handles C<ARGV> differently.
+
+ foreach my $arg (@ARGV) {
+ open(my $fh, $arg) or warn "Can't open $arg: $!";
+
+ while ( ! eof($fh) ) {
+ defined( $_ = <$fh> )
+ or die "readline failed for $arg: $!";
+ ...
}
- # ...
}
=item readlink EXPR
use sort '_mergesort'; # note discouraging _
@new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
+Warning: syntactical care is required when sorting the list returned from
+a function. If you want to sort the list returned by the function call
+C<find_records(@key)>, you can use:
-Warning: Care is required when sorting the list returned from a function.
-
-If you want to sort returned by the function call: find_records(@key) then
-you can use:
@contact = sort { $a cmp $b } find_records @key;
@contact = sort +find_records(@key);
@contact = sort &find_records(@key);
@contact = sort(find_records(@key));
If instead you want to sort the array @key with the comparison routine
-find_records then you can use:
+C<find_records()> then you can use:
+
@contact = sort { find_records() } @key;
@contact = sort find_records(@key);
@contact = sort(find_records @key);
@contact = sort(find_records (@key));
-
If you're using strict, you I<must not> declare $a
and $b as lexicals. They are package globals. That means
-if you're in the C<main> package and type
+that if you're in the C<main> package and type
@articles = sort {$b <=> $a} @files;
default, empty leading fields are preserved, and empty trailing ones are
deleted. (If all fields are empty, they are considered to be trailing.)
-In scalar context, returns the number of fields found and splits into
-the C<@_> array. Use of split in scalar context is deprecated, however,
-because it clobbers your subroutine arguments.
+In scalar context, returns the number of fields found.
If EXPR is omitted, splits the C<$_> string. If PATTERN is also omitted,
splits on whitespace (after skipping any leading whitespace). Anything
indicates a failure to start the program or an error of the wait(2) system
call (inspect $! for the reason).
+If you'd like to make C<system> (and many other bits of Perl) die on error,
+have a look at the L<autodie> pragma.
+
Like C<exec>, C<system> allows you to lie to a program about its name if
you use the C<system PROGRAM LIST> syntax. Again, see L</exec>.
system(@args) == 0
or die "system @args failed: $?"
-You can check all the failure possibilities by inspecting
-C<$?> like this:
+If you'd like to manually inspect C<system>'s failure, you can check all
+possible failure modes by inspecting C<$?> like this:
if ($? == -1) {
print "failed to execute: $!\n";
Also, if the specified perl version is greater than or equal to 5.9.5,
C<use VERSION> will also load the C<feature> pragma and enable all
features available in the requested version. See L<feature>.
+Similarly, if the specified perl version is greater than or equal to
+5.11.0, strictures are enabled lexically as with C<use strict> (except
+that the F<strict.pm> file is not actually loaded).
The C<BEGIN> forces the C<require> and C<import> to happen at compile time. The
C<require> makes sure the module is loaded into memory if it hasn't been
not end in a newline, it appends the same file/line number text as C<die>
does.
-If LIST is empty and C<$@> already contains a value (typically from a
+If the output is empty and C<$@> already contains a value (typically from a
previous eval) that value is used after appending C<"\t...caught">
to C<$@>. This is useful for staying almost, but not entirely similar to
C<die>.