第十三章 shell script

vi写的shell脚本默认是没有可执行权限的，必须要chmod u+x ...    后再运行

如果写完的shell脚本不能运行可能是以下原因：

1. 没有权限
   

2. 执行时没有加./  而且该shell脚本没有被加到PATH里面

3. shell 解释器路径乱了

执行：  /bin/sh -x ./xxxx.sh        -x会在执行shell脚本时在命令行中显示该脚本执行到哪里

$ #！/bin/sh    表示用shell子进程解释后面的shell脚本

$ #！/bin/csh    表示用cshell子进程解释后面的cshell脚本

通过source 执行shell脚本 可以使子进程里面的变量传到副进程里面，他们的变量共用一个内存空间。

chmod u+x ./color3.sh

./color3.sh argument1 argument2 argument3 .......argument10

分别对应$0(文件名)    $1    $2    $3    .......    ${10}                10及其10以后必须加{}才能被shell正确认识

$#    变量数量

$*    每个变量的变量内容，即所有变量的遍历

单引号和双引号最大的不同在于双引号仍然可以保留变量的内容，但单引号内仅能是一般字符，不会出现特殊符号

反单引号（`）     在`之内的内容会被先执行，而其执行出来的结果将作为外部的输入信息

---

第一个shell脚本，注意事项：

• 直接命令执行：

1 绝对路径执行： /xxx/xxx/xxx.sh

2 相对路径执行：./xxx.sh

3 变量“PATH”功能：将xxx.sh放在环境变量PATH指定的目录内，可以直接执行xxx.sh

• 以bash进程来执行：通过“bash xxx.sh”或“sh xxx.sh”来执行

• 第一个script

1 #!/bin/bash    第一行写，声明这个script使用的shell名称

2 #    程序内容说明

3 主要环境变量声明，为了程序运行稳定，可以将主要的环境变量在程序中重新赋值一遍

4 主程序

5 告知执行结果 exit 0              使用$?可以得到执行结果

---

shell script 的良好习惯：

在每个script的文件头要记录好：

• script的功能

• script的版本信息

• script的作业与联系方式

• script的历史记录

• script内较特殊的命令，使用“绝对路径”的方式来执行

• script执行时需要的环境变量预先声明与设置

使用vim来编辑shell script能够检查语法错误

---

script的执行方式区别（source，shscript，./script）：

• 直接执行的方式来执行script

使用无论是使用绝对路径/相对路径，或者是bash，sh来执行脚本，该script都会使用一个新的bash环境来执行程序，也就是说该script是在子进程的bash内执行的，而子进程内的各项变量或操作将会结束而不会回传到父进程中。

• 利用source来执行脚本：在父进程中执行

  
  

source filename 或者 . filename，source 可以用句号（.）来代替

---

利用test命令的测试功能：

1）判断表达式

　　if test  (表达式为真)

　　if test !表达式为假

　　test 表达式1 –a 表达式2                  两个表达式都为真

　　test 表达式1 –o 表达式2                 两个表达式有一个为真

2）判断字符串

　　test –n 字符串                               字符串的长度非零

　　test –z 字符串                               字符串的长度为零

　　test 字符串1＝字符串2                     字符串相等

　　test 字符串1！＝字符串2                  字符串不等

3）判断整数

　　test 整数1 –eq 整数2                        整数相等

　　test 整数1 –ge 整数2                        整数1大于等于整数2

　　test 整数1 –gt 整数2                         整数1大于整数2

　　test 整数1 –le 整数2                         整数1小于等于整数2

　　test 整数1 –lt 整数2                          整数1小于整数2

　　test 整数1 –ne 整数2                        整数1不等于整数2

4）判断文件

　　test  File1 –ef  File2                            两个文件具有同样的设备号和i结点号

　　test  File1 –nt  File2                            文件1比文件2 新

　　test  File1 –ot  File2                            文件1比文件2 旧

　　test –b File                                        文件存在并且是块设备文件

　　test –c File                                        文件存在并且是字符设备文件

　　test –d File                                        文件存在并且是目录

　　test –e File                                        文件存在

　　test –f File                                         文件存在并且是正规文件

