But they often can achieve the same result.
And usually people use them without even noticing the difference...

• chop and chomp.

  They're pretty darned close, until you discover the last line of the file you read from doesn't have a newline.

• &somesub and somesub().

  Usually you won't notice a difference, but the first one makes the sub call and passes the current value of @_ as the arguments. Hmm... if you make such a sub call from within another sub and are expecting no arguments to be passed...

• $somearray[0] and @somearray[0].

  This one bites quite a few programmers. It usually doesn't cause a problem, but guess what happens when you do something like @vals[3] = somesub() and &somesub uses wantarray? Then you've got trouble and it can be a nasty bug to find.

• my and local.

  My creates a lexical variable that's private to a package (note that this is NOT a package variable). local temporarily replaces the current package variable with another value.

Run the following code:

use strict;
use warnings;

print test();

sub test {
    local $x;
    $x = 17;
}
[download]

Global symbol "$x" requires explicit package name at C:\WINNT\Profiles
+\Ovid\Desktop\test.pl line 7
[download]

For more information, see Coping with Scoping and Seven Useful Uses of local. Both, oddly enough, were written by Dominus, the monk you chose to take to task.

Cheers,
Ovid

Update: After chatting with zenmaster and reading his update, I see that this mostly appears to be a misunderstanding of what he meant to say, but I'll leave the post as it's useful information.

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

use Time::HiRes qw(gettimeofday);
$start_time = gettimeofday();
$global_variable = "hello!";

for ($i = 0; $i < 10000000; $i++) {
        # replace this with "my"
        local $global_variable = "redefined. . ";
}
print gettimeofday - $start_time." seconds\n";
print "$global_variable\n";
[download]

31.4016380310059 seconds
hello!
[download]

14.1771370172501 seconds
hello!
[download]

Using twerq's original script, I got similar results on an ActiveState Perl/Win32 machine: my was more than twice as fast as local.

However, I modified twerq's script so that each variable is only declared once. Here is the modified script, which measures time to access or change variables rather than to declare them:

# replace local with "my"
local $start_time = time;
local $global_variable = "hello!";

for (local $i = 0; $i < 5000000; $i++) {
              $global_variable = "redefined. . ";
}
print time - $start_time." seconds\n";
print "$global_variable\n";
[download]

The program now takes 24 seconds when local is used and 18 when my is used. So it appears that local can introduce significant overhead into a program even when the program only declares variables a few times but accesses them over and over.