Like C, Perl provides the &&
(logical AND) and ||
(logical OR) operators. They
evaluate from left to right (with &&
having
slightly higher precedence than ||
) testing the
truth of the statement. These operators are known as short-circuit
operators because they determine the truth of the statement by
evaluating the fewest number of operands possible. For example, if the
left operand of an &&
operator is false,
the right operand is never evaluated because the result of the
operator is false regardless of the value of the right operand.
Such short circuits not only save time, but are frequently used to control the flow of evaluation. For example, an oft-appearing idiom in Perl programs is:
open(FILE, "somefile") || die "Can't open somefile: $! ";
In this case, Perl first evaluates the open
function. If the value is true (because somefile
was successfully opened), the execution of the die
function is unnecessary, and so is skipped. You can read this
literally as "Open some file or die!"
The &&
and ||
operators differ from C's in that, rather than returning 0 or 1, they
return the last value evaluated. In the case of ||
,
this has the delightful result that you can select the first of a
series of scalar values that happens to be true. Thus, a reasonably
portable way to find out the user's home directory might be:
$home = $ENV{HOME} || $ENV{LOGDIR} || (getpwuid($<))[7] || die "You're homeless! ";
On the other hand, since the left argument is always evaluated
in scalar context, you can't use ||
for selecting
between two aggregates for assignment:
@a = @b || @c; # This doesn't do the right thing @a = scalar(@b) || @c; # because it really means this. @a = @b ? @b : @c; # This works fine, though.
Perl also provides lower precedence and
and
or
operators that some people find more readable
and don't force you to use parentheses on list operators. They also
short-circuit. See Table
1.1 for a complete list.