　　test –g File                                        文件存在并且是设置了组ID

　　test –G File                                        文件存在并且属于有效组ID

　　test –h File                                        文件存在并且是一个符号链接（同-L）

　　test –k File                                        文件存在并且设置了sticky位

　　test –b File                                        文件存在并且是块设备文件

　　test –L File                                        文件存在并且是一个符号链接（同-h）

　　test –o File                                        文件存在并且属于有效用户ID

　　test –p File                                        文件存在并且是一个命名管道

　　test –r File                                        文件存在并且可读

　　test –s File                                        文件存在并且是一个套接字

　　test –t FD                                         文件描述符是在一个终端打开的

　　test –u File                                        文件存在并且设置了它的set-user-id位

　　test –w File                                       文件存在并且可写

　　test –x File                                        文件存在并且可执行

---

利用判断符号[]：

除了我们很喜欢使用的 test 之外，其实，我们还可以利用判断符号『 [ ] 』(就是中括号啦) 来进行数据的判断呢！ 举例来说，如果我想要知道 $HOME 这个变量是否为空的，可以这样做：

[Oracle@SOR_SYS]$ [ -z "$HOME" ] ; echo $?
1

使用中括号必须要特别注意，因为中括号用在很多地方，包括万用字节与正规表示法等等，所以如果要在 bash 的语法当中使用中括号作为 shell 的判断式时，必须要注意中括号的两端需要有空白字节来分隔喔！

[  "$HOME"  ==  "$MAIL"  ]

[□"$HOME"□==□"$MAIL"□]

 ↑         ↑          ↑            ↑

Tips:
你会发现在上面的判断式当中使用了两个等号『 == 』。其实在 bash 当中使用一个等号与两个等号的结果是一样的！ 不过在一般惯用程序的写法中，一个等号代表『变量的配置』，两个等号则是代表『逻辑判断 (是否之意)』。 由於我们在中括号内重点在於『判断』而非『配置变量』，因此鸟哥建议您还是使用两个等号较佳！

上面的例子在说明，两个字串 $HOME 与 $MAIL 是否相同的意思，相当於 test $HOME = $MAIL 的意思啦！ 而如果没有空白分隔，例如 [$HOME==$MAIL] 时，我们的 bash 就会显示错误信息了！这可要很注意啊！ 所以说，你最好要注意：

• 在中括号 [] 内的每个组件都需要有空白键来分隔；

• 在中括号内的变量，最好都以双引号括号起来；

• 在中括号内的常数，最好都以单或双引号括号起来。

为什么要这么麻烦啊？直接举例来说，假如我配置了 name="Zhu Ying" ，然后这样判定：

