shell的进阶下

12.1 条件判断式

只要讲到『程序』的话，那么条件判断式，亦即是『 if then 』这种判别式肯定一定要学习的! 因为很多时候，我们都必须要依据某些数据来判断程序该如何进行。举例来说，我们在上头的 ans_yn.sh 讨论输入响应的范例中不是有练习当使用者输入 Y/N 时，必须要执行不同的讯息输出吗?简单的方式可以利用 && 与 || ，但如果我还想要执行一堆指令呢?那真的得要 if then 来帮忙!

12.1.1 if .... then的使用

这个 if .... then 是最常见的条件判断式了~简单的说，就是当符合某个条件判断的时候，就予以进行某项工作就是了。这个 if ... then 的判断还有多层次的情况!我们分别介绍如下:

单层、简单条件判断式

如果你只有一个判断式要进行，那么我们可以简单的这样看:

if [ 条件判断式]; then
    档条件成立的时候,可以进行的指令工作内容,
fi    <--将if反过来写,就成为fi,及结束if之意

至于条件判断式的判断方法，与前一小节的介绍相同啊!
较特别的是，如果我有多个条件要判别时，除了 ans_yn.sh 那个案例所写的，也就是『将多个条件写入一个中括号内的情况』之外，我还可以有多个中括号来隔开喔!而括号与括号之间，则以 && 或 || 来隔开，他们的意义是:

&& 代表 AND;
|| 代表 or;

所以，在使用中括号的判断式中， && 及 || 就与指令下达的状态不同了。举例来说， ans_yn.sh 里面的判断式可以这样修改:

[ "${yn}" == "Y" -o "${yn}" == "y"]
#可以写成
[ "${yn}" == "Y" ] || [ "${yn}" == "y"]

之所以这样改，很多人是习惯问题!很多人则是喜欢一个中括号仅有一个判别式的原因。好了，现在我们来将 ans_yn.sh 这个脚本修改成为 if ... then 的样式来看看:

[xiaoqi@study ~]$ vim ans_yn-2.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin 
export PATH

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

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

if [ "${yn}" == "N" ] || [ "${yn}" == "n" ]; then 
    echo "Oh,interrupt"
    exit 0
fi

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

不过，由这个例子看起来，似乎也没有什么了不起吧?原本的 ans_yn.sh 还比较简单呢~ 但是如果以逻辑概念来看，其实上面的范例中，我们使用了两个条件判断呢!明明仅有一个 ${yn} 的变量，为何需要进行两次比对呢? 此时，多重条件判断就能够来测试测试

12.1.2 if .... else的使用

在同一个数据的判断中，如果该数据需要进行多种不同的判断时，应该怎么作?举例来说，上面的 ans_yn.sh 脚本中，我们只要进行一次 ${yn} 的判断就好 (仅进行一次 if )，不想要作多次 if 的判断。此时你就得要知道底下的语法了:

#一个条件判断，分成功进行与失败进行 (else)
if [ 条件判断式 ]; then
    当条件判断式成立时，可以进行的指令工作内容;
else 
    当条件判断式不成立时，可以进行的指令工作内容;
fi

如果考虑更复杂的情况，则可以使用这个语法:

#多个条件判断 (if ... elif ... elif ... else) 分多种不同情况执行
if [ 条件判断式一 ]; then
    当条件判断式一成立时，可以进行的指令工作内容;
elif [ 条件判断式二 ]; then 
    当条件判断式二成立时，可以进行的指令工作内容;
else 
    当条件判断式一与二均不成立时，可以进行的指令工作内容;
fi

你得要注意的是， elif 也是个判断式，因此出现 elif 后面都要接 then 来处理!但是 else 已经是最后的没有成立的结果了，所以 else 后面并没有 then

我们来将 ans_yn-2.sh 改写成这样:

[xiaoqi@study ~]$ vim ans_yn-3.sh 
 #!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin 
export PATH

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

if [ "${yn}" == "Y" ] || [ "${yn}" == "y" ]; then
    echo "OK,interrupt!"
