当前位置: 首页 > 文档资料 > Shell 中文文档 >

第八章:操作符和相关主题

优质
小牛编辑
131浏览
2023-12-01

赋值

变量赋值
初始化或改变一个变量的值
=
通用的变量赋值操作符,可以用于数值和字符串的赋值
   1 var=27
   2 category=minerals  # "="字符后面不能加空白字符.

 不要把"="赋值操作符和=测试操作符搞混了。

   1 #    = 用于测试操作符
   2
   3 if [ "$string1" = "$string2" ]
   4 # if [ "X$string1" = "X$string2" ] 会更安全,
   5 # 它为了防止其中有一个字符串为空时产生错误信息.
   6 # (增加的"X"字符可以互相抵消.)
   7 then
   8    command
   9 fi

计算操作符

+
-
*
/
**
求幂
   1 # Bash在版本2.02引入了"**"求幂操作符.
   2
   3 let "z=5**3"
   4 echo "z = $z"   # z = 125
%
求模(它返回整数整除一个数后的余数)
 
bash$ 


expr 5 % 3

 
2

5/3 = 1 余 2

This operator finds use in, among other things, generating numbers within a specificrange (see Example 9-24and Example 9-27) and formatting program output (see Example 26-15and Example A-6). It can even be used to generate prime numbers, (see Example A-16). Modulo turns up surprisingly often in various numerical recipes.