[oracle@99bill-as9 zy]$ name="Zhu Ying"
[oracle@99bill-as9 zy]$ [ $name == "Ying" ]
-bash: [: too many arguments

why？因为 $name 如果没有使用双引号刮起来，那么上面的判定式会变成：

[ Zhu Ying== "Ying" ]

上面肯定不对嘛！因为一个判断式仅能有两个数据的比对，上面 Zhu与 Ying还有 "Ying" 就有三个数据！ 这不是我们要的！我们要的应该是底下这个样子：

[ "Zhu Ying" == “Ying” ]

这可是差很多的喔！另外，中括号的使用方法与 test 几乎一模一样啊～ 只是中括号比较常用在条件判断式 if ..... then ..... fi 的情况中就是了。 好，那我们也使用中括号的判断来做一个小案例好了，案例配置如下：

1. 当运行一个程序的时候，这个程序会让使用者选择 Y 或 N

2. 如果使用者输入 Y 或 y 时，就显示『 OK, continue 』

3. 如果使用者输入 n 或 N 时，就显示『 Oh, interrupt ！』

4. 如果不是 Y/y/N/n 之内的其他字节，就显示『I don't know what your choice is 』

利用中括号、 && 与 || 来继续吧！

vi judgment.sh

#!/bin/bash
#This program shows the user's choice

read -p "Please input (Y/N):" yn
[ "$yn" == "Y" -o "$yn" == "y" ] && echo "OK,continue" && exit 0
[ "$yn" == "N" -o "$yn" == "n" ] && echo "Oh,interrupt!" && exit 0

echo  "I don't  know what  your  choice  is! " &&  exit  0

测试：

[oracle@SOR_SYS]$ sh judgment.sh 
Please input (Y/N):y
OK,continue
[oracle@SOR_SYS]$ sh judgment.sh 
Please input (Y/N):n
Oh,interrupt!
[oracle@SOR_SYS]$ sh judgment.sh 
Please input (Y/N):
I don't  know what  your  choice  is! 
[oracle@SOR_SYS$

由於输入正确 (Yes) 的方法有大小写之分，不论输入大写 Y 或小写 y 都是可以的，此时判断式内就得要有两个判断才行！ 由于是任何一个成立即可 (大小或小写的 y) ，所以这里使用 -o (或) 连结两个判断喔！ 很有趣吧！利用这个字串判别的方法，我们就可以很轻松的将使用者想要进行的工作分门别类呢！ 接下来，我们再来谈一些其他有的没有的东西吧！

======================================================

上面的脚本我们可以改成if。。。then判断语句

#!/bin/bash

read -p "Please input (Y/N)" yn

if [ "$yn" == "Y" ] || [ "$yn" == "y" ]; then
 echo "OK,continue!"
 exit 0
fi

if [ "$yn" == "N" ] || [ "$yn" == "n" ]; then
 echo "Oh,intrrupt!"
 exit 0
fi

echo "I don't know what your choice is " && exit 0

测试结果：

[oracle@SOR_SYS~]$ sh if-judg.sh 
Please input (Y/N)y
OK,continue!
[oracle@SOR_SYS~]]$ sh if-judg.sh
Please input (Y/N)n
Oh,intrrupt!
[oracle@SOR_SYS~]]$ sh if-judg.sh
Please input (Y/N)
I don't know what your choice is

---

shell script的默认变量（$0, $1...）:

在shell script 中已针对要传递的参数设定好了一些变量名称且可在脚本中直接使用!对应如下:

scriptname args1 args2 args3 args4 ...

$0              $1       $2     $3       $4

由上可知，$0 对应的是执行脚本名，其它的为对应的要传入的参数；但除了这些数字的变量外, 还有一些较为特殊的变量可以在 script 内使用：

$#:传递给脚本的参数数目

$?:上一段代码或脚本在shell中退出的情况，0表示正常，反之则反

$*:传递给脚本的所有参数组成的字符串

$@:同$*。但是如果给$@，$*加上双引号的话两者便不同了。对于$*，保持原义；对于$@，则表示获取整个参数列表，并将其分隔成不同的参数。

$$:当前脚本的PID

$!:上一个脚本或命令的PID

shift：造成参数变量号码偏移

---

Shell 中各种括号的作用：

一、小括号，圆括号（）