elif [ "${yn}" == "N" ] || [ "${yn}" == "n" ];then
    echo "Oh,interropt!"
else
    echo "I don't know what your choice is"
fi

是否程序变得很简单，而且依序判断，可以避免掉重复判断的状况，这样真的很容易设计程序!

好了，让我们再来进行另外一个案例的设计。一般来说，如果你不希望用户由键盘输入额外的数据时，可以使用上一节提到的参数功能 ($1)!让用户在下达指令时就将参数带进去! 现在我们想让用户输入『 hello 』这个关键词时，利用参数的方法可以这样依序设计:

判断 $1 是否为 hello，如果是的话，就显示 "Hello, how are you ?";
如果没有加任何参数，就提示使用者必须要使用的参数下达法;
而如果加入的参数不是 hello ，就提醒使用者仅能使用 hello 为参数。

实现代码:

[xiaoqi@study ~]$ vim hello-2.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

if [ "${1}" == "hello"  ]; then
    echo "Hello,How are you!"
elif [ "${1}" == "" ]; then
    echo "You MUST input parameters, ex> {${0} someword}"
else 
    echo "The only parameter is 'hello', ex> {${0} hello}"
fi

然后你可以执行这支程序，分别在 $1 的位置输入 hello, 没有输入与随意输入，就可以看到不同的输出!

我们在第十章已经学会了 grep 这个好用的玩意儿，那么多学一个叫做 netstat 的指令，这个指令可以查询到目前主机有开启的网络服务端口口 (service ports)，相关的功能我们会在服务器架设篇继续介绍，这里你只要知道，我可以利用『 netstat -tuln 』来取得目前主机有启动的服务，而且取得的信息有点像这样:

[xiaoqi@study ~]$ netstat -lunt
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State      
tcp        0      0 192.168.122.1:53        0.0.0.0:*               LISTEN     
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:25            0.0.0.0:*               LISTEN     
tcp6       0      0 :::22                   :::*                    LISTEN     
tcp6       0      0 ::1:631                 :::*                    LISTEN     
tcp6       0      0 ::1:25                  :::*                    LISTEN     
udp        0      0 0.0.0.0:5996            0.0.0.0:*                          
udp        0      0 0.0.0.0:55150           0.0.0.0:*                          
udp        0      0 192.168.122.1:53        0.0.0.0:*                          
udp        0      0 0.0.0.0:67              0.0.0.0:*                          
udp        0      0 0.0.0.0:68              0.0.0.0:*                          
udp        0      0 0.0.0.0:48345           0.0.0.0:*                          
udp        0      0 0.0.0.0:5353            0.0.0.0:*                          
udp        0      0 127.0.0.1:323           0.0.0.0:*                          
udp6       0      0 :::5996                 :::*                               
udp6       0      0 :::48280                :::*                               
udp6       0      0 ::1:323                 :::*                               
udp6       0      0 fe80::20c:29ff:fe61:546 :::*     
#封包格式               本地IP                      远程IP:端口                是否监听

上面的重点是『Local Address (本地主机的 IP 与端口口对应)』那个字段，他代表的是本机所启动的网络服务! IP 的部分说明的是该服务位于那个接口上，若为 127.0.0.1 则是仅针对本机开放，若是 0.0.0.0 或 ::: 则代表对整个 Internet 开放,每个端口 (port) 都有其特定的网络服务，几个常见的 port 与相关网络服务的关系是:

80: WWW
22: ssh
21: ftp
25: mail
111: RPC(远程过程调用)
631: CUPS(打印服务功能)

假设我的主机有兴趣要侦测的是比较常见的 port 21, 22, 25 及 80 时，那我如何透过 netstat 去侦测我的主机是否有开启这四个主要的网络服务端口口呢?由于每个服务的关键词都是接在冒号『 : 』后面，所以可以藉由撷取类似『 :80 』来侦测的!那我就可以简单的这样去写这个程序喔:

[xiaoqi@study ~]$ vim netstat.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin 
export PATH

echo "Now, I will detect your Linux server's services!"
echo -e "The www, ftp, ssh, and mail(smtp) will be detect! \n"

