Establishing a Default Value (Perl Cookbook, 2nd Edition)

## 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

Copyright © 2003 O'Reilly & Associates. All rights reserved.