Perl Cd Bookshelf [Electronic resources] نسخه متنی

1.2. Establishing a Default Value

1.2.1. Problem

You would like to supply a default
value to a scalar variable, but only if it doesn't already have one.
It often happens that you want a hardcoded default value for a
variable that can be overridden from the command line or through an
environment variable.

1.2.2. Solution

Use the || or
||= operator, which work on both strings and
numbers:

# use $b if $b is true, else $c
$a = $b || $c;
# set $x to $y unless $x is already true
$x ||= $y;

If 0, "0", and
" are valid values for your variables, use
defined instead:

# use $b if $b is defined, else $c
$a = defined($b) ? $b : $c;
# the "new" defined-or operator from future perl
use v5.9;
$a = $b // $c;

1.2.3. Discussion

The
big difference between the two techniques (defined
and ||) is what they test: definedness versus
truth. Three defined values are still false in the world of Perl:
0, "0", and
". If your variable already held one of those,
and you wanted to keep that value, a || wouldn't
work. You'd have to use the more elaborate three-way test with
defined instead. It's often convenient to arrange
for your program to care about only true or false values, not defined
or undefined ones.

Rather than being restricted in its return values to a mere 1 or 0 as
in most other languages, Perl's || operator has a
much more interesting property: it returns its first operand (the
lefthand side) if that operand is true; otherwise it returns its
second operand. The && operator also
returns the last evaluated expression, but is less often used for
this property. These operators don't care whether their operands are
strings, numbers, or references—any scalar will do. They just
return the first one that makes the whole expression true or false.
This doesn't affect the Boolean sense of the return value, but it
does make the operators' return values more
useful.

This property lets you provide a default value to a variable,
function, or longer expression in case the first part doesn't pan
out. Here's an example of ||, which would set
$foo to be the contents of either
$bar or, if $bar were false,
"DEFAULT VALUE":

$foo = $bar || "DEFAULT VALUE";

Here's another example, which sets $dir to be
either the first argument to the program or "/tmp"
if no argument were given.

$dir = shift(@ARGV) || "/tmp";

We can do this without altering @ARGV:

$dir = $ARGV[0] || "/tmp";

If 0 is a valid value for
$ARGV[0], we can't use ||,
because it evaluates as false even though it's a value we want to
accept. We must resort to Perl's only ternary operator, the
?: ("hook colon," or just "hook"):

$dir = defined($ARGV[0]) ? shift(@ARGV) : "/tmp";

We can also write this as follows, although with slightly different
semantics:

$dir = @ARGV ? $ARGV[0] : "/tmp";

This checks the number of elements in @ARGV,
because the first operand (here, @ARGV) is
evaluated in scalar context. It's only false when there are 0
elements, in which case we use "/tmp". In all
other cases (when the user gives an argument), we use the first
argument.

The following line increments a value in %count,
using as the key either $shell or, if
$shell is false, "/bin/sh".

$count{ $shell || "/bin/sh" }++;

You may chain several alternatives together as we have in the
following example. The first expression that returns a true value
will be used.

# find the user name on Unix systems
$user = $ENV{USER}
|| $ENV{LOGNAME}
|| getlogin( )
|| (getpwuid($<))[0]
|| "Unknown uid number $<";

The && operator works analogously: it
returns its first operand if that operand is false; otherwise, it
returns the second one. Because there aren't as many interesting
false values as there are true ones, this property isn't used much.
One use is demonstrated in Recipe 13.12 and
Recipe 14.19.

The ||= assignment operator looks odd, but it
works exactly like the other binary assignment operators. For nearly
all of Perl's binary operators, $VAR
OP= VALUE means
$VAR = $VAR
OP VALUE; for example,
$a += $b is
the same as $a =
$a + $b. So
||= is used to set a variable when that variable
is itself still false. Since the || check is a
simple Boolean one—testing for truth—it doesn't care
about undefined values, even when warnings are enabled.

Here's an example of ||= that sets
$starting_point to "Greenwich"
unless it is already set. Again, we assume
$starting_point won't have the value
0 or "0", or that if it does,
it's okay to change it.

$starting_point ||= "Greenwich";

You can't use or in
place of || in assignments, because
or's precedence is too low. $a
= $b or
$c is equivalent to ($a
= $b) or
$c. This will always assign $b
to $a, which is not the behavior you want.

Don't extend this curious use of || and
||= from scalars to arrays and hashes. It doesn't
work, because the operators put their left operand into scalar
context. Instead, you must do something like this:

@a = @b unless @a;          # copy only if empty
@a = @b ? @b : @c;          # assign @b if nonempty, else @c

Perl is someday expected to support new operators:
//, //=, and
err. It may already do so by the time you read
this text. These defined-or operators will work just like the
logical-or operators, ||, except that they will
test definedness, not mere truth. That will make the following pairs
equivalent:

$a = defined($b) ? $b : $c;
$a = $b // $c;
$x = defined($x) ? $x : $y;
$x //= $y;
defined(read(FH, $buf, $count)  or  die "read failed: $!";
read(FH, $buf, $count)          err die "read failed: $!";

These three operators are already present in Perl release v5.9, which
being an odd-numbered release, is an experimental version and not
what you want in a production environment. It is expected to be in
v5.10, which will be a stable release, and will most certainly be in
Perl v6, whose release date has not yet been determined.

1.2.4. See Also

The || operator in perlop(1)
and Chapter 3 of Programming Perl; the
defined and exists functions in
perlfunc(1) and Chapter 29 of
Programming Perl