Calling with '&' can affect both prototype checking and the value of @_ passed to the sub. With &, the prototype check is skipped, and if no parenthesized arguments are given the existing @_ is passed as the argument list.

Not usually, but it does if the sub is "prototyped"; in which case the call with & will disregard the "prototype".

It can also matter if you don't supply parens on your call; in which case you'll need to declare the sub before you call it unless you use the & on your call.

$ perl -le 'foo; sub foo { print "foo" }'
$ perl -le '&foo; sub foo { print "foo" }'
foo
[download]

$ perl -wle 'foo; sub foo{ print "foo"}'
Unquoted string "foo" may clash with future reserved word at -e line 1
+.
Useless use of a constant in void context at -e line 1.
[download]

-sauoq
"My two cents aren't worth a dime.";

use strict;
&use();
#use(); #this doesn't work
sub use
{
      print "In sub\n";
}
[download]

It's not bad for obfuscation though.

package Just_another_Perl_Hacker; sub print {($_=$_[0])=~ s/_/ /g;
                                      print } sub __PACKAGE__ { &
                                      print (     __PACKAGE__)} &
                                                  __PACKAGE__
                                            (                )
[download]

Abigail

(tye)Re: A question of style covers that pretty well.

Another difference I haven't seen mentioned yet is that within a sub, using &here (with the ampersand and without parentheses) will pass along the arguments in @_ to the here sub.

For example:

#!/usr/bin/perl -w

use strict;

test1("hello");
test2("hello");

sub test1
{
  &showargs;
}

sub test2
{
  &showargs();
}

sub showargs
{
  print "Got args @_\n";
}
__END__
Got args hello
Got args
[download]