 |  |
| |
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.
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;
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.
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
|  | |
| 1.1. Accessing Substrings |  | 1.3. Exchanging Values Without Using Temporary Variables |
Copyright © 2003 O'Reilly & Associates. All rights reserved.