What's the difference between return; and return undef; in Perl

Question

Is there a difference between a subroutine that does

return;

and one that does

return undef;

?

Answer 1

Given

sub foo { return; }
sub bar { return undef; }

In scalar context, they behave the same.

my $foo = foo();   # $foo is undef
my $bar = bar();   # $bar is undef

In list context, they behave differently

my @foo = foo();   # @foo is ()  (an empty list)
my @bar = bar();   # @bar is ( undef )  (a one-element list)

Note that a one-element list is a true value in boolean context, even though the only element is undef.

In general, it's usually not a good idea to return undef; from a subroutine, because of how it behaves in context.

Answer 2

return will return an empty list in list context but undef in scalar context. return undef; will always return a single value undef even in list context.

In general, it's usually not a good idea to return undef; from a subroutine normally used in list context:

sub foo { return undef }
if ( my @x = foo() ) {
    print "oops, we think we got a result";
}

In general, it's usually not a good idea to return; from a subroutine normally used in scalar context, because it won't behave as the user expects in list context:

sub foo { return }
%x = ( 'foo' => foo(), 'bar' => 'baz' );
if ( ! exists $x{'bar'} ) {
    print "oops, bar became a value, not a key";
}

Both of these errors happen quite a bit in practice, the latter more so, perhaps because subs that are expected to return a scalar are more common. And if it's expected to return a scalar, it had better return a scalar.

Answer 3

I think I still agree with PBP though.

1) You should avoid nesting function calls:

my $result = bar();
foo(1, $result, 2);

2) You should always be explicit (when doing "complicated" things):

foo(1, scalar bar(), 2);