in reply to Re: Re: Whether to use local()
in thread Whether to use local()

You can use both globals (package vars) and lexicals under use strict though globals need to be fully qualified ( $My::Mail::Server= "";)
Though globals are usually (not always) the wrong way to go. The idea of lexicals are that they only exist in a scope thereby limiting access. What local does is let you temporarily save a value for a package var. It's a runtime trick and my is (mostly) a compile time trick.

The lowdown is package vars exist in packages and any can be accessed from any package. my vars exist in the scope they where declared in and cannot be accessed outside so you don't have to worry about other subs/modules etc clobbering your values. You usually use local to save the value of $/ or $_ so you don't screw up code that calls your code. It has some other uses but that's one of the main one. There are probably a lot better explainations than mine and I'm sure if you do a search for lexical / package / global you will find a wealth of info here in the monestary.

here is a great FAQ on "Coping with Scoping" by dominus. It's a far better explaination than mine.


"To be civilized is to deny one's nature."

Replies are listed 'Best First'.
Re(4) Whether to use local()
by dmmiller2k (Chaplain) on Mar 16, 2002 at 04:25 UTC

    local (the keyword) has NOTHING to do with local variables. In Perl, you use my (the keyword) to declare local (i.e., lexically scoped, or 'lexical') variables.

    The keyword local localizes a variable, whether it's named or anonymous or global (i.e., package variables, which are in the symbol table). To localize a variable is to stash away its value in such a way that exiting the enclosing scope will result in its being restored. For example:

    use vars qw( $x ); # a package global $x = 'outer'; # this block: { my $save_x = $x; # localize $x by saving its value $x = 'inner'; # change $x to hearts content some_sub( $x ); # some_sub() sees $x with value 'inner' $x = $save_x; # restore original value just before exiting b +lock } # is functionally identical to this block: { local $x = 'inner'; some_sub( $x ); } # in both cases, some_sub() is called with the package global $x set # to 'inner' and in both cases, the value of $x is restored when the # block exits, except in the 'local' case, it is not necessary to # explicitly restore $x

    One example of its use is with the Perl global, $/. Often, (in a subroutine, for example) it is necessary to set $/ = undef;, but to do so may break code which assumes its default value.

    # need to 'slurp' in an entire file { local $/ = undef; # (read the file, etc.) } # $/ is now restored to whatever it was before

    Hopefully, this explains WHEN to use local.

    Update: Whoops! I stand corrected (thanks, shotgunefx)! Starting with Perl 5.5, it became possible to localize arbitrary anonymous variables (e.g., local $obj->get_handle()->{some_property}->get_param("param1");). I never actually had a use for (and therefore never tried) localize a lexical; I suppose I just assumed that they could.

    Apologies to all for suggesting that localizing a lexical was possible.


    If you GIVE a man a fish you feed him for a day
    TEACH him to fish and you feed him for a lifetime
      Not according to the perl I use. The code below dies with Can't localize lexical variable $bar at line 10.
      #!/usr/bin/perl -w $main::foo = 'global'; my $bar = "my"; print "foo is ",$foo,"\n"; print "my is ",$bar,"\n"; { local $foo; local $bar; # Dies here. print "foo is ",$foo,"\n"; print "foo is ",$main::foo,"\n"; print "bar is ",$bar,"\n"; } print "foo is ",$foo,"\n"; print "my is ",$bar,"\n";


      "To be civilized is to deny one's nature."

        My mistake, lexicals cannot be localized. However, pretty much everything else can (properties of objects, hash values and array elements, etc.).