testfile=/dev/shm/netstat_checking.txt
netstat -tuln > ${testfile} # 先转存数据到内存当中!不用一直执行 netstat

testing=$(grep ":80 " ${testfile}) # 侦测看 port 80 在否?
if [ "${testing}" != ""  ]; then
    echo "WW is running in your system."
fi

testing=$(grep ":22 " ${testing}) # 侦测看 port 22 在否?
if [ "${testing}" != ""  ]; then
    echo "SSH is running in your system."
fi

testing=$(grep ":21 " ${testfile}) # 侦测看 port 21 在否? 
if [ "${testing}" != "" ]; then
    echo "FTP is running in your system."
fi

testing=$(grep ":25 " ${testfile}) # 侦测看 port 25 在否? 
if [ "${testing}" != "" ]; then
    echo "Mail is running in your system."
fi

实际执行这个程序你就可以看到你的主机有没有启动这些服务!
/dev/shm/是linux下内存文件夹，不再硬盘中创建数据而是在内存里

12.1.3 case .... esac的使用

上个小节提到的『 if .... then .... fi 』对于变量的判断是以『比对』的方式来分辨的，如果符合状态就进行某些行为，并且透过较多层次 (就是 elif ...) 的方式来进行多个变量的程序代码编写!

如 hello-2.sh 那个小程序，就是用这样的方式来撰写的啰。好，那么万一我有多个既定的变量内容，例如 hello-2.sh 当中，我所需要的变量就是 "hello"及空字符串两个，那么我只要针对这两个变量来设定状况就好了，那么可以使用什么方式来设计呢?就用 case ... in .... esac !

语法如下:

case $变量名称 in        <--键词为 case ，还有变数前有钱字号
    "第一个变量内容") <--每个变量内容建议用双引号括起来，关键词则为小括号 )
        程序段
    ;;                <--每个类别结尾使用两个连续的分号来处理!
    "第二个变量内容")
        程序段
    ;;
    *)                <--最后一个变量内容都会用 * 来代表所有其他值
        不包含第一个变量内容与第二个变量内容的其他程序执行段
        exit 1
    ;;
esac                <--最终的 case 结尾!『反过来写』思考一下!

要注意的是，这个语法以 case (实际案例之意) 为开头，结尾自然就是将 case 的英文反过来写!就成为 esac !另外，每一个变量内容的程序段最后都需要两个分号 (;;) 来代表该程序段落的结束，这挺重要的喔!至于为何需要有 * 这个变量内容在最后呢?这是因为，如果用户不是输入变量内容一或二时，我们可以告知用户相关的信息!

我们拿 hello-2.sh 的案例来修改一下，他应该会变成这样喔:

[xiaoqi@study ~]$ cat hell-3.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin 
export PATH

case ${1} in
  "hello")
           echo "Hello, how are you ?"
        ;; 
  "")
           echo "You MUST input parameters, ex> {${0} someword}"
        ;;
  *)
          echo "Usage ${0} {hello}"
        ;;
esac

在上面这个 hello-3.sh 的案例当中，如果你输入『 sh hello-3.sh test 』来执行，那么屏幕上就会出现『Usage hello-3.sh {hello}』的字样，告知执行者仅能够使用 hello !
这样的方式对于需要某些固定字符串来执行的变量内容就显的更加的方便!这种方式真的要熟悉掌握!
这是因为早期系统的很多服务的启动 scripts 都是使用这种写法的 (CentOS 6.x 以前)。虽然 CentOS 7 已经使用 systemd，不过仍有数个服务是放在 /etc/init.d/ 目录下喔!例如有个名为 netconsole 的服务在该目录下，那么你想要重新启动该服务，是可以这样做的 (请注意，要成功执行，还是得要具有 root身份才行!一般账号能执行，但不会成功!):

/etc/init.d/netconsole restart

重点是那个 restart 啦!如果你使用『 less /etc/init.d/netconsole 』去查阅一下，就会看到他使用的是 case 语法，并且会规定某些既定的变量内容，你可以直接下达 /etc/init.d/netconsole ，该 script 就会告知你有哪些后续接的变量可以使用!

