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

Is there a difference between a subroutine that does


and one that does?

return undef;


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.


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.

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);

The book "Perl Best Practices" recommends the use of return; instead of return undef; because the latter would return a one-element list in list context (the other answers already mention this). This would be a "nasty bug" according to the book.

However, I think returning nothing can actually cause serious bugs (probably difficult to find), whereas calling a boolean function in list context seems rather simple to debug.

So I always return something (that evaluates to) false in my boolean functions (usually 0 for false and 1 for true). (Yes, this would also return a one-element list in list context - so the comment in the book is technically right -, but then the actual error would be calling the boolean function in list context.)

To be clear, I still recommend the book. It offers a lot of good advice. And I am referring to Chapter 9 (Subroutines), page 199/200 ("Use a bare return to return failure.") in the book "Perl Best Practices" by Damian Conway (O'Reilly Media, Inc.), ISBN 978-0-596-00173-5. Not sure if there's another/newer edition.

Side note: Perl seems to return an empty string when negating something. my $foo = 5; return !$foo; returns q().

Need Your Help

How do I fix SVN 'Working copy text base is corrupt'?

svn repository

After many happy commits to my svn repo, all of the sudden the relationship went sour...svn flipped her lid and yelled: "Working copy text base is corrupt!"

data block size in HDFS, why 64MB?

database hadoop mapreduce block hdfs

The default data block size of HDFS/hadoop is 64MB.