Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions




23.2. Local Variables

What makes a variable "local"?

local variables

A variable declared as local is one that is visible only within the block of code in which it appears. It has local "scope". In a function, a local variable has meaning only within that function block.

Example 23-12. Local variable visibility

# Global and local variables inside a function.

func ()
  local loc_var=23       # Declared as local variable.
  echo                   # Uses the 'local' builtin.
  echo "\"loc_var\" in function = $loc_var"
  global_var=999         # Not declared as local.
                         # Defaults to global. 
  echo "\"global_var\" in function = $global_var"


# Now, to see if local variable "loc_var" exists outside function.

echo "\"loc_var\" outside function = $loc_var"
                                      # $loc_var outside function = 
                                      # No, $loc_var not visible globally.
echo "\"global_var\" outside function = $global_var"
                                      # $global_var outside function = 999
                                      # $global_var is visible globally.

exit 0
#  In contrast to C, a Bash variable declared inside a function
#+ is local *only* if declared as such.


Before a function is called, all variables declared within the function are invisible outside the body of the function, not just those explicitly declared as local.

func ()
global_var=37    #  Visible only within the function block
                 #+ before the function has been called. 
}                #  END OF FUNCTION

echo "global_var = $global_var"  # global_var =
                                 #  Function "func" has not yet been called,
                                 #+ so $global_var is not visible here.

echo "global_var = $global_var"  # global_var = 37
                                 # Has been set by function call.

23.2.1. Local variables help make recursion possible.

Local variables permit recursion, [1] but this practice generally involves much computational overhead and is definitely not recommended in a shell script. [2]

Example 23-13. Recursion, using a local variable


#               factorial
#               ---------

# Does bash permit recursion?
# Well, yes, but...
# It's so slow that you gotta have rocks in your head to try it.


if [ -z "$1" ]
  echo "Usage: `basename $0` number"
  exit $E_WRONG_ARGS

if [ "$1" -gt $MAX_ARG ]
  echo "Out of range (5 is maximum)."
  #  Let's get real now.
  #  If you want greater range than this,
  #+ rewrite it in a Real Programming Language.
  exit $E_RANGE_ERR

fact ()
  local number=$1
  #  Variable "number" must be declared as local,
  #+ otherwise this doesn't work.
  if [ "$number" -eq 0 ]
    factorial=1    # Factorial of 0 = 1.
    let "decrnum = number - 1"
    fact $decrnum  # Recursive function call (the function calls itself).
    let "factorial = $number * $?"

  return $factorial

fact $1
echo "Factorial of $1 is $?."

exit 0

See also Example A-16 for an example of recursion in a script. Be aware that recursion is resource-intensive and executes slowly, and is therefore generally not appropriate to use in a script.



Herbert Mayer defines recursion as ". . . expressing an algorithm by using a simpler version of that same algorithm . . ." A recursive function is one that calls itself.


Too many levels of recursion may crash a script with a segfault.

#  Warning: Running this script could possibly lock up your system!
#  If you're lucky, it will segfault before using up all available memory.

recursive_function ()		   
echo "$1"     # Makes the function do something, and hastens the segfault.
(( $1 < $2 )) && recursive_function $(( $1 + 1 )) $2;
#  As long as 1st parameter is less than 2nd,
#+ increment 1st and recurse.

recursive_function 1 50000  # Recurse 50,000 levels!
#  Most likely segfaults (depending on stack size, set by ulimit -m).

#  Recursion this deep might cause even a C program to segfault,
#+ by using up all the memory allotted to the stack.

echo "This will probably not print."
exit 0  # This script will not exit normally.

#  Thanks, St�phane Chazelas.

  Published under the terms of the GNU General Public License Design by Interspire