一般来说，使用『 case $变量 in 』这个语法中，当中的那个『 $变量』大致有两种取得的方式:

直接下达式:例如上面提到的，利用『 script.sh variable 』的方式来直接给予 $1 这个变量的内容，这也是在 /etc/init.d 目录下大多数程序的设计方式。
交互式:透过 read 这个指令来让用户输入变量的内容。

[xiaoqi@study ~]$ vim show123.sh
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin 
export PATH

case ${1} in
    "one")
        echo "Your choice is ONE"
        ;;
    "two")
        echo "Your choice is TWO"
        ;;
    "three")
        echo "Your choice is THREE"
        ;;
    *)
        echo "Usage ${0} {one|two|three}"
        ;;
esac

此时，你可以使用『 sh show123.sh two 』的方式来下达指令，就可以收到相对应的响应了。上面使用的是直接下达的方式，

12.2 function的使用

什么是『函数 (function)』功能啊?简单的说，其实，函数可以在 shell script 当中做出一个类似自定义执行指令的东西，最大的功能是，可以简化我们很多的程序代码~举例来说，上面的 show123.sh 当中，每个输入结果 one, two, three 其实输出的内容都一样啊~那么我就可以使用 function 来简化了! function 的语法是这样的:

function fname(){
    程序段
}

那个 fname 就是我们的自定义的执行指令名称~而程序段就是我们要他执行的内容了。要注意的是，因为 shell script 的执行方式是由上而下，由左而右，因此在 shell script 当中的 function 的设定一定要在程序的最前面，这样才能够在执行时被找到可用的程序段 (这一点与传统程序语言差异相当大!)

我们将 show123.sh 改写一下，自定义一个名为 printit 的函数来使用喔:

[xiaoqi@study ~]$ vim show123-2.sh
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin 
export PATH

function printit(){
    echo -n "Your choice is " # 加上 -n 可以不断行继续在同一行显示
}

echo "This program will print your selection !"

case ${1} in
    "one")
        printit; echo ${1} | tr 'a-z' 'A-Z' # 将参数做大小写转换!
        ;;
    "two")
        printit; echo ${1} | tr 'a-z' 'A-Z' # 将参数做大小写转换!
        ;;
    "three")
        printit; echo ${1} | tr 'a-z' 'A-Z' # 将参数做大小写转换!
        ;;
    *)
        echo "Usage ${0} {one|two|three}"
        ;;
esac

以上面的例子来说，写了一个函数名称为 printit ，所以，在后续的程序段里面，只要执行 printit 的话，就表示我的 shell script 要去执行『 function printit .... 』里面的那几个程序段

另外， function 也是拥有内建变量的~他的内建变量与 shell script 很类似，函数名称代表示 $0 ，而后续接的变量也是以 $1, $2... 来取代.这里很容易搞错,因为『 function fname() { 程序段 } 』内的 $0, $1... 等等与 shell script 的 $0 是不同的。

以上面 show123-2.sh 来说，假如我下达: 『 sh show123-2.sh one 』这表示在 shell script 内的 $1 为 "one" 这个字符串。但是在 printit() 内的 $1 则与这个 one 无关。我们将上面的例子再次的改写一下:

[xiaoqi@study ~]$ cat show123-3.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

function printit(){
    echo "You choice is ${1}" #这个 $1 必须要参考底下指令的下达
}

echo "This program will print your selection"
case ${1} in
    "one")
        printit 1    #请注意， printit 指令后面还有接参数!
        ;;
    "two")
        printit 2
        ;;
    "three")
        printit 3
        ;;
    *)
        echo "Usage ${0} {one|two|three}"
        ;;
esac

在上面的例子当中，如果你输入『 sh show123-3.sh one 』就会出现『 Your choice is 1 』的字样~ 为什么是 1 呢?因为在程序段落当中，我们是写了『 printit 1 』那个 1 就会成为 function 当中的 $1 ~

12.3循环的使用

