Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
    • 第一部分 初见shell

      • 第一章 为什么使用shell编程
        • 第二章 和Sha-Bang(#!)一起出发

          • 2.1 调用一个脚本
            • 2.2 牛刀小试
          • 第二部分 shell基础

            • 第三章 特殊字符
              • 第四章 变量与参数

                • 4.1 变量替换
                  • 4.2 变量赋值
                    • 4.3 Bash变量是弱类型的
                      • /code/shell/part2/04_4_special_variable_types
                      • 第五章 引用

                        • 5.1 引用变量
                          • 5.2 转义
                          • 第六章 退出与退出状态
                            • 第七章 测试

                              • 7.1 测试结构
                                • 7.2 文件测试操作
                                  • 7.3 其他比较操作
                                    • 7.4 嵌套 if/then 条件测试
                                      • 7.5 牛刀小试
                                      • 第八章 运算符相关话题

                                        • 8.1 运算符
                                          • 8.2 数字常量
                                            • 8.3 双圆括号结构
                                              • 8.4 运算符优先级
                                            • 第三部分 shell进阶

                                              • 第九章 换个角度看变量

                                                • 9.1 内部变量
                                                  • 9.2 变量类型标注:declare 与 typeset
                                                    • 9.2.1 declare 的另类用法
                                                      • 9.3 $RANDOM:生成随机数
                                                      • 第十章 变量处理

                                                        • 10.1 字符串处理
                                                          • 10.1.1 使用 awk 处理字符串
                                                            • 10.1.2 参考资料
                                                              • 10.2 参数替换
                                                              • 第十一章 循环与分支

                                                                • 11.1 循环
                                                                  • 11.2 嵌套循环
                                                                    • 11.3 循环控制
                                                                      • 11.4 测试与分支
                                                                      • 第十二章 命令替换
                                                                        • 第十三章 算术扩展
                                                                        • 第四部分 命令
                                                                          • 第五部分 高级话题

                                                                            • 18 正则表达式

                                                                              • 18.1 正则表达式简介
                                                                                • 18.2文件名替换
                                                                                  • 18.3 正则表达式对照表
                                                                                  • 19 嵌入文档
                                                                                    • 20 I/O 重定向

                                                                                      • 20.1 使用 exec
                                                                                        • 20.2 重定向代码块
                                                                                          • 20.3 应用程序
                                                                                          • 第二十一章 子shell
                                                                                            • 第二十二章. 限制模式的Shell
                                                                                              • 第二十三章. 进程替换
                                                                                                • 24 函数

                                                                                                  • 24.1 复杂函数和函数复杂性
                                                                                                    • 24.2 局部变量
                                                                                                      • 24.2.1 局部变量和递归
                                                                                                        • 注释
                                                                                                        • 24.3 不使用局部变量的递归
                                                                                                        • 25. 别名
                                                                                                          • 26. 列表结构
                                                                                                            • 27 数组
                                                                                                              • 30 网络编程
                                                                                                                • 33 选项
                                                                                                                  • 第34章 陷阱
                                                                                                                    • 第36章 杂项
                                                                                                                      • echo命令
                                                                                                                      • 第六部分 Google Shell 风格指南
                                                                                                                      • 前端学习笔记

                                                                                                                        24.2 局部变量

                                                                                                                        author iconLinuxStorycalendar icon2021年5月11日category icon
                                                                                                                        • Linux
                                                                                                                        tag icon
                                                                                                                        • Bash
                                                                                                                        timer icon大约 5 分钟

                                                                                                                        此页内容
                                                                                                                        • 24.2.1 局部变量和递归
                                                                                                                        • 注释

                                                                                                                        # 24.2 局部变量

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

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

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

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

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

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

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

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

                                                                                                                        # 24.2.1 局部变量和递归

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

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

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

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

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

                                                                                                                        #!/bin/bash
                                                                                                                        # recursion-def.sh
                                                                                                                        # 另外一个描述递归的比较生动的脚本。
                                                                                                                        
                                                                                                                        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 $?
                                                                                                                        
                                                                                                                        1
                                                                                                                        2
                                                                                                                        3
                                                                                                                        4
                                                                                                                        5
                                                                                                                        6
                                                                                                                        7
                                                                                                                        8
                                                                                                                        9
                                                                                                                        10
                                                                                                                        11
                                                                                                                        12
                                                                                                                        13
                                                                                                                        14
                                                                                                                        15
                                                                                                                        16
                                                                                                                        17
                                                                                                                        18
                                                                                                                        19
                                                                                                                        20
                                                                                                                        21
                                                                                                                        22
                                                                                                                        23
                                                                                                                        24
                                                                                                                        25
                                                                                                                        26
                                                                                                                        27

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

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

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

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

                                                                                                                        # 注释

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

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

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

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

                                                                                                                        [2]open in new window 被熟知为冗余。

                                                                                                                        [3]open in new window 被熟知为同义反复。

                                                                                                                        [4]open in new window 被熟知为暗喻。

                                                                                                                        [5]open in new window 被熟知为递归函数。

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

                                                                                                                        #!/bin/bash
                                                                                                                        
                                                                                                                        #  提醒: 运行这个脚本可能会让你的系统卡死。
                                                                                                                        #  如果你够好运的话,在耗尽可用内存之前,它会发生一个段错误。
                                                                                                                        
                                                                                                                        recursive_function ()		   
                                                                                                                        {
                                                                                                                        echo "$1"     # 让函数做一些事情,加快发生段错误。
                                                                                                                        (( $1 < $2 )) && recursive_function $(( $1 + 1 )) $2;
                                                                                                                        #  只要第一个参数小于第二个参数,
                                                                                                                        #+ 让第一个参数加1,然后递归。
                                                                                                                        }
                                                                                                                        
                                                                                                                        recursive_function 1 50000  # 递归 50,000层!
                                                                                                                        #  很可能发生段错误(依赖于栈的大小,通过ulimit -m可以设置栈的大小)
                                                                                                                        
                                                                                                                        #  即使是C语言,递归调用这么多层也会发生段错误,
                                                                                                                        #+ 通过分配栈耗尽所有的内存。
                                                                                                                        
                                                                                                                        
                                                                                                                        echo "This will probably not print."
                                                                                                                        exit 0  # 这个脚本可能不会正常退出。
                                                                                                                        
                                                                                                                        #  感谢, Stéphane Chazelas.
                                                                                                                        
                                                                                                                        1
                                                                                                                        2
                                                                                                                        3
                                                                                                                        4
                                                                                                                        5
                                                                                                                        6
                                                                                                                        7
                                                                                                                        8
                                                                                                                        9
                                                                                                                        10
                                                                                                                        11
                                                                                                                        12
                                                                                                                        13
                                                                                                                        14
                                                                                                                        15
                                                                                                                        16
                                                                                                                        17
                                                                                                                        18
                                                                                                                        19
                                                                                                                        20
                                                                                                                        21
                                                                                                                        22
                                                                                                                        23
                                                                                                                        24
                                                                                                                        edit icon编辑此页open in new window
                                                                                                                        上次编辑于: 2022/4/27 15:33:00
                                                                                                                        贡献者: clay-wangzhi
                                                                                                                        上一页
                                                                                                                        24.1 复杂函数和函数复杂性
                                                                                                                        下一页
                                                                                                                        24.3 不使用局部变量的递归
                                                                                                                        备案号:冀ICP备2021007336号
                                                                                                                        Copyright © 2023 LinuxStory