24.2 局部变量

怎样使一个变量变成“局部”变量？

局部变量
如果变量用local来声明，那么它就只能够在该变量被声明的代码块中可见。 这个代码块就是局部范围。 在一个函数中，一个局部变量只有在函数代码中才有意义.[1]

例子 24-12. 局部变量的可见范围

  1. #!/bin/bash
  2. # ex62.sh: 函数内部的局部变量与全局变量。
  4. func () {
  5.     local loc_var=23       # 声明为局部变量。
  6.     echo                   # 使用'local'内建命令
  7.     echo "\"loc_var\" in function = $loc_var"
  8.     global_var=999         # 没有声明为局部变量。
  9.     # 默认为全局变量。
  11.     echo "\"global_var\" in function = $global_var"
  12. }
  14. func
  16. # 现在，来看看局部变量“loc_var”在函数外部是否可见。
  18. echo
  19. echo "\"loc_var\" outside function = $loc_var"
  20.                                     # $loc_var outside function =
  21.                                     # 不行, $loc_var 不是全局可见的.
  22. echo "\"global_var\" outside function = $global_var"
  23.                                     # $在函数外部global_var = 999
  24.                                     # $global_var 是全局可见的.
  25. echo
  27. exit 0
  28. #  与C语言相比，在函数内声明的Bash变量
  29. #+ 除非它被明确声明为local时，它才是局部的。

notice 在函数被调用之前，所有在函数中声明的变量，在函数外部都是不可见的，当然也包括那些被明确声明为local的变量。

  1. #!/bin/bash
  3. func ()
  4. {
  5.     global_var=37    #  变量只在函数体内可见
  6.                      #+ 在函数被调用之前。
  7. }                    #  函数结束
  9. echo "global_var = $global_var"  # global_var =
  10.                                  #  函数 "func" 还没被调用，
  11.                                  #+ 所以$global_var 在这里还不是可见的.
  12. func
  13. echo "global_var = $global_var"  # global_var = 37
  14.                                  # 已经在函数调用的时候设置。

extra 正如Evgeniy Ivanov指出的那样，当在一条命令中定义和给一个局部变量赋值时，显然操作的顺序首先是给变量赋值，之后限定变量的局部范围。这可以通过返回值来反应。

  1. #!/bin/bash
  3. echo "==OUTSIDE Function (global)=="
  4. t=$(exit 1)
  5. echo $?     # 1
  6.             # 如预期一样.
  8. echo
  9. function0 ()
  10. {
  11.     echo "==INSIDE Function=="
  12.     echo "Global"
  13.     t0=$(exit 1)
  14.     echo $?      # 1
  15.                  # 如预期一样.
  17.     echo
  18.     echo "Local declared & assigned in same command."
  19.     local t1=$(exit 1)
  20.     echo $?      # 0
  21.                  # 意料之外!
  22. #  显然，变量赋值发生在Apparently, 
  23. #+ 局部声明之前。
  24. #+ 返回值是为了latter.
  26.     echo
  27.     echo "Local declared, then assigned (separate commands)."
  28.     local t2
  29.     t2=$(exit 1)
  30.     echo $?
  31. }
  33. function0

24.2.1 局部变量和递归

递归是一个有趣并且有时候非常有用的自己调用自己的形式。 Herbert Mayer 是这样定义递归的，“。。。表示一个算法通过使用一个简单的相同算法版本。。。”

想象一下，一个定义是从自身考虑的，[2] 一个表达包含了自身的表达， [3] 一条蛇吞下自己的尾巴， [4] 或者 。。。 一个函数调用自身。[5]