除了 if...then...fi 这种条件判断式之外，循环可能是程序当中最重要的一环了~ 循环可以不断的执行某个程序段落，直到用户设定的条件达成为止。所以，重点是那个『条件的达成』是什么。除了这种依据判断式达成与否的不定循环之外，还有另外一种已经固定要跑多少次的循环形态，可称为固定循环的形态呢!底下我们就来谈一谈:

while do done, until do done (不定循环)

一般来说，不定循环最常见的就是底下这两种状态了:

while [ condition ] <--中括号的状态就是判断式
do    <--do是循环的开始
    程序段落
done    <--done是循环的结束

while 的中文是『当....时』，所以，这种方式说的是『当 condition 条件成立时，就进行循环，直到 condition 的条件不成立才停止』的意思。

还有另外一种不定循环的方式:

until [ condition ]
do
    程序段落
done

这种方式恰恰与 while 相反，它说的是『当 condition 条件成立时，就终止循环，否则就持续进行循环的程序段。』

我们以 while 来做个简单的练习好了。假设我要让使用者输入 yes 或者是 YES 才结束程序的执行，否则就一直进行告知用户输入字符串。

[xiaoqi@study ~]$ vim  yes_to_stop.sh
#/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

while [ "${yn}" != "yes" -a "${yn}" != "YES"  ]
do
    read -p "Please input yes/YES to stop this program: " yn
done
echo "OK! you input the correct answer."

上面这个例题的说明是『当 ${yn} 这个变数不是 "yes" 且 ${yn} 也不是 "YES" 时，才进行循环内的程序。』而如果 ${yn} 是 "yes" 或 "YES" 时，就会离开循环.

那如果使用 until 呢?他的条件会变成这样:

[xiaoqi@study ~]$ cat yes_to_stop-2.sh   
#/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

until [ "${yn}" != "yes" -o "${yn}" != "YES"  ]
do
    read -p "Please input yes/YES to stop this program: " yn
done
echo "OK! you input the correct answer."

如果我想要计算 1+2+3+....+100 这个数据呢? 利用循环啊~他是这样的:

[xiaoqi@study ~]$ vim cal_1_100.sh
#!/bin/bash
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

s=0 #加数
i=0 #累加数

while [ "${i}" != "100" ]
do
    i=$(($i+1)) 
    s=$(($s+$i)) 
done
echo " The result of '1=2=3=...+100' is --> $s"

当你执行了『 sh cal_1_100.sh 』之后，就可以得到 5050 这个数据

for...do...done (固定循环)

相对于 while, until 的循环方式是必须要『符合某个条件』的状态， for 这种语法，则是『已经知道要进行几次循环』的状态!他的语法是:

for var in conl con2 con3 ...
do
    程序段
done

以上面的例子来说，这个 $var 的变量内容在循环工作时:

第一次循环时， $var 的内容为 con1 ;
第二次循环时， $var 的内容为 con2 ;
第三次循环时， $var 的内容为 con3 ;
....

我们可以做个简单的练习。假设我有三种动物，分别是 dog, cat, elephant 三种，我想每一行都输出这样:『There are dogs...』之类的字样，则可以:

[xiaoqi@study ~]$ vim userid.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

users=$(cut -d ':' -f1 /etc/passwd)    #获取账号名称
for username in ${users}    #开始循环
do
    id ${username}
done

执行上面的脚本后，你的系统账号就会被捉出来检查啦!这个动作还可以用在每个账号的删除、重整上面呢! 换个角度来看，如果我现在需要一连串的数字来进行循环呢?举例来说，我想要利用 ping 这个可以判断网络状态的指令，来进行网络状态的实际侦测时，我想要侦测的网域是本机所在的 10.10.1.150~10.10.1.255，由于有 105 台主机，总不会要我在 for 后面输入 1 到 100 吧?此时你可以这样做喔!

[xiaoqi@study ~]$ cat pingip.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

