24 函数

本章目录

和其它“真正”的编程语言一样，Bash也有函数，尽管它在实现方面有一些限制。一个函数就是一个子程序，实现一系列操作的代码块，执行一个特定任务的“黑盒子”。有重复代码的地方，当一个过程只需要轻微修改任务就会重复执行的时候，那么你就需要考虑使用函数了。

  1. function function_name {
  2. command...
  3. }

或者

  1. function_name () { 
  2. command...
  3. }

第二种形式可能会更受C程序员的喜爱（并且它更具有可移植性）。
在C语言里面，函数的圆括号可以出现在第二行。

  1. function_name () {
  2. command...
  3. }

extra 一个函数可能被“压缩”到一个单独行里。

  1. fun () { echo "This is a function"; echo; } 
  2. #                                 ^     ^

然而，在这种情况下，函数里的最后一个命令必须跟有一个分号。

  1. fun () { echo "This is a function"; echo } # Error! 
  2. #                                       ^
  3. fun2 () { echo "Even a single-command function? Yes!"; } 
  4. #                                                    ^

只需要引用函数名字就可以调用或者触发函数。一个函数调用相当于一个命令。

例子 24-1. 简单的函数

  1. #!/bin/bash
  2. # ex59.sh: 练习函数(简单的).
  4. JUST_A_SECOND=1
  6. funky ()
  7. { # 这是一个简单的函数
  8.     echo "This is a funky function."
  9.     echo "Now exiting funky function."
  10. } # 函数必须在调用前声明.
  13. fun ()
  14. {   # 一个稍微复杂点的函数.
  15.     i=0
  16.     REPEATS=30
  18.     echo
  19.     echo "And now the fun really begins."
  20.     echo
  22.     sleep $JUST_A_SECOND    # Hey, 等一秒钟!
  23.     while [ $i -lt $REPEATS ]
  24.     do
  25.         echo "----------FUNCTIONS---------->"
  26.         echo "<------------ARE-------------"
  27.         echo "<------------FUN------------>"
  28.         echo
  29.         let "i+=1"
  30.     done
  31. }
  33. # 现在，调用这些函数.
  35. funky
  36. fun
  38. exit $?

函数定义必须在第一次函数调用之前。没有声明函数的方法，比如像C语言中一样。

  1. f1
  2. # 将会产生一个错误消息，因为“f1”函数还没有定义。
  4. declare -f f1      # 这样也不会有帮助。
  5. f1                 # 仍然会产生一个错误消息。
  7. # 然而...
  10. f1 () {
  11.     echo "Calling function \"f2\" from within function \"f1\"."
  12.     f2 
  13. }
  15. f2 () {
  16.     echo "Function \"f2\"."
  17. }
  19. f1  #  在此之前，事实上函数“f2”是没有被调用的，
  20.     #+ 尽管在它定义之前被引用了。
  21.     #  这是可以的。
  22.     # 感谢, S.C.

extra 函数不能为空！

  1. #!/bin/bash
  2. # empty-functionn.sh
  4. empty () 
  5. {
  6. }
  8. exit 0  # 这里将不会退出!
  11. # $ sh empty-function.sh
  12. # empty-function.sh: line 6: syntax error near unexpected token `}'
  13. # empty-function.sh: line 6: `}'
  15. # $ echo $? 
  16. # 2
  18. # 请注意，只包含注释的函数也是空函数。
  20. func () 
  21. {
  22.     # 注释 1.
  23.     # 注释 2.
  24.     # 这仍然是一个空函数。
  25.     # 感谢, Mark Bova将这一点指出来。
  26. }
  27. # 结果会出现和上面一样的错误信息。
  29. # 然而 ...
  31. not_quite_empty ()
  32. {
  33.     illegal_command
  34. } #  一个包含这个函数的脚本将不会出错
  35.     #+ 只要这个函数没有被调用。
  36. not_empty ()
  37. {
  38.     :
  39. } # 包含一个 : (空命令符），这样是可以的。
  41. # 感谢, Dominick Geyer 和 Thiemo Kellner.

甚至，把一个函数嵌套在另外一个函数里也是可行的，尽管这并没有什么用。

  1. f1 () 
  2. {
  3.     f2 () # 嵌套函数
  4.     {
  5.         echo "Function \"f2\", inside \"f1\"."
  6.     }
  7. }
  9. f2  #  将会产生一个错误消息。
  10.     #  即使有一个前置的 "declare -f f2" 也不会有什么作用。
  12. echo
  14. f1  #  不会做任何事情，因为调用“f1”的时候，并不会自动调用“f2”。
  15.     #  现在，调用“f2”是可以的，
  16.     #+ 因为通过调用“f1”，它的定义现在已是可见的。
  18.     # 感谢, S.C.

函数定义可能出现在不太可能出现的地方，甚至出现在本应该是命令出现的地方。

  1. ls -l | foo() { echo "foo"; }  # 可行的，尽管没有什么作用。
  4. if [ "$USER" = bozo ]
  5. then
  6.     bozo_greet ()   # 函数定义嵌套在if/then的结构体中。
  7.     {
  8.         echo "Hello, Bozo."
  9.     }
  10. fi
  12. bozo_greet        # 只有Bozo用户工作，其它用户会得到一个错误消息。
  15. # 在某些场景中，像下面这些东西可能会很有用。
  16. NO_EXIT=1   # 将会激活下面的函数定义。
  18. [[ $NO_EXIT -eq 1 ]] && exit() { true; }     # 函数定义出现在“与列表”中。
  19. # 如果 $NO_EXIT 等于 1, 定义 "exit ()".
  20. # 通过把exit函数别名为“true”，这样把内置的exit命令给禁用了。
  22. exit  # 调用 "exit ()" 函数, 而不是内置的 "exit" 命令。
  25. # 或者，类似地:
  26. filename=file1
  28. [ -f "$filename" ] &&
  29. foo () { rm -f "$filename"; echo "File "$filename" deleted."; } ||
  30. foo () { echo "File "$filename" not found."; touch bar; }
  32. foo
  34. # 感谢, S.C. 和 Christopher Head

函数名字可以呈现各种奇怪的形式。

  1. _(){ for i in {1..10}; do echo -n "$FUNCNAME"; done; echo; }
  2. # ^^^         函数名字和圆括号之间没有空格。
  3. #             这并不会总是会正常工作。为什么呢？
  5. # 现在，我们来调用函数。
  6. _         # __________
  7. #           ^^^^^^^^^^   10 个下划线（10 倍的函数名字）！
  8. # 一个“假”的下划线也是一个可以接受的函数名字。
  10. # 事实上，一个分号也是一个可以接受的函数名字。
  12. :(){ echo ":"; }; :
  14. # 这有什么作用呢？
  15. # 这是一个狡诈的方式去混淆脚本中的代码。

也可以参见 Example A-56

小提示：当一个函数的不同版本出现在一个脚本中，会发生什么事情呢？

  1. #  正如Yan Chen 指出的那样,
  2. #  当一个函数被多次定义的时候，
  3. #  最后一个函数是被调用的那个。
  4. #  然而这并不是特别有用。
  6. func () 
  7. {
  8.     echo "First version of func ()."
  9. }
  11. func () 
  12. {
  13.     echo "Second version of func ()."
  14. }
  16. func   # 调用的是第二个 func () 函数版本。
  18. exit $?
  20. #  甚至，可能用函数去覆盖
  21. #+ 或者占用系统命令。
  22. #  当然，这并不是可取的。