例子 24-13. 一个简单的递归函数表示

  1. #!/bin/bash
  2. # recursion-demo.sh
  3. # 递归演示.
  5. RECURSIONS=9   # 递归的次数.
  6. r_count=0      # 必须是全局变量，为什么？
  8. recurse ()
  9. {
  10.     var="$1"
  12.     while [ "$var" -ge 0 ]
  13.     do
  14.         echo "Recursion count = "$r_count"  +-+  \$var = "$var""
  15.         (( var-- )); (( r_count++ ))
  16.         recurse "$var"  #  函数调用自身(递归)
  17.     done              #+ 直到遇到什么样的终止条件？
  18. }
  20. recurse $RECURSIONS
  22. exit $?
  23. `

例子 24-14. 另一个简单的例子

  1. #!/bin/bash
  2. # recursion-def.sh
  3. # 另外一个描述递归的比较生动的脚本。
  5. RECURSIONS=10
  6. r_count=0
  7. sp=" "
  9. define_recursion ()
  10. {
  11.     ((r_count++))
  12.     sp="$sp"" "
  13.     echo -n "$sp"
  14.     echo "\"The act of recurring ... \""        # Per 1913 Webster's dictionary.
  16.     while [ $r_count -le $RECURSIONS ]
  17.     do
  18.         define_recursion
  19.     done
  20. }
  22. echo
  23. echo "Recursion: "
  24. define_recursion
  25. echo
  27. exit $?

局部变量是一个写递归代码有效的工具，但是这种方法一般会包含大量的计算负载，显然在shell脚本中并不推荐递归.[6]

例子24-15. 使用局部变量进行递归

  1. #!/bin/bash
  3. # 阶乘
  4. # ---------
  6. # Bash允许递归么？
  7. # 恩，允许，但是...
  8. # 他太慢了，所以恐怕你难以忍受。
  10. MAX_ARG=5
  11. E_WRONG_ARGS=85
  12. E_RANGE_ERR=86
  15. if [ -z "$1" ]
  16. then
  17.     echo "Usage: `basename $0` number"
  18.     exit $E_WRONG_ARGS
  19. fi
  21. if [ "$1" -gt $MAX_ARG ]
  22. then
  23.     echo "Out of range ($MAX_ARG is maximum)."
  24.     #  现在让我们来了解一些实际情况。
  25.     #  如果你想计算比这个更大的范围的阶乘，
  26.     #+ 应该用真正的编程语言来重写它。
  27.     exit $E_RANGE_ERR
  28. fi
  30. fact () 
  31. {
  32.     local number=$1
  33.     #  变量"number" 必须被定义为局部变量，
  34.     #+ 否则不能正常工作。
  35.     if [ "$number" -eq 0 ]
  36.     then
  37.         factorial=1    # 0的阶乘为1.
  38.     else
  39.         let "decrnum = number - 1"
  40.         fact $decrnum  # 递归的函数调用 (就是函数调用自己).
  41.         let "factorial = $number * $?"
  42.     fi
  43.     return $factorial
  44. }
  46. fact $1
  47. echo "Factorial of $1 is $?."
  49. exit 0

也可以参考例子 A-15，一个包含递归例子的脚本。我们意识到递归同时也意味着巨大的资源消耗和缓慢的运行速度，因此它并不适合在脚本中使用。

注释

[1] 然而，如Thomas Braunberger 指出的那样，一个函数里定义的局部变量对于调用它的父函数也是可见的。

  1. #!/bin/bash
  3. function1 ()
  4. {
  5.   local func1var=20
  7.   echo "Within function1, \$func1var = $func1var."
  9.   function2
  10. }
  12. function2 ()
  13. {
  14.   echo "Within function2, \$func1var = $func1var."
  15. }
  17. function1
  19. exit 0
  22. # 脚本的输出:
  24. # Within function1, $func1var = 20.
  25. # Within function2, $func1var = 20.

在Bash手册里是这样描述的：

“局部变量只能在函数内部使用; 它让变量名的可见范围限制在了函数内部以及它的孩子里” [emphasis added]
The ABS Guide的作者认为这个行为一个bug.

[2] 被熟知为冗余。

[3] 被熟知为同义反复。

[4] 被熟知为暗喻。

[5] 被熟知为递归函数。

[6] 太多的递归层次可能会引发一个脚本的段错误。

  1. #!/bin/bash
  3. #  提醒: 运行这个脚本可能会让你的系统卡死。
  4. #  如果你够好运的话，在耗尽可用内存之前，它会发生一个段错误。
  6. recursive_function ()           
  7. {
  8. echo "$1"     # 让函数做一些事情，加快发生段错误。
  9. (( $1 < $2 )) && recursive_function $(( $1 + 1 )) $2;
  10. #  只要第一个参数小于第二个参数，
  11. #+ 让第一个参数加1，然后递归。
  12. }
  14. recursive_function 1 50000  # 递归 50,000层!
  15. #  很可能发生段错误(依赖于栈的大小，通过ulimit -m可以设置栈的大小)
  17. #  即使是C语言，递归调用这么多层也会发生段错误，
  18. #+ 通过分配栈耗尽所有的内存。
  21. echo "This will probably not print."
  22. exit 0  # 这个脚本可能不会正常退出。
  24. #  感谢, Stéphane Chazelas.