例子 8-1. 最大公约数

   1 #!/bin/bash
   2 # gcd.sh: 最大公约数
   3 #         用Euclid运算法则
   4
   5 #  两个整数的"最大公约数"
   6 #+ 是能被这两个整数整除的大最整数.
   7
   8 #  Euclid运算法则采用逐次除法.
   9 #  每一次都重新赋值,
  10 #+ 被除数 <---  除数
  11 #+ 除数  <---  余数
  12 #+ 直到 余数 = 0.
  13 #+ 最后被传递的值中:最大公约数 = 被除数.
  14 #
  15 #  关于Euclid运算法则的讨论有一个出色的讨论,
  16 #  访问Jim Loy的网站, http://www.jimloy.com/number/euclids.htm.
  17
  18
  19 # ------------------------------------------------------
  20 # 参数检查
  21 ARGS=2
  22 E_BADARGS=65
  23
  24 if [ $# -ne "$ARGS" ]
  25 then
  26   echo "Usage: `basename $0` first-number second-number"
  27   exit $E_BADARGS
  28 fi
  29 # ------------------------------------------------------
  30
  31
  32 gcd ()
  33 {
  34
  35   dividend=$1                    #  随意赋值.
  36   divisor=$2                     #+ 这里在两个参数赋大的还是小的都没有关系.
  37                                  #  为什么?
  38
  39   remainder=1                    #  如果在循环中使用未初始化的变量,
  40                                  #+ 在循环中第一个传递值会使它返回一个错误信息
  41                                  #
  42
  43   until [ "$remainder" -eq 0 ]
  44   do
  45     let "remainder = $dividend % $divisor"
  46     dividend=$divisor            # 现在用最小的两个数字来重复.
  47     divisor=$remainder
  48   done                           # Euclid运算法则
  49
  50 }                                # 最后的$dividend变量值就是最大公约数.
  51
  52
  53 gcd $1 $2
  54
  55 echo; echo "GCD of $1 and $2 = $dividend"; echo
  56
  57
  58 # 练习:
  59 # --------
  60 #  检测命令行参数以确保它们是整数,
  61 #+ 如果不是整数则给出一个适当的错误信息并退出脚本.
  62
  63 exit 0

+=
"加-等(plus-equal)" (把原变量值增加一个常量并重新赋值给变量)

let "var += 5"会使变量var值加了5并把值赋给var.

-=
"(减-等)minus-equal" (把原变量值减少一个常量并重新赋值给变量)
*=
"(乘-等)times-equal" (把原变量值乘上一个常量并重新赋值给变量)

let "var *= 4"使变量var的值乘上4并把值赋给var.

/=
"(除-等)slash-equal" (把原变量值除以一个常量并重新赋值给变量)
%=
"(模-等)mod-equal" (把原变量值除以一个常量整除(译者注:即取模)并重新赋余数的值给变量)

计算操作符常常出现在exprlet命令的表达式中.


例子 8-2. 使用计算操作符

   1 #!/bin/bash
   2 # 用10种不同的方法计数到11.
   3
   4 n=1; echo -n "$n "
   5
   6 let "n = $n + 1"   # let "n = n + 1"也可以.
   7 echo -n "$n "
   8
   9
  10 : $((n = $n + 1))
  11 #  ":"是需要的,
  12 #+ 否则Bash会尝试把"$((n = $n + 1))"作为命令运行.
  13 echo -n "$n "
  14
  15 (( n = n + 1 ))
  16 #  上面是更简单的可行的办法.
  17 #  多谢David Lombard指出这一点.
  18 echo -n "$n "
  19
  20 n=$(($n + 1))
  21 echo -n "$n "
  22
  23 : $[ n = $n + 1 ]
  24 #  ":"是需要的,
  25 #+ 否则Bash会尝试把"$[ n = $n + 1 ]"作为命令运行.
  26 #  即使"n"被当作字符串来初始化也能工作.
  27 echo -n "$n "
  28
  29 n=$[ $n + 1 ]
  30 #  即使"n"被当作字符串来初始化也能工作.
  31 #* 应避免这种使用这种结构,因为它是被废弃并不可移植的.
  32 #  多谢Stephane Chazelas.
  33 echo -n "$n "
  34
  35 # 现在是C风格的增加操作.
  36 # 多谢Frank Wang指出这一点.
  37
  38 let "n++"          # let "++n"也可以.
  39 echo -n "$n "
  40
  41 (( n++ ))          # (( ++n )也可以.
  42 echo -n "$n "
  43
  44 : $(( n++ ))       # : $(( ++n ))也可以.
  45 echo -n "$n "
  46
  47 : $[ n++ ]         # : $[ ++n ]]也可以.
  48 echo -n "$n "
  49
  50 echo
  51
  52 exit 0

 Bash中的整数变量实际上是有符号的长整数(32位),它的范围在-2147483648至2147483647之间。如果有在此范围限制之外的操作将会得到一个错误的结果。

   1 a=2147483646
   2 echo "a = $a"      # a = 2147483646
   3 let "a+=1"         # 把变量"a"的值自增一.
   4 echo "a = $a"      # a = 2147483647
   5 let "a+=1"         # 再自增"a"一次,超过这个限制.
   6 echo "a = $a"      # a = -2147483648
   7                    #      错误 (溢出)

到2.05b版本为止,Bash支持64位的整数。

 Bash不能处理浮点计算。它会把含有小数点的数当成字符串。

   1 a=1.5
   2
   3 let "b = $a + 1.3"  # 错误
   4 # t2.sh: let: b = 1.5 + 1.3: syntax error in expression (error token is ".5 + 1.3") 意为表达式错误(错误的符号".5 + 1.3")
   5
   6 echo "b = $b"       # b=1

在脚本中用bc需要浮点计算或数学库函数的支持。

位操作符. 位操作符很少在脚本中使用。他们主要用于操作和测试从端口或sockets中读到的数据。“位运算”更多地用于编译型的语言,比如说C和C++,它们运行起来快地像飞。

位操作符

<< 位左移(每移一位相当乘以2)
<<= "位左移赋值"
let "var <<= 2"结果使var的二进制值左移了二位(相当于乘以4)
>> 位右移(每移一位相当除以2)
>>= "位右移赋值"(和<<=相反)
& 位与
&= "位于赋值"
| 位或
|= "位或赋值"
~ 位反
! 位非
^ 位或
^= "位或赋值"

逻辑操作符

&& 逻辑与
   1 if [ $condition1 ] && [ $condition2 ]
   2 # 等同于:  if [ $condition1 -a $condition2 ]
   3 # 如果condition1和condition2都为真则返回真...
   4
   5 if [[ $condition1 && $condition2 ]]    # Also works.
   6 # 注意&&操作不能在[ ... ]结构中使用.

 依据上下文,&&也可以在与列表(and list)连接命令中。

|| 逻辑或
   1 if [ $condition1 ] || [ $condition2 ]
   2 # 等同于:  if [ $condition1 -o $condition2 ]
   3 # 如果condition1和condition2有一个为真则返回真...
   4
   5 if [[ $condition1 || $condition2 ]]    # Also works.
   6 # 注意||操作不能在[ ... ]结构中使用.

 Bash测试由逻辑操作符连接起来的每一个表达式的退出状态


例子 8-3. 使用&&和||进行混合条件测试

   1 #!/bin/bash
   2
   3 a=24
   4 b=47
   5
   6 if [ "$a" -eq 24 ] && [ "$b" -eq 47 ]
   7 then
   8   echo "Test #1 succeeds."
   9 else
  10   echo "Test #1 fails."
  11 fi
  12
  13 # 错误:   if [ "$a" -eq 24 && "$b" -eq 47 ]
  14 #+         这会尝试执行' [ "$a" -eq 24 '
  15 #+         然后会因没找到匹配的']'而失败.
  16 #
  17 #  注意:  if [[ $a -eq 24 && $b -eq 24 ]]也可以.
  18 #  双方括号的if-test比
  19 #+ 单方括号的结构更灵活.
  20 #    (第17行和第6行的"&&"有不同的意思.)
  21 #    多谢Stephane Chazelas指出这一点.
  22
  23
  24 if [ "$a" -eq 98 ] || [ "$b" -eq 47 ]
  25 then
  26   echo "Test #2 succeeds."
  27 else
  28   echo "Test #2 fails."
  29 fi
  30
  31
  32 #  -a和-o选项提供
  33 #+ 混合条件测试另一个选择.
  34 #  多谢Patrick Callahan指出这一点.
  35
  36
  37 if [ "$a" -eq 24 -a "$b" -eq 47 ]
  38 then
  39   echo "Test #3 succeeds."
  40 else
  41   echo "Test #3 fails."
  42 fi
  43
  44
  45 if [ "$a" -eq 98 -o "$b" -eq 47 ]
  46 then
  47   echo "Test #4 succeeds."
  48 else
  49   echo "Test #4 fails."
  50 fi
  51
  52
  53 a=rhino
  54 b=crocodile
  55 if [ "$a" = rhino ] && [ "$b" = crocodile ]
  56 then
  57   echo "Test #5 succeeds."
  58 else
  59   echo "Test #5 fails."
  60 fi
  61
  62 exit 0

在算术计算的环境中,&&和||操作符也可以使用。

 
bash$ 


echo $(( 1 && 2 )) $((3 && 0)) $((4 || 0)) $((0 || 0))

 
1 0 1 0

杂合的其他操作符,

逗号操作符

逗号操作符连接两个或更多的算术操作。所有的操作都被求值(可能会有副作用),但只返回最后一个操作的结构.

   1 let "t1 = ((5 + 3, 7 - 1, 15 - 4))"
   2 echo "t1 = $t1"               # t1 = 11
   3
   4 let "t2 = ((a = 9, 15 / 3))"  # 初始化"a"并求"t2"的值.
   5 echo "t2 = $t2    a = $a"     # t2 = 5    a = 9

逗号操作符主要用在 for 循环 里. 参考 例子 10-12