network="10.10.1"     # 先定义一个网域的前面部分!
for sitenu in $(seq 150 255)    # seq 为 sequence(连续) 的缩写之意
do
    #底下的程序在取得 ping 的回传值是正确的还是失败的!
    ping -c 1 -w 1 ${network}.${sitenu} &> /dev/null && result=0 || result=1
    #开始显示结果是正确的启动 (UP) 还是错误的没有连通 (DOWN)
    if [ "${result}" == 0 ]; then
        echo "Server ${network}.${sitenu} is UP."
    else
        echo "Server ${network}.${sitenu} is DOWN."
    fi
done

上面这一串指令执行之后就可以显示出 10.10.1.150~10.10.1.255 共 105 部主机目前是否能与你的机器连通!其实这个范例的重点在 $(seq ..) 那个位置!那个 seq 是连续 (sequence) 的缩写之意!代表后面接的两个数值是一直连续的! 如此一来，就能够轻松的将连续数字带入程序中!

除了使用 $(seq 1 100)** 之外，你也可以直接使用 bash 的内建机制来处理喔!可以使用 **{1..100}** 来取代 **$(seq 1 100) !那个大括号内的前面/后面用两个字符，中间以两个小数点来代表连续出现的意思!例如要持续输出 a, b, c...g 的话，就可以使用『 echo {a..g} 』这样的表示方式!

最后，让我们来玩判断式加上循环的功能!我想要让用户输入某个目录文件名，然后我找出某目录内的文件名的权限，该如何是好?

[root@study xiaoqi]# vim dir_perm.sh 
#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

#1.先看看这个目录是否存在啊?
read -p "Please input adirectory: " dir
if [ "${dir}" == "" -o ! -d "${dir}" ]; then
    echo "Then ${dir} is NOT exist in your system."
    exit 1
fi

#2.开始测试文件
filelist=$(ls ${dir})
for filename in ${filelist}
do
    perm=""
    test -r "${dir}/${filename}" && perm="${perm} readable"
    test -w "${dir}/${filename}" && perm="${perm} writable"
    test -x "${dir}/${filename}" && perm="${perm} executable"
    echo "Then file ${dir}/${filename}'s permission is ${perm} "
done

利用这种方式，可以很轻易的来处理一些文件的特性。

for...do...done 的数值处理

除了上述的方法之外，for 循环还有另外一种写法!语法如下:

for (( 初始值; 限制值; 执行步阶))
do
    程序段
done

这种语法适合于数值方式的运算当中，在 for 后面的括号内的三串内容意义为:

初始值:某个变量在循环当中的起始值，直接以类似 i=1 设定好;
限制值:当变量的值在这个限制值的范围内，就继续进行循环。例如 i<=100;
执行步阶:每作一次循环时，变量的变化量。例如 i=i+1。

值得注意的是，在『执行步阶』的设定上，如果每次增加 1 ，则可以使用类似『i++』的方式，亦即是 i 每次循环都会增加一的意思。好，我们以这种方式来进行 1 累加到使用者输入的循环吧

[root@study xiaoqi]# vim cal_1_100-2.sh
#!/bin/bash
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

read -p "Please input anumber, I will count for 1+2+...+your_input: " nu

s=0
for (( i=1; i<=${nu}; i++ ))
do
    s=$((${s}+${i}))
done

echo "The result pf '1+2+3..+${nu}' is --> ${s}"

搭配随机数与数组的实验

让我们来做个小实验!假设你们公司的团队中，经常为了今天中午要吃啥搞到头很昏! 每次都用猜拳的~好烦喔~有没有办法写支脚本，用脚本搭配随机数来告诉我们，今天中午吃啥好?执行这只脚本后，直接跟你说要吃啥~

要达成这个任务，首先你得要将全部的菜品输入到一组数组当中，再透过随机数的处理，去取得可能的数值，再将搭配到该数值的菜品输出出来即可!

[root@study xiaoqi]# vim what_to_eat.sh 
#!/bin/bash
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

eat[1]="酸辣土豆丝"
eat[2]="番茄炒蛋"
eat[3]="汉堡"
eat[4]="牛肉"
eat[5]="酸菜鱼"
eat[6]="方便面"
eat[7]="面包"
eat[8]="小龙虾"
eat[9]="糖醋排骨"

eatnum=9    #需要输入有几个可用的菜数量!

