Hi Athanasius,

I'm curious, what in your view is the advantage of using Logical Defined-Or over simple Logical Or in the OP's situation?

$ perl -Mstrict -Mwarnings -E'
my $foo;
say (defined $foo ? "1: defined" : "1: not defined");
my $bar = $foo;
say "2: bar: $bar";
my $baz = $foo || "baz";
say "3: baz: $baz";
my $qux = $foo // "qux";
say "4: qux: $qux";
'
1: not defined
Use of uninitialized value $bar in concatenation (.) or string at -e l
+ine 5.
2: bar: 
3: baz: baz
4: qux: qux
[download]

Thanks!

Hey Nick,

The difference really only matters if what you're checking has a false value (that you may not know about, such as when looping through a hash). A false value is still defined:

perl -wMstrict -E 'my $x=0; say $x||1; say $x//2;'
1
0
[download]

Update: here's a tiny example that shows that in a larger application, not checking for defined can be an issue when you aren't explicitly looking for truth:

use warnings;
use strict;

this(arg => 0);

sub this {
    my %args = @_;
    do_something("if\n") if $args{arg};
    do_something("if def\n") if defined $args{arg};
}
sub do_something{
    print shift;
}
[download]

my $one = 1;
my $zero = 0;
my $undef;
my $result;

$result = 1;              # 1
$result = 1 || 0;         # also 1
$result = 0 || 1;         # also 1
$result = $zero || $one;  # also 1
$result = $zero // $one;  # 0
$result = $zero // 1;     # 0 as well
$result = 0 // 1;         # 0 as well
$result = $undef // $one; # 1 again
$result = $undef || $one; # 1 again

$result = fork || die;    # dies in the child process or if failing to
+ fork
$result = fork && die;    # dies in the parent process
$result = fork // die;    # dies in process unable to fork a child 
# (beware the return values of function calls, for they are subtle and
+ quick to bite your behind)
[download]