括号的使用总结

单括号、双括号、单方括号、双方括号

  • 单括号 () 没作用；
  • $() 是命令替换；
  • (()) 可以进行算数运算，c 语言风格的 for 命令；
  • 单方括号 [] 是测试命令，需要有空格；
  • $[] 是数学运算，作用与 $(()) 一样，后者更常用；
  • $[[]] 是高级的字符串运算，需要有空格；

数组

对其它 shell 而言，数组变量的可移植性并不好，应尽量减少使用。下面的例子在 zsh 中运行，结果就不一样。

  1. #!/bin/bash
  3. # 定义数组
  4. myarray=(one two three four)
  6. # one
  7. echo $myarray
  9. # one
  10. echo ${myarray[0]}
  12. # one two three four
  13. echo ${myarray[*]}
  15. myarray[2]=seven
  17. unset myarray[2]
  19. # one two four
  20. echo ${myarray[*]}
  22. # 这个位置是空的
  23. echo ${myarray[2]}
  25. # four
  26. echo ${myarray[3]}
  28. unset myarray
  30. # 空的
  31. echo ${myarray[*]}

函数

创建函数

  1. function name {
  2.     commands
  3. }
  5. # 或者
  7. name() {
  8.     commands
  9. }

注意，函数必需先定义，然后才能使用。

使用举例：

  1. #!/bin/bash
  3. # 使用函数
  5. function func1 {
  6.     echo "This is an example of a function"
  7. }
  9. count=1
  10. while [ $count -le 5 ]
  11. do
  12.     func1
  13.     count=$((count+1))
  14. done
  16. # 会覆盖上面的定义
  17. function func1 {
  18.     echo "This is another example"
  19. }
  21. func1

返回值

有三种方式获取：

第一，默认最后一个命令的退出状态码；

  1. #!/bin/bash
  2. # 不推荐使用
  3. func1() {
  4.     echo "trying to display a non existent file"
  5.     ls -l badfile
  6. }
  8. func1
  9. echo "The exit status is: $?"

第二，使用 return 命令；

  1. #!/bin/bash
  2. # 使用 return 命令
  3. # 有两点需要注意：
  4. # 1. 函数一结束就取返回值
  5. # 2. 退出状态码必须是 0～255
  6. function db1 {
  7.     read -p "Enter a value: " value
  8.     echo "doubling the value"
  9.     return $((value * 2))
  10. }
  11. db1
  12. echo "The new value is $?"

第三，使用函数输出，推荐使用；

  1. #!/bin/bash
  3. function db1 {
  4.     read -p "Enter a value: " value
  5.     echo $((value * 2))
  6. }
  7. # 命令替换
  8. result=$(db1)
  9. echo "The new value is $result"

向函数传递参数

同脚本获取命令行参数一样，函数也使用 $1 … $9 … 获取参数。$0 是函数名。

  1. #!/bin/bash
  3. # 向函数传递参数
  5. function addem {
  6.     if [ $# -eq 0 ] || [ $# -gt 2 ]
  7.     then
  8.         echo -1
  9.     elif [ $# -eq 1 ]
  10.     then
  11.         echo $(($1 + $1))
  12.     else
  13.         echo $(($1 + $2))
  14.     fi
  15. }
  17. echo "Adding 10 and 15: $(addem 10 15)"

在函数中使用变量

默认情况下，在脚本中定义的变量都是全局变量，在函数内外都可以使用。

  1. #!/bin/bash
  3. # 默认都是全局变量
  5. function db1 {
  6.     value=$((value * 2))
  7. }
  9. read -p "Enter a value: " value
  10. db1
  11. echo The new value is: $value

声明局部变量，在变量前加上 local 关键字。

  1. #!/bin/bash
  3. # 定义局部变量
  5. function func1 {
  6.     local temp=$((value+5))
  7.     result=$((temp * 2))
  8. }
  10. temp=4
  11. value=6
  13. func1
  14. # 22
  15. echo "The result is $result"
  16. # 4
  17. echo "The temp value is $temp"

向函数传递数组

  1. #!/bin/bash
  3. # 给函数传递数组
  5. wrong() {
  6.     echo "The parameters are: $@"
  7.     thisarray=$1
  8.     echo "The received array is ${thisarray[*]}"
  9. }
  11. myarray=(1 2 3 4 5)
  12. echo "The origin array is ${myarray[*]}"
  13. # 这种传递数组的方式不行
  14. wrong $myarray
  15. echo
  17. # 正确使用方法
  18. right() {
  19.     echo "The parameters are: $@"
  20.     # 在内部创建一个新的变量
  21.     newarray=($(echo $@))
  22.     echo "The received array is ${newarray[*]}"
  23. }
  25. right ${myarray[*]}
  27. # 结果是
  28. # The origin array is 1 2 3 4 5
  29. # The parameters are: 1
  30. # The received array is 1
  31. # 
  32. # The parameters are: 1 2 3 4 5
  33. # The received array is 1 2 3 4 5

函数返回数组

递归

  1. #!/bin/bash
  3. # 递归
  4. # 计算一个数的阶乘
  6. function factorial {
  7.     if [ $1 -eq 1 ]
  8.     then
  9.         echo 1
  10.     else
  11.         local temp=$(($1 - 1))
  12.         local result
  13.         result=$(factorial $temp)
  14.         echo $((result * $1))
  15.     fi
  16. }
  18. read -p "Enter value: " value
  19. result=$(factorial $value)
  20. echo "The factorial of $value is: $result"

创建库

创建库文件，然后在多个脚本中引用，方便函数重用。

示例库函数：

  1. cat myfuncs 
  2. # my script functions
  4. function addem {
  5.     echo $(($1 + $2))
  6. }
  8. function multem {
  9.     echo $(($1 * $2))
  10. }
  12. function divem {
  13.     if [ $2 -ne 0 ]
  14.     then
  15.         echo $(($1 / $2))
  16.     else
  17.         echo -1
  18.     fi
  19. }

和环境变量一样，shell 函数仅在定义它的 shell 会话内有效。在命令行中运行 myfuncs 脚本，shell 会创建一个新的 shell 运行它，之后在当前的 shell 中也无法使用它：

  1. $ ./myfuncs 
  2. $ addem 1 2
  3. bash: addem: command not found

source 命令会在当前 shell 上下文中执行命令，而不是创建一个新 shell。source 命令有一个快捷的别名，称作点操作符（dot operator）。

  1. #!/bin/bash
  2. # 使用库函数
  4. # 这种方式不正确
  5. # ./myfunc
  7. # 使用这种方式执行
  8. . ./myfuncs
  10. result=$(addem 10 15)
  11. echo "The result is $result"

在命令行上使用库函数

在命令行上创建函数：

  1. $ function divem { echo $(($1 / $2));}
  2. $ divem 5 2
  3. 2
  5. $ function multem {
  6. > echo $(($1 * $2))
  7. > }
  8. $ multem 2 5
  9. 10

在 .bashrc 中定义函数，或者使用点操作符加载库函数。这样就可以在 shell 中是使用了。