Perl has a variable declaration called local. One might be tempted to interpret this as creating a local variable in the sense such as other scripting languages (like Bash or Python) use local. Avoid temptation. I’m going to unpack this a bit here.
The places on the Web where Perl documentation lives tend to be a little shy about revealing much concerning this distinction. For example Perl Tutorial (org) cleverly avoids mention of local: Perl Variables. And w3schools (io) has a single ill-defined definition and an awkward attempt at scope: Perl – Comments (see Variable Scopes and Perl Local Variable).
Geeks for Geeks provides a much better explanation of the my keyword which will help to understand how my is similar to local in other languages (like Python or Bash): Perl | my Keyword. Also, plover has a thorough explanation for the uses of local: Seven Useful Uses of local. (If you’d like to dive even deeper, plover also has a thorough discussion of scope in Perl: Coping with Scoping.)
Ok, let’s see how simple we can make this.
If you are writing a Bash script and putting your executable code only into functions (in programming there should be no executable code outside of functions), then when you declare a local variable inside a function the scope of that variable will exist only inside that function. The only things that can have access to your variable live inside that function. Another function may call this function, but that calling function cannot see the variable.
Still in Bash, the reverse is also true with one caveat: this function can call another function but the called function will also not be able to see calling function’s local variable. However, this function can use export to export its local variable to the called function.
Let’s phrase this as a local variable in Bash can be exported down the call-stack (using export).
One other caveat of bash is that each function runs in its own subshell. This means that creating any variable inside a function will not overwrite any global variable (with the same name). This will catch one off-guard from time to time; it has me. (You cannot use export to send any variable up the call-stack.)
Back in Perl, a my variable would be stuck within it’s what’s called its lexical block. This is usually defined by a pair of squigglies: {}. To continue with our functions example (and again, you want all of your code to live within functions when you script) if you declare a my variable inside a function in Perl (what Perl calls a subroutine declared using sub), that my variable will be trapped in its function (subroutine) the same that a local variable in Bash would be trapped in its function.
Now that we have that aligned, let’s look at the relationship between a global variable and a local variable in Perl, because this is a bit tricky.
In both Perl and Bash, you will want to prefer declaring your global variables in the declarations section at the beginning of your script. (See my script templates for assistance.) Once declared, these global variables will be available throughout the current script by any function or call-stack.
This is where the power of Perl’s poorly named local keyword comes into play, which you will likely never need or use. Declaring an existing global variable as local inside a function temporarily re-assigns the global variable for use in this function and down any call-stack therein. Once this function (and any call-stack it evoked) ends execution, the former global variable is restored for the remainder of the script.
(Attempting to declare a local variable for a non-existant global variable will throw an error.)
So, in Perl local temporarily substitutes a value for a global variable. Could be powerfully useful in the right situation, but you probably just want my.
