高级 Bash 脚本编程指南
上一页第 24 章 函数下一页

24.2. 局部变量

是什么使变量成为局部的？

局部变量

声明为 局部 的变量是指仅在其出现的代码块内可见的变量。它具有局部的作用域。在函数中，局部变量 仅在该函数块内有意义。[1]

示例 24-12. 局部变量可见性

#!/bin/bash
# ex62.sh: 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.
                         # Therefore, defaults to global. 
  echo "\"global_var\" in function = $global_var"
}  

func

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

echo
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.
echo				      

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

Caution

在函数被调用之前，所有在函数内声明的变量在函数体外部都是不可见的，不仅仅是那些显式声明为 局部 的变量。

#!/bin/bash

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.

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

Note

正如 Evgeniy Ivanov 指出的那样，当在单个命令中声明和设置局部变量时，操作顺序显然是首先设置变量，然后才将其限制为局部作用域。这反映在返回值中。

#!/bin/bash

echo "==OUTSIDE Function (global)=="
t=$(exit 1)
echo $?      # 1
             # As expected.
echo

function0 ()
{

echo "==INSIDE Function=="
echo "Global"
t0=$(exit 1)
echo $?      # 1
             # As expected.

echo
echo "Local declared & assigned in same command."
local t1=$(exit 1)
echo $?      # 0
             # Unexpected!
#  Apparently, the variable assignment takes place before
#+ the local declaration.
#+ The return value is for the latter.

echo
echo "Local declared, then assigned (separate commands)."
local t2
t2=$(exit 1)
echo $?      # 1
             # As expected.

}

function0

24.2.1. 局部变量和递归。

递归 是一种有趣且有时有用的 自引用 形式。Herbert Mayer 将其定义为 ". . . 通过使用同一算法的更简单版本来表达算法 . . ."

考虑一个根据自身定义的定义，[2] 一个隐含在其自身表达式中的表达式，[3] 一条蛇吞噬自己的尾巴，[4] 或者... 一个调用自身的函数。[5]

示例 24-13. 简单递归函数演示

#!/bin/bash
# recursion-demo.sh
# Demonstration of recursion.

RECURSIONS=9   # How many times to recurse.
r_count=0      # Must be global. Why?

recurse ()
{
  var="$1"

  while [ "$var" -ge 0 ]
  do
    echo "Recursion count = "$r_count"  +-+  \$var = "$var""
    (( var-- )); (( r_count++ ))
    recurse "$var"  #  Function calls itself (recurses)
  done              #+ until what condition is met?
}

recurse $RECURSIONS

exit $?

示例 24-14. 另一个简单演示

#!/bin/bash
# recursion-def.sh
# A script that defines "recursion" in a rather graphic way.

RECURSIONS=10
r_count=0
sp=" "

define_recursion ()
{
  ((r_count++))
  sp="$sp"" "
  echo -n "$sp"
  echo "\"The act of recurring ... \""   # Per 1913 Webster's dictionary.

  while [ $r_count -le $RECURSIONS ]
  do
    define_recursion
  done
}

echo
echo "Recursion: "
define_recursion
echo

exit $?

局部变量是编写递归代码的有用工具，但这种做法通常涉及大量的计算开销，并且绝对不建议在 shell 脚本中使用。[6]

示例 24-15. 递归，使用局部变量

#!/bin/bash

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


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


MAX_ARG=5
E_WRONG_ARGS=85
E_RANGE_ERR=86


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

if [ "$1" -gt $MAX_ARG ]
then
  echo "Out of range ($MAX_ARG 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
fi  

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

  return $factorial
}

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

exit 0

另请参阅 示例 A-15，了解脚本中递归的示例。请注意，递归是资源密集型的，执行缓慢，因此通常不适用于脚本。

注释

[1]

但是，正如 Thomas Braunberger 指出的那样，在函数中声明的局部变量对于父函数调用的函数也是可见的。

#!/bin/bash

function1 ()
{
  local func1var=20

  echo "Within function1, \$func1var = $func1var."

  function2
}

function2 ()
{
  echo "Within function2, \$func1var = $func1var."
}

function1

exit 0


# Output of the script:

# Within function1, $func1var = 20.
# Within function2, $func1var = 20.

这在 Bash 手册中有所记录

“Local 只能在函数内部使用；它使变量名具有可见的作用域，该作用域仅限于该函数及其子函数。” [强调添加] 《ABS 指南》的作者认为此行为是一个错误。

[2]

也称为冗余。

[3]

也称为同义反复。

[4]

也称为隐喻。

[5]

也称为递归函数。

[6]

过多的递归层级可能会导致脚本因段错误而崩溃。

#!/bin/bash

#  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.

上一页首页下一页
复杂函数和函数复杂性上级不使用局部变量的递归