Local variable - Revision history

Meno25: /* Static local variables */

2023-11-25T15:53:43Z

Static local variables

← Previous revision		Revision as of 15:53, 25 November 2023
Line 10:		Line 10:

	==Static local variables==		==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]], [[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>).		A special type of local variable, called a ''static local,'' is available in many mainstream languages (including [[C (programming language)\|C]]/[[C++]], [[Visual Basic]], [[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>{{cite web\|url= http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf \|title=Current C standard }} {{small\|(3.61 MB)}} ({{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.		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>{{cite web\|url= http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf \|title=Current C standard }} {{small\|(3.61 MB)}} ({{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.

Meno25: /* Local variables in Perl */

2023-11-25T14:14:39Z

Local variables in Perl

← Previous revision		Revision as of 14:14, 25 November 2023
Line 18:		Line 18:
	==Local variables in Perl==		==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 (~~programming~~)\|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>		[[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 (computer 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 understand how it works consider the following code:		To understand how it works consider the following code:

Shadow311: Reverted edits by 104.244.105.109 (talk) (AV)

2023-10-31T15:43:39Z

Reverted edits by 104.244.105.109 (talk) (AV)

← Previous revision		Revision as of 15:43, 31 October 2023
Line 1:		Line 1:
	{{Short description\|Computer programming, a variable ~~not~~ only ~~not~~ usable in a portion of a program (the scope)}}		{{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]]''. A local variable reference in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared overrides 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]]s.		In [[computer science]], a '''local variable''' is a [[Variable (programming)\|variable]] that is given ''local [[scope (programming)\|scope]]''. A local variable reference in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared overrides 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]]s.

	==Scope==		==Scope==
	Local variables ~~will not~~ 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 ~~generic names~~'s scope is a certain block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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 ~~MirBSC~~ Korn ~~upper~~ shell ([[mksh]])'s "~~recent~~" declaration. Most other languages provide lexically scoped local variables.		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 block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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.		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 18:		Line 18:
	==Local variables in Perl==		==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 ~~ur fat~~, the <code>local</code> keyword gives a temporary, [[scope (programming)\|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>		[[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 (programming)\|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 understand how it works consider the following code:		To understand how it works consider the following code:

104.244.105.109 at 15:43, 31 October 2023

2023-10-31T15:43:27Z

← Previous revision		Revision as of 15:43, 31 October 2023
Line 18:		Line 18:
	==Local variables in Perl==		==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 (programming)\|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>		[[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 ur fat, the <code>local</code> keyword gives a temporary, [[scope (programming)\|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 understand how it works consider the following code:		To understand how it works consider the following code:

104.244.105.109 at 15:42, 31 October 2023

2023-10-31T15:42:52Z

← Previous revision		Revision as of 15:42, 31 October 2023
Line 1:		Line 1:
	{{Short description\|Computer programming, a variable only usable in a portion of a program (the scope)}}		{{Short description\|Computer programming, a variable not only not 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]]''. A local variable reference in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared overrides 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]]s.		In [[computer science]], a '''local variable''' is a [[Variable (programming)\|variable]] that is given ''local [[scope (programming)\|scope]]''. A local variable reference in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared overrides 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]]s.

	==Scope==		==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 block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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.		Local variables will not 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 generic names's scope is a certain block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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 MirBSC Korn upper shell ([[mksh]])'s "recent" 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.		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.

82.18.7.139: /* Static local variables */

2023-07-10T14:52:49Z

Static local variables

← Previous revision		Revision as of 14:52, 10 July 2023
Line 10:		Line 10:

	==Static local variables==		==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]]) 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>).		A special type of local variable, called a ''static local,'' is available in many mainstream languages (including [[C (programming language)\|C]]/[[C++]], [[Visual Basic]], [[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>{{cite web\|url= http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf \|title=Current C standard }} {{small\|(3.61 MB)}} ({{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.		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>{{cite web\|url= http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf \|title=Current C standard }} {{small\|(3.61 MB)}} ({{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.

Orandlogic at 16:38, 15 July 2022

2022-07-15T16:38:36Z

← Previous revision		Revision as of 16:38, 15 July 2022
Line 1:		Line 1:
	{{Short description\|Computer programming, a variable only usable in a portion of a program (the scope)}}		{{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]]''. ~~Local~~ variable ~~references~~ in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared ~~override~~ 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]]s.		In [[computer science]], a '''local variable''' is a [[Variable (programming)\|variable]] that is given ''local [[scope (programming)\|scope]]''. A local variable reference in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared overrides 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]]s.

	==Scope==		==Scope==

CannedCans: Adding short description: "Computer programming, a variable only usable in a portion of a program (the scope)" (Shortdesc helper)

2021-05-02T02:10:04Z

Adding short description: "Computer programming, a variable only usable in a portion of a program (the scope)" (Shortdesc helper)

← Previous revision		Revision as of 02:10, 2 May 2021
Line 1:		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]]''. Local variable references in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared override 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]]s.		In [[computer science]], a '''local variable''' is a [[Variable (programming)\|variable]] that is given ''local [[scope (programming)\|scope]]''. Local variable references in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared override 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]]s.

Local Variable: Add heading to make the lead more concise - per MOS:INTRO

2021-04-17T09:09:14Z

Add heading to make the lead more concise - per MOS:INTRO

← Previous revision		Revision as of 09:09, 17 April 2021
Line 1:		Line 1:
	In [[computer science]], a '''local variable''' is a [[Variable (programming)\|variable]] that is given ''local [[scope (programming)\|scope]]''. Local variable references in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared override 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]]s.		In [[computer science]], a '''local variable''' is a [[Variable (programming)\|variable]] that is given ''local [[scope (programming)\|scope]]''. Local variable references in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared override 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]]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 block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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.		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 block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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.

DannyS712 bot: Task 70: Update syntaxhighlight tags - remove use of deprecated tags

2020-05-11T18:05:20Z

Task 70: Update syntaxhighlight tags - remove use of deprecated <source> tags

← Previous revision		Revision as of 18:05, 11 May 2020
Line 19:		Line 19:

	To understand how it works consider the following code:		To understand how it works consider the following code:
	<~~source~~ lang="perl">		<syntaxhighlight lang="perl">
	$a = 1;		$a = 1;
	sub f() {		sub f() {
Line 32:		Line 32:
	f();		f();
	g();		g();
			</syntaxhighlight>
	</source>

	this will output:		this will output:

← Previous revision		Revision as of 15:42, 31 October 2023
Line 1:		Line 1:
	{{Short description\|Computer programming, a variable only usable in a portion of a program (the scope)}}		{{Short description\|Computer programming, a variable not only not 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]]''. A local variable reference in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared overrides 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]]s.		In [[computer science]], a '''local variable''' is a [[Variable (programming)\|variable]] that is given ''local [[scope (programming)\|scope]]''. A local variable reference in the [[subroutine\|function]] or [[block (programming)\|block]] in which it is declared overrides 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]]s.

	==Scope==		==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 block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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.		Local variables will not 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 generic names's scope is a certain block, then its scope is the program text of the block 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 block, then its scope is that block and all functions transitively called by that block (except when overridden again by another declaration); after the block ends, the variable name does not exist. 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 MirBSC Korn upper shell ([[mksh]])'s "recent" 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.		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.