1、单小括号 ()

   ①命令组。括号中的命令将会新开一个子shell顺序执行，所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开，最后一个命令可以没有分号，各命令和括号之间不必有空格。

   ②命令替换。等同于`cmd`，shell扫描一遍命令行，发现了$(cmd)结构，便将$(cmd)中的cmd执行一次，得到其标准输出，再将此输出放到原来命令。有些shell不支持，如tcsh。

    ③用于初始化数组。如：array=(a b c d)

 2、双小括号 (( ))

    ①整数扩展。这种扩展计算是整数型的计算，不支持浮点型。((exp))结构扩展并计算一个算术表达式的值，如果表达式的结果为0，那么返回的退出状态码为1，或者 是"假"，而一个非零值的表达式所返回的退出状态码将为0，或者是"true"。若是逻辑判断，表达式exp为真则为1,假则为0。

    ②只要括号中的运算符、表达式符合C语言运算规则，都可用在$((exp))中，甚至是三目运算符。作不同进位(如二进制、八进制、十六进制)运算时，输出结果全都自动转化成了十进制。如：echo $((16#5f)) 结果为95 (16进位转十进制)

    ③单纯用 (( )) 也可重定义变量值，比如 a=5; ((a++)) 可将 $a 重定义为6

    ④常用于算术运算比较，双括号中的变量可以不使用$符号前缀。括号内支持多个表达式用逗号分开。 只要括号中的表达式符合C语言运算规则,比如可以直接使用for((i=0;i<5;i++)), 如果不使用双括号, 则为for i in `seq 0 4`或者for i in {0..4}。再如可以直接使用if (($i<5)), 如果不使用双括号, 则为if [ $i -lt 5 ]。

二、中括号，方括号[]

1、单中括号 []

    ①bash 的内部命令，[和test是等同的。如果我们不用绝对路径指明，通常我们用的都是bash自带的命令。if/test结构中的左中括号是调用test的命令标识，右中括号是关闭条件判断的。这个命令把它的参数作为比较表达式或者作为文件测试，并且根据比较的结果来返回一个退出状态码。if/test结构中并不是必须右中括号，但是新版的Bash中要求必须这样。

    ②Test和[]中可用的比较运算符只有==和!=，两者都是用于字符串比较的，不可用于整数比较，整数比较只能使用-eq，-gt这种形式。无论是字符串比较还是整数比较都不支持大于号小于号。如果实在想用，对于字符串比较可以使用转义形式，如果比较"ab"和"bc"：[ ab \< bc ]，结果为真，也就是返回状态为0。[ ]中的逻辑与和逻辑或使用-a 和-o 表示。

    ③字符范围。用作正则表达式的一部分，描述一个匹配的字符范围。作为test用途的中括号内不能使用正则。

    ④在一个array 结构的上下文中，中括号用来引用数组中每个元素的编号。

2、双中括号[[ ]]

    ①[[是 bash 程序语言的关键字。并不是一个命令，[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割，但是会发生参数扩展和命令替换。

    ②支持字符串的模式匹配，使用=~操作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式，而不仅仅是一个字符串，比如[[ hello == hell? ]]，结果为真。[[ ]] 中匹配字符串或通配符，不需要引号。

    ③使用[[ ... ]]条件判断结构，而不是[ ... ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。

    ④bash把双中括号中的表达式看作一个单独的元素，并返回一个退出状态码。
例子：

if  ($i<5)
if  [ $i -lt 5 ]
if  [ $a - ne  1 -a $a != 2 ]
if  [ $a - ne  1] && [ $a != 2 ]
if  [[ $a != 1 && $a != 2 ]]

for  i  in  $( seq  0 4); do  echo  $i; done
for  i  in  ` seq  0 4`; do  echo  $i; done
for  ((i=0;i<5;i++)); do  echo  $i; done
for  i  in  {0..4}; do  echo  $i; done

三、大括号、花括号 {}

1、常规用法

    ①大括号拓展。(通配(globbing))将对大括号中的文件名做扩展。在大括号中，不允许有空白，除非这个空白被引用或转义。第一种：对大括号中的以逗号分割的文件列表进行拓展。如 touch {a,b}.txt 结果为a.txt b.txt。第二种：对大括号中以点点（..）分割的顺序文件列表起拓展作用，如：touch {a..d}.txt 结果为a.txt b.txt c.txt d.txt

# ls {ex1,ex2}.sh
ex1.sh  ex2.sh
# ls {ex{1..3},ex4}.sh
ex1.sh  ex2.sh  ex3.sh  ex4.sh
# ls {ex[1-3],ex4}.sh
ex1.sh  ex2.sh  ex3.sh  ex4.sh

    ②代码块，又被称为内部组，这个结构事实上创建了一个匿名函数 。与小括号中的命令不同，大括号内的命令不会新开一个子shell运行，即脚本余下部分仍可使用括号内变量。括号内的命令间用分号隔开，最后一个也必须有分号。{}的第一个命令和左括号之间必须要有一个空格。

2、几种特殊的替换结构

${var:-string},${var:+string},${var:=string},${var:?string}

      ①${var:-string}和${var:=string}:若变量var为空，则用在命令行中用string来替换${var:-string}，否则变量var不为空时，则用变量var的值来替换${var:-string}；对于${var:=string}的替换规则和${var:-string}是一样的，所不同之处是${var:=string}若var为空时，用string替换${var:=string}的同时，把string赋给变量var： ${var:=string}很常用的一种用法是，判断某个变量是否赋值，没有的话则给它赋上一个默认值。
      ② ${var:+string}的替换规则和上面的相反，即只有当var不是空的时候才替换成string，若var为空时则不替换或者说是替换成变量 var的值，即空值。(因为变量var此时为空，所以这两种说法是等价的) 
      ③${var:?string}替换规则为：若变量var不为空，则用变量var的值来替换${var:?string}；若变量var为空，则把string输出到标准错误中，并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。
      补充扩展：在上面这五种替换结构中string不一定是常值的，可用另外一个变量的值或是一种命令的输出。

3、四种模式匹配替换结构

模式匹配记忆方法：
# 是去掉左边(在键盘上#在$之左边)
% 是去掉右边(在键盘上%在$之右边)
#和%中的单一符号是最小匹配，两个相同符号是最大匹配。

${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

     第一种模式：${variable%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最短的匹配模式
     第二种模式： ${variable%%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最长的匹配模式
     第三种模式：${variable#pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern开始，如果是，就从命令行把variable中的内容去掉左边最短的匹配模式
     第四种模式： ${variable##pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最长的匹配模式
     这四种模式中都不会改变variable的值，其中，只有在pattern中使用了*匹配符号时，%和%%，#和##才有区别。结构中的pattern支持通配符，*表示零个或多个任意字符，?表示仅与一个任意字符匹配，[...]表示匹配中括号里面的字符，[!...]表示不匹配中括号里面的字符。

# var=testcase
# echo $var
testcase
# echo ${var%s*e}
testca
# echo $var
testcase
# echo ${var%%s*e}
te
# echo ${var#?e}
stcase
# echo ${var##?e}
stcase
# echo ${var##*e}

# echo ${var##*s}
e
# echo ${var##test}
case

4、字符串提取和替换

${var:num},${var:num1:num2},${var/pattern/pattern},${var//pattern/pattern}

       第一种模式：${var:num}，这种模式时，shell在var中提取第num个字符到末尾的所有字符。若num为正数，从左边0处开始；若num为负数，从右边开始提取字串，但必须使用在冒号后面加空格或一个数字或整个num加上括号，如${var: -2}、${var:1-3}或${var:(-2)}。         
        第二种模式：${var:num1:num2}，num1是位置，num2是长度。表示从$var字符串的第$num1个位置开始提取长度为$num2的子串。不能为负数。
       第三种模式：${var/pattern/pattern}表示将var字符串的第一个匹配的pattern替换为另一个pattern。。         
       第四种模式：${var//pattern/pattern}表示将var字符串中的所有能匹配的pattern替换为另一个pattern。

[root@centos ~] # var=/home/centos
[root@centos ~] # echo $var
/home/centos
[root@centos ~] # echo ${var:5}
/centos
[root@centos ~] # echo ${var: -6}
centos
[root@centos ~] # echo ${var:(-6)}
centos
[root@centos ~] # echo ${var:1:4}
home
[root@centos ~] # echo ${var/o/h}
/hhme/centos
[root@centos ~] # echo ${var//o/h}
/hhme/cenths

四、符号$后的括号

（1）${a} 变量a的值, 在不引起歧义的情况下可以省略大括号。

（2）$(cmd) 命令替换，和`cmd`效果相同，结果为shell命令cmd的输，过某些Shell版本不支持$()形式的命令替换, 如tcsh。

（3）$((expression)) 和`exprexpression`效果相同, 计算数学表达式exp的数值, 其中exp只要符合C语言的运算规则即可, 甚至三目运算符和逻辑表达式都可以计算。

五、使用

1、多条命令执行

（1）单小括号，(cmd1;cmd2;cmd3) 新开一个子shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后可以没有分号。

（2）单大括号，{ cmd1;cmd2;cmd3;} 在当前shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后必须有分号, 第一条命令和左括号之间必须用空格隔开。
对{}和()而言, 括号中的重定向符只影响该条命令， 而括号外的重定向符影响到括号中的所有命令。

---

shell script 的追踪和调试：

sh [-nvx] scripts.sh

参数：

-n：不要执行script，仅查询语法的问题

-v：在执行script前，先将script的内容输出到屏幕上

-x：将使用到的script内容显示到屏幕上，这是很有用的参数！