Local variable: Difference between revisions

Revision as of 16:00, 16 October 2013

Latest revision as of 15:53, 25 November 2023

(38 intermediate revisions by 26 users not shown)

Line 1:

{{Short description|Computer programming, a variable only usable in a portion of a program (the scope)}}

In [[computer science]], a '''local variable''' is a [[Variable (programming)|variable]] that is given ''local [[scope (programming)|scope]]''. LocalA local variable referencesreference in the [[subroutine|function]] or [[block (programming)|block]] in which it is declared overrideoverrides the same variable name in the larger scope. In [[programming language]]s with only two levels of visibility, local variables are contrasted with [[global variables]]. On the other hand, many [[ALGOL]]-derived languages allow any number of nested levels of visibility, with private variables, functions, constants and types hidden within them, either by nested blocks or [[nested function]]s. Local variables are fundamental to [[procedural programming]], and more generally [[modular programming]]: variables of local scope are used to avoid issues with [[side-effect (computer science)|side-effects]] that can occur with [[global variable|global variables]]s.

==Scope==

Local variables may have a lexical or dynamic [[scope (programming)|scope]], though lexical (static) scoping is far more common. In lexical scoping (or lexical scope; also called static scoping or static scope), if a variable name's scope is a certain functionblock, then its scope is the program text of the functionblock definition: within that block's text, the variable name exists, and is bound to the variable's value, but outside that block's text, the variable name does not exist. By contrast, in dynamic scoping (or dynamic scope), if a variable name's scope is a certain functionblock, then its scope is thethat time-periodblock duringand whichall thefunctions functiontransitively iscalled executing:by whilethat theblock function(except iswhen running,overridden theagain variableby nameanother exists, and is bound to its variable, butdeclaration); after the functionblock returnsends, the variable name does not exist. Static scoping is far more common. Some languages, like [[Perl]] and [[Common Lisp]], allow the programmer to choose static or dynamic scoping when defining or redefining a variable. Examples of languages that use dynamic scoping include [[Logo (programming language)|Logo]], [[Emacs lisp]], and the shell languages [[Bash (Unix shell)|bash]], [[dash (shell)|dash]], and the MirBSD Korn shell ([[mksh]])'s "local" declaration. Most other languages provide lexically scoped local variables.

In most languages, local variables are [[automatic variable]]s stored on the [[call stack]] directly. This means that when a [[recursion (computer science)|recursive function]] calls itself, local variables in each instance of the function are given distinct [[Memory address|addresses]]. Hence variables of this scope can be declared, written to, and read, without any risk of [[side-effect (computer science)|side-effects]] to functions outside of the block in which they are declared.

Line 8 ⟶ 10:

==Static local variables==

A special type of local variable, called a ''static local,'' is available in many mainstream languages (including [[C (programming language)|C]]/[[C++]], [[Visual Basic]], and [[Visual Basic (.NET)|VB.NET]] and [[PHP]]) which allows a value to be retained from one call of the function to another – it is a [[static variable]] with local scope. In this case, recursive calls to the function also have access to the (single, [[static memory allocation|statically allocated]]) variable. In all of the above languages, static variables are declared as such with a special ''storage class'' keyword (e.g., <code>static</code>).

Static locals in global functions have the same lifetime as [[static global variable]]s, because their value remains in memory for the life of the program,<ref>{{PDFlinkcite web|[url= http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf |title=Current C standard] }}&nbsp;{{small|(3.61&nbsp;MB<!-- application/pdf, 3788603 bytes -->)}} ({{As of|2009|lc=on}}). In particular, see section 6.2.4 “Storage durations of objects”, page 32.</ref> but have [[function scope]] (not global scope), as with automatic local variables.

This is distinct from other usages of the [[Static (keyword)|<code>static</code> keyword]], which has several different meanings in various languages.

Line 16 ⟶ 18:

==Local variables in Perl==

[[Perl]] supports both dynamic and lexically-scoped local variables. The keyword <code>local</code> is used to define local dynamically-scoped variables, while <code>my</code> is used for local lexically-scoped variables. Since dynamic scoping is less common today, the Perl documentation warns that "<code>local</code> isn't what most people think of as “local”.".<ref>[http://perldoc.perl.org/functions/local.html perldoc.perl.org: local]</ref>. Instead, the <code>local</code> keyword gives a temporary, [[scope (programmingcomputer science)|dynamically-scoped]] value to a global (package) variable, which lasts until the end of the enclosing block. However, the variable is visible to any function called from within the block.<ref>[http://perldoc.perl.org/perlsub.html#Temporary-Values-via-local() perldoc.perl.org: perlsub: Temporary Values via <code>local()</code>]</ref> To create lexically-scoped local variables, use the <code>my</code> operator instead.<ref>[http://perldoc.perl.org/perlsub.html#Private-Variables-via-my() perldoc.perl.org: perlsub: Private Variables via <code>my()</code>]</ref>

To create lexically-scoped local variables, use the <code>my</code> operator instead.<ref>[http://perldoc.perl.org/perlsub.html#Private-Variables-via-my() perldoc.perl.org: perlsub: Private Variables via <code>my()</code>]</ref>

To understand how it works consider the following code:

<sourcesyntaxhighlight lang="perl">

$a = 1;

sub f() {

local $a;

$a = 2;

g();

}

sub g() {

print "$a\n";

}

g();

f();

g();

</syntaxhighlight>

</source>

this will output:<br />

1

1<br />

2

2<br />

1

thisThis happens since the global variable $a is modified to a new ''temporary'' (local) meaning inside {{code|f()}}, but the global value is restored upon leaving the scope of {{code|f()}}.

Using <code>my</code> in this case instead of <code>local</code> would have printed 1 three times since in that case the <code>$a</code> variable would be limited to the static scope of the function {{code|f()}} and not seen by {{code|g()}}.<br /> Randal L. Schwartz and Tom Phoenix argue that the operator <code>local</code> should have had a different name like <code>save</code>.<ref>{{cite book|author=Randal L. Schwartz and Tom Phoenix|title=Learning Perl 3rd edition|paragraphat=paragraph 4.7|publisher=O'REILLY |date=2001-07-01 |ISBN=0-596-00132-0|url=https://archive.org/details/learningperl00schw}}</ref>

==Local variables in Ruby==

[[Ruby (programming language)|Ruby]] as a language was inspired also by Perl, but in this case, the notation was made simpler: a global variable name must be preceded by a $ sign, like <code>$variable_name</code>, while a local variable has simply no $ sign in front of its name, like <code>variable_name</code> (while in perl all scalar values have a $ in front). Note that Ruby only provides built-in support for statically-scoped local variables like Perl's <code>my</code>, not dynamically-scoped local variables like Perl's <code>local</code>. There is at least one library for Ruby that provides dynamically-scoped variables.

<ref>

Conrad Irwin.

"LSpace: Dynamic scope for Ruby".

December 2012

http://cirw.in/blog/lspace

Retrieved 2013-10-16.

</ref>

== See also ==

Line 56 ⟶ 63:

{{DEFAULTSORT:Local Variable}}

[[Category:Variable (computer programmingscience)]]