check=$(( ${RANDOM} * ${eatnum} /32767 + 1))
echo "Your may eat ${eat[${check}]}"

如果想要每次都输出 3 个菜呢? 而且这个店家不能重复喔!重复当然就没啥意义了!所以，你可以这样作!

[root@study xiaoqi]# vim what_to_eat-2.sh 
#!/bin/bash
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH

eat[1]="酸辣土豆丝"
eat[2]="番茄炒蛋"
eat[3]="汉堡"
eat[4]="牛肉"
eat[5]="酸菜鱼"
eat[6]="方便面"
eat[7]="面包"
eat[8]="小龙虾"
eat[9]="糖醋排骨"

eatnum=9
eated=0

while [ "${eated}" -lt 3 ];
do
    check=$(( ${RANDOM} * ${eatnum} /32767 + 1))
    mycheck=0
    if [ "${eated}" -ge 1 ]; then
        for i in $(seq 1 ${eated})
        do
            if [ ${eatedcon[$i]} == $check ];then
                myckeck=1
            fi
        done
    fi
    if [ ${mycheck} == 0 ];then
        echo "your may cat ${eat[${check}]}"
        eated=$((${eated} + 1))
        eatedcon[${eated}]=${check}
    fi

done

12.4 shell script 的追踪与 debug

scripts 在执行之前，最怕的就是出现语法错误的问题了!那么我们如何 debug 呢?有没有办法不需要透过直接执行该 scripts 就可以来判断是否有问题呢?当然是有的!我们就直接以 bash 的相关参数来进行判断!

[root@study xiaoqi]# sh [-nvx] scripts.sh
选项与参数:
-n :不要执行 script，仅查询语法的问题;
-v :再执行 sccript 前，先将 scripts 的内容输出到屏幕上; 
-x :将使用到的 script 内容显示到屏幕上，这是很有用的参数!


#范例一:测试 dir_perm.sh 有无语法的问题?
[root@study xiaoqi]# sh -n dir_perm.sh 
#若语法没有问题，则不会显示任何信息!
 
范例二:将 show_animal.sh 的执行过程全部列出来~
[root@study xiaoqi]# sh -x show_animal.sh
+ PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/root/bin + export PATH
+ for animal in dog cat elephant
+ echo 'There are dogs.... '
There are dogs....
+ for animal in dog cat elephant
+ echo 'There are cats.... '
There are cats....
+ for animal in dog cat elephant
+ echo 'There are elephants.... '
There are elephants....

在输出的讯息中，在加号后面的数据其实都是指令串，由于 sh -x 的方式来将指令执行过程也显示出来，如此用户可以判断程序代码执行到哪一段时会出现相关的信息!

版权属于：龙之介大人
本文链接：https://i7dom.cn/172/2019/30/linux-bash-shell-05.html
本站所有原创文章采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。您可以自由的转载和修改，但请务必注明文章来源和作者署名并说明文章非原创且不可用于商业目的。

12.1 条件判断式

12.1.1 if .... then的使用

12.1.2 if .... else的使用

12.1.3 case .... esac的使用

12.2 function的使用

12.3循环的使用

while do done, until do done (不定循环)

for...do...done (固定循环)

for...do...done 的数值处理

搭配随机数与数组的实验

12.4 shell script 的追踪与 debug

发表评论取消回复

Cobbler 自动化安装

腾讯云CDN报564错误码解决方案

使用redis为Typecho博客加速

Paragon NTFS for Mac v15破解版的使用方法

关于kali右键没有菜单解决方法

一篇文章玩转Markdown

使用redis为Typecho博客加速

linux文件操作

linux下文本比对sed与awk使用方法

Linux日志管理

12.1 条件判断式

12.1.1 if .... then的使用

12.1.2 if .... else的使用

12.1.3 case .... esac的使用

12.2 function的使用

12.3循环的使用

while do done, until do done (不定循环)

for...do...done (固定循环)

for...do...done 的数值处理

搭配随机数与数组的实验

12.4 shell script 的追踪与 debug

发表评论 取消回复

发表评论取消回复