本章內容

◆ 循環(huán)
◆ 信號捕捉
◆ 函數
◆ 數組
◆ 高級字符串操作
◆ 高級變量
◆ expect

流程控制

編程中的邏輯處理：
    順序執(zhí)行
    選擇執(zhí)行
    循環(huán)執(zhí)行

循環(huán)

循環(huán)執(zhí)行
    將某代碼段重復運行多次
    重復運行多少次
        循環(huán)次數事先已知
        循環(huán)次數事先未知
    有進入條件和退出條件
for, while, until

for循環(huán)

for 變量名 in 列表;do
    循環(huán)體
done
執(zhí)行機制：
依次將列表中的元素賦值給“變量名” ; 每次賦值后即執(zhí)行一次循環(huán)體; 直到列表中的元素耗盡，循環(huán)結束

列表生成方式：
    (1) 直接給出列表
    (2) 整數列表：
        (a) {start..end}
        (b) $(seq [start [step]] end)
    (3) 返回列表的命令
        $(COMMAND)
    (4) 使用glob，如：*.sh
    (5) 變量引用
        $@, $*

for特殊格式

雙小括號方法，即((…))格式，也可以用于算術運算
雙小括號方法也可以使bash Shell實現C語言風格的變量操作
    I=10
    ((I++))
for循環(huán)的特殊格式：
    for ((控制變量初始化;條件判斷表達式;控制變量的修正表達式))
    do
    循環(huán)體
    done
控制變量初始化：僅在運行到循環(huán)代碼段時執(zhí)行一次
控制變量的修正表達式：每輪循環(huán)結束會先進行控制變量修正運算，而后再做條件判斷

小筆記：

#1+2+3+...+100
SUM=0
for i in {1..100};do
    let SUM+=i
done
echo $SUM

SUM=0
for i in {1..100};do
    if [ $[i%2] -eq 1 ];then    #奇數和
        let SUM+=i
    fi
done
echo $SUM

#創(chuàng)建用戶并設置密碼，登陸需要改密碼
for i in {1..10};do
    useradd user$i
    password=`tr -dc '[:alnum:]' < /dev/urandom | head -c 8`
    echo user$i:$password | tee -a pass.txt | chpasswd
    passwd -e user$i
    echo  "User:user$i is created"
done

#用戶名記錄到文件并腳本創(chuàng)建這些用戶
vim userlist
jack
ada
jhon

for USER in `cat userlist`;do
    useradd $USER
done

#把不同的后綴名改為統(tǒng)一的后綴名
FILENAME=`ls | grep -v *.sh`
for I in $FILENAME;do
    NEWFILE=`echo $I | sed -nr 's#^([^.].*)\..*#\1#p'`
    mv $I ${NEWFILE}.abc
done 

#網段掃描
NETID=192.168.3
for HOSTID in {1..254};do
    {
        if ping -c1 -W1 $NETID.$HOSTID &> /dev/null ;then
            echo $NETID.$HOSTID is up | tee -a hostlist.txt
        fi
    } &
done
wait

#乘法表
for i in {1..9};do
    for j in `seq $i`;do
        echo -e "${j}x$i=$[j*i]\t\c"
    done
    echo
done

練習:用for實現

1、判斷/var/目錄下所有文件的類型

DIR=/var
for I in `ls $DIR`;do
    if [ -b $DIR/$I ];then
        echo -e "$I is \033[1;32mblock \033[0mfile"
    elif [ -c $DIR/$I ];then
        echo -e "$I is \033[1;31mcharacter \033[0mfile"
    elif [ -h $DIR/$I ];then
        echo -e "$I is \033[1;32msymbolic link \033[0mfile"
    elif [ -p $DIR/$I ];then
        echo -e "$I is \033[32mpipe \033[0mfile"
    elif [ -S $DIR/$I ];then
        echo -e "$I is \033[1;35msocket \033[0mfile"
    elif [ -d $DIR/$I ];then
        echo -e "$I is \033[1;34mdirectory \033[0mfile"                                                                        
    else
        echo -e "$I is \033[1mnormal \033[0mfile"
    fi
done

2、添加10個用戶user1-user10，密碼為8位隨機字符

for i in {1..10};do
    useradd user$i
    password=`tr -dc '[:alnum:]' < /dev/urandom | head -c 8`
    echo user$i:$password | tee -a pass.txt | chpasswd
    passwd -e user$i
    echo  "User:user$i is created"
done

3、 /etc/rc.d/rc3.d目錄下分別有多個以K開頭和以S開頭的文件；分別讀取每個文件，以

K開頭的輸出為文件加stop，以S開頭的輸出為文件名加start，如K34filename stop S66filename start
DIR=/etc/rc.d/rc3.d
for I in `ls $DIR`;do
    CHAR=`echo $I | cut -c 1`
    if [ $CHAR = K ] ;then
        echo $I | sed -nr '/^K.*/s#(.*)#\1 stop#p'
    elif [ $CHAR = S ] ;then                                                                                                   
        echo $I | sed -nr '/^S.*/s#(.*)#\1 start#p' 
    fi
done

4、編寫腳本，提示輸入正整數n的值，計算1+2+…+n的總和

SUM=0
read -p "請輸入正整形數：" n
if [[ $NUM =~ ^[0-9]+$ ]];then
    for I in `seq $n`;do
        let SUM+=$I
    done
else                                                                                                                           
    echo "數字有誤！"
    exit 2
fi
echo 總和：$SUM    

5、計算100以內所有能被3整除的整數之和

SUM=0
for I in {1..100};do
    if ! let $I%3; then                                                                                                        
        let SUM+=$I
    fi
done
echo 100以內能被3整除的整數之和：$SUM

6、編寫腳本，提示請輸入網絡地址，如192.168.0.0，判斷輸入的網段中主機在線狀態(tài)

read -p "請輸入網絡地址：" NETID
if echo $NETID | grep -E '([0-9]{1,3}\.){3}[0-9]{1,3}$' &> /dev/null  ;then
    NETID=`echo $NETID | sed -nr 's#(([0-9]{1,3}\.){3})[0-9]{1,3}$#\1#p'`                                                      
    for HOSTID in {1..254};do
        {
        if ping -c1 -W1 $NETID$HOSTID &> /dev/null ;then
            echo $NETID$HOSTID is up | tee -a hostlist.txt
        fi
        } &
    done
else
    echo "網絡地址不正確！"
    exit 2
fi
wait

7、打印九九乘法表

for ((i=1;i<=9;i++));do
    for ((j=1;j<=i;j++));do
        echo -e "${j}x$i=$[j*i]\t\c"
    done
    echo
done 

8、在/testdir目錄下創(chuàng)建10個html文件,文件名格式為數字N（從1到10）加隨機8個字母，如：1AbCdeFgH.html

DIR=/data/testdir
cd $DIR                                                                                                                        
for I in {1..10};do
    touch 1`tr -dc '[:alnum:]' < /dev/urandom | head -c 8`.html
done
echo "Files is created"! 

9、打印等腰三角形

read -p "請輸入數字：" N
if [[ $N =~ ^[0-9]+$ ]];then                                                                                                   
    for ((i=1;i<=$N;i++)) ;do
        for ((j=1;j<=$N-$i;j++)) ;do
            echo -e " \c"
        done
        for ((k=2;k<=$i*2;k++)) ;do
            echo -e "\033[1;$[RANDOM%7+31]m*\c"
        done
        echo
    done
else
    echo "請輸入有效的數字！"
fi

10、猴子第一天摘下若干個桃子，當即吃了一半，還不癮，又多吃了一個第二天早上又

將剩下的桃子吃掉一半，又多吃了一個。以后每天早上都吃了前一天剩下的一半零一個。
到第10天早上想再吃時，只剩下一個桃子了。求第一天共摘了多少？
SUM=1
DAY=9        
for I in `seq $DAY`;do
    let SUM=($SUM+1)*2
done
echo -e "第一天共摘了：\033[1m$SUM \033[0m個桃子！" 

while循環(huán)

while CONDITION; do
    循環(huán)體
done
CONDITION： 循環(huán)控制條件；進入循環(huán)之前，先做一次判斷；每一次循環(huán)之后
            會再次做判斷；條件為“true” ，則執(zhí)行一次循環(huán)；直到條件測試狀態(tài)為“false”
            終止循環(huán)
因此：CONDTION一般應該有循環(huán)控制變量；而此變量的值會在循環(huán)體不斷地被修正
進入條件：CONDITION為true
退出條件：CONDITION為false

練習：用while實現

1、 編寫腳本，求100以內所有正奇數之和

I=0
SUM=0
while [ $I -le 100 ];do
    if  ! let $I%2;then
        let SUM+=$I
    fi
    let I++
done
echo 100以內的奇數是：$SUM

2、 編寫腳本，提示請輸入網絡地址，如192.168.0.0，判斷輸入的網段中主機在線狀態(tài)，并統(tǒng)計在線和離線主機各多少

HOSTID=1
read -p "請輸入網絡地址：" NETID
    if echo $NETID | grep -E '([0-9]{1,3}\.){3}[0-9]{1,3}$' &> /dev/null  ;then
        rm -f hostlist.txt
        NETID=`echo $NETID | sed -nr 's#(([0-9]{1,3}\.){3})[0-9]{1,3}$#\1#p'`
        while [ $HOSTID -le 254 ];do
            {
            if ping -c1 -W1 $NETID$HOSTID &> /dev/null ;then
                echo $NETID$HOSTID is up | tee -a hostlist.txt &> /dev/null
            fi
            } &
            let HOSTID++
        done
        HOST=`cat hostlist.txt | wc -l`
        echo 在線主機數：$HOST
        echo 離線主機數：`expr $HOSTID - 1 - $HOST` 
    else
        echo "網絡地址不正確！"
        exit 2
    fi
wait

3、 編寫腳本，打印九九乘法表

I=1
while [ $I -le 9 ];do
    J=1               
    while [ $J -le $I ];do
        echo -e "${J}x${I}=$[j*i]\t\c"
        let J++
    done
    echo
    let I++
done

4、 編寫腳本，利用變量RANDOM生成10個隨機數字，輸出這個10數字，并顯示其中的最大值和最小值

I=1
MAX=$RANDOM
MIN=$MAX
echo $MAX
while [ $I -lt 10 ];do
    RND=$RANDOM
    echo $RND
    if [ $RND -gt $MAX ];then
        MAX=$RND
    elif [ $RND -lt $MIN ];then
        MIN=$RND
    fi
    let I++
done
echo MAX=$MAX
echo MIN=$MIN 

5、 編寫腳本，實現打印國際象棋棋盤

I=1
while [ $I -le 8 ];do
    odevity1=$[I%2]
    J=1
    while [ $J -le 8 ];do
        odevity2=$[J%2]
        if [ $odevity1 -eq $odevity2 ];then
            echo -e -n "\033[43m  \033[0m"
        else
            echo -e -n "\033[42m  \033[0m" 
        fi
        let J++
    done
    echo
    let I++
done

6、 后續(xù)六個字符串：efbaf275cd、 4be9c40b8b、 44b2395c46、 f8c8873ce0、 b902c16c8b、 ad865d2f63是通過對隨機數變量RANDOM隨機執(zhí)行命令： echo $RANDOM|md5sum|cut –c1-10 后的結果，請破解這些字符串對應的RANDOM值

RND=0
NUM=0
while true ;do
    STR=`echo $RND|md5sum|cut -c1-10`
    if [ "$STR" = "efbaf275cd" ];then
        echo "efbaf275cd = $RND"
        let NUM+=1
    elif [ "$STR" = "4be9c40b8b" ];then
        echo "4be9c40b8b = $RND"
        let NUM+=1
    elif [ "$STR" = "44b2395c46" ];then
        echo "44b2395c46 = $RND"
        let NUM+=1
    elif [ "$STR" = "f8c8873ce0" ];then
        echo "f8c8873ce0 = $RND"
        let NUM+=1
    elif [ "$STR" == "b902c16c8b" ];then
        echo "b902c16c8b = $RND"
        let NUM+=1
    elif [ "$STR" == "ad865d2f63" ];then
        echo "ad865d2f63 = $RND"
        let NUM+=1
    fi
    if [ $NUM -eq 6 ];then
        break
    fi
    let RND++
done         

ad865d2f63 = 1000
b902c16c8b = 3000
f8c8873ce0 = 6000
44b2395c46 = 9000
4be9c40b8b = 12000
efbaf275cd = 15000

until循環(huán)

until CONDITION; do
    循環(huán)體
done
進入條件： CONDITION 為false
退出條件： CONDITION 為true

循環(huán)控制語句continue

用于循環(huán)體中
continue [N]：提前結束第N層的本輪循環(huán)，而直接進入下一輪判斷；最內層為
    第1層
        while CONDTIITON1; do
            CMD1
            ...
            if CONDITION2; then
                continue
            fi
            CMDn
            ...
        done

循環(huán)控制語句break

用于循環(huán)體中
break [N]：提前結束第N層循環(huán)，最內層為第1層
    while CONDTIITON1; do
        CMD1
        ...
        if CONDITION2; then
            break
        fi
        CMDn
        ...
    done

continue 2    #提前結束第1層，第二層進入下一輪循環(huán)
break 2        #提前結束第2層

循環(huán)控制shift命令

shift [n]
用于將參量列表 list 左移指定次數，缺省為左移一次。
參量列表 list 一旦被移動，最左端的那個參數就從列表中刪除。 while 循環(huán)遍歷位置參量列表時，常用到 shift
./doit.sh a b c d e f g h
./shfit.sh a b c d e f g h

#!/bin/bash
while [ "$1" ];do
    useradd $1
    echo User:$1 is created
    shift
done
echo complete

示例：doit.sh

#!/bin/bash
# Name: doit.sh
# Purpose: shift through command line arguments
# Usage: doit.sh [args]
while [ $# -gt 0 ] # or (( $# > 0 ))
do
    echo $*
    shift
done

示例：shift.sh

#!/bin/bash
#step through all the positional parameters
until [ -z "$1" ]
do
    echo "$1"
    shift
done
echo

創(chuàng)建無限循環(huán)

while true; do
    循環(huán)體
done
until false; do
    循環(huán)體
Done

練習

1、 每隔3秒鐘到系統(tǒng)上獲取已經登錄的用戶的信息；如果發(fā)現用戶hacker登錄，

則將登錄時間和主機記錄于日志/var/log/login.log中,并退出腳本
while true;do
if who | grep hacker &> /dev/null ;then
    who | grep hacker >> /var/log/login.log                                                                                
fi
sleep 3
done

2、隨機生成10以內的數字，實現猜字游戲，提示比較大或小，相等則退出

let NUM=$RANDOM%10+1
while read -p "please input number(1-10):" N ;do
    if [[ $N =~ [0-9]+ ]] ;then
        if [ $N -eq $NUM ];then
            echo -e "\e[1;32mRight"!"\e[0m"                                                                                    
            break
        elif [ $N -lt $NUM ];then
            echo -e "\e[1;31mless\e[0m"
        elif [ $N -gt $NUM ];then
            echo -e "\e[1;31mgreater\e[0m"
        fi
    else
        echo "Invalid digit"
    fi
done

3、用文件名做為參數，統(tǒng)計所有參數文件的總行數

SUM=0
if [ -z "$1" ];then
    echo "Usage: $0 filename"
fi
while [ "$1" ];do
    if [ -f "$1" ];then
        NUM=`cat $1 | wc -l`
        SUM=$[SUM+NUM]
    else
        echo "$1 No such file"
    fi
    shift
done
echo SUM=$SUM

4、用二個以上的數字為參數，顯示其中的最大值和最小值

if [ -z $2 ];then
    echo "Usage: $0 number1 number2"
elif [ $# -gt 2 ];then
    echo "Usage: $0 number1 number2"
else
    if  [[ $1 =~ ^[0-9]+$ ]] && [[ $2 =~ ^[0-9]+$ ]] ;then
        while [ $2 ];do
            if [ $1 -gt $2 ];then
                echo MAX=$1
                echo MIM=$2
                break
            elif [ $1 -lt $2 ];then
                echo MAX=$2
                echo MIX=$1
                break
            else                                                                                                               
                break
            fi
        done
    else
        echo "Invalid digit"
    fi
fi

特殊用法

while循環(huán)的特殊用法（遍歷文件的每一行）
    while read line; do
        循環(huán)體
    done < /PATH/FROM/SOMEFILE
依次讀取/PATH/FROM/SOMEFILE文件中的每一行，且將行賦值給變量line

練習

1、掃描/etc/passwd文件每一行，如發(fā)現GECOS字段為空，則將用戶名和單位電話為62985600填充至GECOS字段，并提示該用戶的GECOS信息修改成功
cut -d: -f5 /etc/passwd | while read GECOS;do
    if [ -z "$GECOS" ];then
        GECOS=62985600
    fi
    echo $GECOS
done

select循環(huán)與菜單

select variable in list
do
    循環(huán)體命令
done
select 循環(huán)主要用于創(chuàng)建菜單，按數字順序排列的菜單項將顯示在標準錯誤上，并顯示 PS3 提示符，等待用戶輸入
用戶輸入菜單列表中的某個數字，執(zhí)行相應的命令
用戶輸入被保存在內置變量 REPLY 中
select 是個無限循環(huán)，因此要記住用 break 命令退出循環(huán)，或用 exit 命令終止腳本。也可以按 ctrl+c 退出循環(huán)
select 經常和 case 聯(lián)合使用
與 for 循環(huán)類似，可以省略 in list，此時使用位置參量

#小筆記
PS2:標準輸入提示符
PS3：select提示符
PS3="Please input a number: "; \
select menu in gongbaojiding baoyu haishen longxia ;do true;done

函數介紹

函數function是由若干條shell命令組成的語句塊，實現代碼重用和模塊化編程
它與shell程序形式上是相似的，不同的是它不是一個單獨的進程，不能獨立運行，而是shell程序的一部分
函數和shell程序比較相似，區(qū)別在于
Shell程序在子Shell中運行
而Shell函數在當前Shell中運行。因此在當前Shell中，函數可以對shell中變量進行修改

定義函數

函數由兩部分組成：函數名和函數體
help function
語法一：
    f_name () {
        ...函數體...
    }
語法二：
    function f_name {
        ...函數體...
    }
法三：
    function f_name () {
        ...函數體...
    }

#小筆記
declear -F                #查看函數
unset function_name        #刪除函數

source functions        #引用funcitons到腳本下，可使用functions腳本的函數

函數使用

函數的定義和使用：
    可在交互式環(huán)境下定義函數
    可將函數放在腳本文件中作為它的一部分
    可放在只包含函數的單獨文件中
調用：函數只有被調用才會執(zhí)行
    調用：給定函數名
    函數名出現的地方，會被自動替換為函數代碼
函數的生命周期：被調用時創(chuàng)建，返回時終止

函數返回值

函數有兩種返回值：
函數的執(zhí)行結果返回值：
    (1) 使用echo等命令進行輸出
    (2) 函數體中調用命令的輸出結果
函數的退出狀態(tài)碼：
    (1) 默認取決于函數中執(zhí)行的最后一條命令的退出狀態(tài)碼
    (2) 自定義退出狀態(tài)碼，其格式為：
    return 從函數中返回，用最后狀態(tài)命令決定返回值
    return 0 無錯誤返回
    return 1-255 有錯誤返回

交互式環(huán)境下定義和使用函數

示例：
    dir() {
    > ls -l
    > }
定義該函數后，若在$后面鍵入dir，其顯示結果同ls -l的作用相同dir
該dir函數將一直保留到用戶從系統(tǒng)退出，或執(zhí)行了如下所示的unset命令unset dir

在腳本中定義及使用函數

函數在使用前必須定義，因此應將函數定義放在腳本開始部分，直至shell首次發(fā)現它后才能使用
調用函數僅使用其函數名即可
示例：
    cat func1
    #!/bin/bash
    # func1
    hello()
    {
        echo "Hello there today's date is `date +%F`"
    }
    echo "now going to the function hello"
    hello
    echo "back from the function"

使用函數文件

● 可以將經常使用的函數存入函數文件，然后將函數文件載入shell
● 文件名可任意選取，但最好與相關任務有某種聯(lián)系。例如：functions.main
● 一旦函數文件載入shell，就可以在命令行或腳本中調用函數。可以使用set命令查看所有定義的函數，其輸出列表包括已經載入shell的所有函數
● 若要改動函數，首先用unset命令從shell中刪除函數。改動完畢后，再重新載入此文件

創(chuàng)建函數文件

函數文件示例：
    cat functions.main
    #!/bin/bash
    #functions.main
    findit()
    {
        if [ $# -lt 1 ] ; then
            echo "Usage:findit file"
            return 1
        fi
        find / -name $1 –print
    }

載入函數

函數文件已創(chuàng)建好后，要將它載入shell
定位函數文件并載入shell的格式
    . filename 或 source filename
注意：此即<點> <空格> <文件名>
這里的文件名要帶正確路徑
示例：
    上例中的函數，可使用如下命令
        . functions.main

檢查載入函數

使用set命令檢查函數是否已載入。 set命令將在shell中顯示所有的載入函數
示例：
    set
    findit=( )
    {
        if [ $# -lt 1 ]; then
            echo "usage :findit file";
        return 1
        fi
        find / -name $1 -print
    }
    …

執(zhí)行shell函數

要執(zhí)行函數，簡單地鍵入函數名即可
示例：
    findit groups
    /usr/bin/groups
    /usr/local/backups/groups.bak

刪除shell函數

現在對函數做一些改動后，需要先刪除函數，使其對shell不可用。使用unset命令完成刪除函數
命令格式為：
    unset function_name
示例：
    unset findit
    再鍵入set命令，函數將不再顯示
環(huán)境函數
    使子進程也可使用
    聲明：export -f function_name
    查看：export -f 或 declare -xf

函數參數

函數可以接受參數：
傳遞參數給函數：調用函數時，在函數名后面以空白分隔給定參數列表即可；
    例如“testfunc arg1 arg2 ...”
在函數體中當中，可使用$1, $2, ...調用這些參數；還可以使用$@, $*, $#等特殊變量

函數變量

變量作用域：
    環(huán)境變量：當前shell和子shell有效
    本地變量：只在當前shell進程有效，為執(zhí)行腳本會啟動專用子shell進程；
    因此，本地變量的作用范圍是當前shell腳本程序文件，包括腳本中的函數
    局部變量：函數的生命周期；函數結束時變量被自動銷毀
注意：如果函數中有局部變量，如果其名稱同本地變量，使用局部變量
在函數中定義局部變量的方法
    local NAME=VALUE

函數遞歸示例

函數遞歸：
    函數直接或間接調用自身
    注意遞歸層數
遞歸實例：
    階乘是基斯頓·卡曼于 1808 年發(fā)明的運算符號，是數學術語，一個正整數的階
    乘（factorial）是所有小于及等于該數的正整數的積，并且有0的階乘為1，自然
    數n的階乘寫作n!
        n!=1×2×3×...×n
        階乘亦可以遞歸方式定義：0!=1，n!=(n-1)!×n
        n!=n(n-1)(n-2)...1
        n(n-1)! = n(n-1)(n-2)!
    
    n!=(n-1)!xn        
    3!=2!x3
    2!=1!x2
    1!=0!x1
    0!=1
    
    fact 3
    echo (fact 2)*3
    
    fact 2
    echo (fact 1)*2
    
    fact 1
    echo (fact 0)*1
    
    fact 0 =  1

函數遞歸示例

示例：fact.sh
#!/bin/bash
#
fact() {
    if [ $1 -eq 0 -o $1 -eq 1 ]; then
        echo 1
    else
        echo $[$1*$(fact $[$1-1])]
    fi
}
fact $1

fork炸彈

fork炸彈是一種惡意程序，它的內部是一個不斷在fork進程的無限循環(huán)，實質是
一個簡單的遞歸程序。由于程序是遞歸的，如果沒有任何限制，這會導致這個
簡單的程序迅速耗盡系統(tǒng)里面的所有資源
函數實現
    :(){ :|:& };:
    bomb() { bomb | bomb & }; bomb
腳本實現
    cat Bomb.sh
    #!/bin/bash
    ./$0|./$0&

練習

1、編寫函數，實現OS的版本判斷

os_ver ()
{
    sed -r 's#.* ([0-9]+)\..*#\1#' /etc/redhat-release
}
os_ver

2、編寫函數，實現取出當前系統(tǒng)eth0的IP地址

showip ()
{
    IP=`ip addr show $1 | sed -nr 's#.* (([0-9]{1,3}\.){3}[0-9]{1,3})\/.*#\1#p'` 
    if [ $IP ];then
        echo $1:$IP
    else
        ip addr show $1 &> /dev/null && echo $1:nothing
    fi
}
if [ -z "$1" ];then
    echo "Usage:$0 interface"
    exit 2
fi
while [ "$1" ];do
    showip $1
    shift
done

3、編寫函數，實現打印綠色OK和紅色FAILED

source /etc/init.d/functions
action OK               
action FAILED false

4、編寫函數，實現判斷是否無位置參數，如無參數，提示錯誤

args ()
{
    if [ -z $1 ];then
        echo "nothing arg"
        return 2
    fi
}
args $1 

練習

1、編寫服務腳本/root/bin/testsrv.sh，完成如下要求

• (1) 腳本可接受參數：start, stop, restart, status

• (2) 如果參數非此四者之一，提示使用格式后報錯退出

• (3) 如是start:則創(chuàng)建/var/lock/subsys/SCRIPT_NAME, 并顯示“啟動成功”
  考慮：如果事先已經啟動過一次，該如何處理？

• (4) 如是stop:則刪除/var/lock/subsys/SCRIPT_NAME, 并顯示“停止完成”
  考慮：如果事先已然停止過了，該如何處理？

• (5) 如是restart，則先stop, 再start
  考慮：如果本來沒有start，如何處理？

• (6) 如是status, 則如果/var/lock/subsys/SCRIPT_NAME文件存在，則顯示“SCRIPT_NAME is running...” ，如果/var/lock/subsys/SCRIPT_NAME文件不存在，則顯示“SCRIPT_NAME is stopped...”

• (7)在所有模式下禁止啟動該服務，可用chkconfig 和 service命令管理
  說明：SCRIPT_NAME為當前腳本名

DIR=/var/lock/subsys
NAME=$0
case $1 in
    start)
        if [ ! -d $DIR ];then
            mkdir -p $DIR
        elif [ ! -f $DIR/$NAME ];then
            touch $DIR/$NAME
            echo "啟動成功"
        else
            echo "已啟動"
        fi
    ;;
    stop)
        if [ -d $DIR ];then
            rm -rf $DIR
            echo "停止成功"
        else
            echo "已停止"
        fi
    ;;
    restart)
        stop
        start
    ;;
    status)
        if [ -f $DIR/$NAME ];then
            echo $NAME is running...
        else
            echo $NAME is stopped...
        fi
    ;;
    *)
        echo "Usage: $0 start|stop|restart|status"
    ;;
esac

2、編寫腳本/root/bin/copycmd.sh

• (1) 提示用戶輸入一個可執(zhí)行命令名稱
• (2) 獲取此命令所依賴到的所有庫文件列表
• (3) 復制命令至某目標目錄(例如/mnt/sysroot)下的對應路徑下
  如：/bin/bash ==> /mnt/sysroot/bin/bash
• /usr/bin/passwd ==> /mnt/sysroot/usr/bin/passwd
• (4) 復制此命令依賴到的所有庫文件至目標目錄下的對應路徑下： 如：/lib64/ld
  linux-x86-64.so.2 ==> /mnt/sysroot/lib64/ld-linux-x86-64.so.2
• (5)每次復制完成一個命令后，不要退出，而是提示用戶鍵入新的要復制的命令，并重復完成上述功能；直到用戶輸入quit退出

ROOT=/mnt/sysroot
bin_cp()
{
    if which $1 &> /dev/null;then 
        CMD=`which $1`
        CMDDIR=$ROOT`dirname $CMD`
        [ ! -d $CMDDIR ] && mkdir -p $CMDDIR
        [ ! -f $ROOT$CMD ] && cp $CMD $CMDDIR 
        return 0
    else
        echo $1 command not found...
        return 2
    fi
}

lib_cp()
{
    LIB=$(ldd `which $1` | grep -Eo '/[^[:space:]]+')
    for I in $LIB;do
        LIBDIR=`dirname $I`
        [ ! -d $ROOT$LIBDIR ] && mkdir -p $ROOT$LIBDIR
        [ ! -f $ROOT$I ] && cp $I $ROOT$LIBDIR
    done
    return 0
}

while read -p "Please input executable command(or quit):" CMD;do
    if [[ $CMD =~ [qQ][uU][iI][tT] ]];then
        break
    else
        if bin_cp $CMD  ;then
            lib_cp $CMD
        fi
    fi                                                                                                                         
done

練習

1、編寫函數實現兩個數字做為參數，返回最大值

fun_max()
{
    if [ -z $2 ];then
        echo "Usage: $0 number1 number2"
    elif [ $# -gt 2 ];then
        echo "arg invalid"
    else
        if [ $2 ];then
            [ $1 -gt $2 ] && echo MAX=$1 || echo MAX=$2
        else
            echo "Usage: $0 number1 number2"
        fi
    fi
}
fun_max $@

2、斐波那契數列又稱黃金分割數列，因數學家列昂納多·斐波那契以兔子繁殖為例

子而引入，故又稱為“兔子數列”，指的是這樣一個數列：0、 1、 1、 2、 3、 5、
8、 13、 21、 34、 ……，斐波納契數列以如下被以遞歸的方法定義：F（0）=0，
F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2）
利用函數，求n階斐波那契數列
fib_seq2()
{
    A=1;B=2;C=0
    if [ $1 -eq 0 ];then
        echo 0
    elif [ $1 -eq 1 -o $1 -eq 2 ];then
        echo 1
    elif [ $1 -gt 2 ];then
        for i in `seq 3 $1`;do
            C=$[$A+$B]
            A=$B
            B=$C
        done
        echo $C                 
    fi
}

read -p "Please input number: " N
if [[ $N =~ ^[0-9]+$ ]] ;then
    NUM=`fib_seq2 $N`
    if [ $N -lt 92 ];then
        echo "f($N)=$NUM"
    else
        echo "f($N) value is too bigger"
    fi
else
    echo "Usage: $0 number"
    exit 2
fi

3、漢諾塔（又稱河內塔）問題是源于印度一個古老傳說。大梵天創(chuàng)造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞著64片黃金圓盤。大梵天命令婆羅門把圓盤從下面開始按大小順序重新擺放在另一根柱子上。并且規(guī)定，在小圓盤上不能放大圓盤，在三根柱子之間一次只能移動一個圓盤，利用函數，實現N片盤的漢諾塔的移動步驟

占位

信號捕捉trap

trap '觸發(fā)指令' 信號
    進程收到系統(tǒng)發(fā)出的指定信號后，將執(zhí)行自定義指令，而不會執(zhí)行原操作
trap '' 信號
    忽略信號的操作
trap '-' 信號
    恢復原信號的操作
trap -p
    列出自定義信號操作
trap finish EXIT
    當腳本退出時，執(zhí)行finish函數

#按ctrl+c，不中斷程序
trap 'echo press ctrl+c' int
trap -p        #捕獲信號，顯示信號
for ((i=0;i<=10;i++));do
    echo $i
    sleep 1
done

#按下ctrl+c不做任何響應
trap '' int
trap -p        #捕獲信號，顯示信號
for ((i=0;i<=10;i++));do
    echo $i
    sleep 1
done

trap示例

#!/bin/bash
trap 'echo "signal:SIGINT"' int
trap -p
for((i=0;i<=10;i++))
do
    sleep 1
    echo $i
done

trap '' int
trap -p
for((i=11;i<=20;i++))
do
    sleep 1
    echo $i
done

trap '-' int
trap -p
for((i=21;i<=30;i++))
do
    sleep 1
    echo $i
done

數組

變量：存儲單個元素的內存空間
數組：存儲多個元素的連續(xù)的內存空間，相當于多個變量的集合
數組名和索引
    索引：編號從0開始，屬于數值索引
    注意：索引可支持使用自定義的格式，而不僅是數值格式，即為關聯(lián)索引，
    bash4.0版本之后開始支持
    bash的數組支持稀疏格式（索引不連續(xù)）
聲明數組：
    declare -a ARRAY_NAME
    declare -A ARRAY_NAME 關聯(lián)數組
    注意：兩者不可相互轉換

數組賦值

數組元素的賦值
(1) 一次只賦值一個元素
    ARRAY_NAME[INDEX]=VALUE
    weekdays[0]="Sunday"
    weekdays[4]="Thursday"
(2) 一次賦值全部元素
    ARRAY_NAME=("VAL1" "VAL2" "VAL3" ...)
(3) 只賦值特定元素
    ARRAY_NAME=([0]="VAL1" [3]="VAL2" ...)
(4) 交互式數組值對賦值
    read -a ARRAY
    顯示所有數組：declare -a

引用數組

引用數組元素
    ${ARRAY_NAME[INDEX]}
    注意：省略[INDEX]表示引用下標為0的元素
引用數組所有元素
    ${ARRAY_NAME[*]}
    ${ARRAY_NAME[@]}
數組的長度(數組中元素的個數)
    ${#ARRAY_NAME[*]}
    ${#ARRAY_NAME[@]}
刪除數組中的某元素：導致稀疏格式
    unset ARRAY[INDEX]
刪除整個數組
    unset ARRAY
    
#小筆記    
NUM=({1..10})
NUM[10]=11
echo ${NUM[*]}        #全部顯示
echo ${#NUM[*]}        #數組個數
    
declare -A STR        #關聯(lián)數組需要定義
STR=([shiwu]=10 [yifu]=20 [yinliao]=30)
echo ${STR[shiwu]}

unset NUM STR

數組數據處理

引用數組中的元素：
    數組切片：
    ${ARRAY[@]:offset:number}
        offset 要跳過的元素個數
        number 要取出的元素個數
    取偏移量之后的所有元素
    ${ARRAY[@]:offset}
向數組中追加元素：
    ARRAY[${#ARRAY[*]}]=value
關聯(lián)數組：
    declare -A ARRAY_NAME
    ARRAY_NAME=([idx_name1]='val1' [idx_name2]='val2‘...)
    注意：關聯(lián)數組必須先聲明再調用

示例

#生成10個隨機數保存于數組中，并找出其最大值和最小值
#!/bin/bash
declare -i min max
declare -a nums
for ((i=0;i<10;i++));do
    nums[$i]=$RANDOM
    [ $i -eq 0 ] && min=${nums[$i]} && max=${nums[$i]}&& continue
    [ ${nums[$i]} -gt $max ] && max=${nums[$i]}
    [ ${nums[$i]} -lt $min ] && min=${nums[$i]}
done
echo "All numbers are ${nums[*]}"
echo Max is $max
echo Min is $min

示例

編寫腳本，定義一個數組，數組中的元素對應的值是/var/log目錄下所有以.log結尾
的文件；統(tǒng)計出其下標為偶數的文件中的行數之和
#!/bin/bash
#
declare -a files
files=(/var/log/*.log)
declare -i lines=0
for i in $(seq 0 $[${#files[*]}-1]); do
    if [ $[$i%2] -eq 0 ];then
        let lines+=$(wc -l ${files[$i]} | cut -d' ' -f1)
    fi
done
echo "Lines: $lines."

練習

1、輸入若干個數值存入數組中，采用冒泡算法進行升序或降序排序

declare -a NUM

array()             #給數組NUM賦值
{
   ARG=$#
   A=0
   for I in `echo $@`;do
       if [ $A -lt $ARG ];then      
           NUM[$A]=$I
       fi  
   let A++ 
   done
}

bubble_sort()       #冒泡排序                                                                                           
{
   if [ $2 ];then
   for ((n=0;n<$#-1;n++));do   
       for I in `seq 0 $#`;do
           if [ $I -eq 0 ];then
               NEXT=${NUM[$I]}
               continue
           fi
           Y=$[$I-1]
           LAST=${NUM[$Y]}
           NEXT=${NUM[$I]}
           if [ $I -ne $# ];then
               if [ -n "$NEXT" ] && [ -n "$LAST" ];then
                   if [ $NEXT -lt $LAST ];then
                       NUM[$I]=$LAST
                       NUM[$Y]=$NEXT 
                   fi  
                   
               fi
           fi
       done
   done
   echo ${NUM[@]}
   else
       echo "Invalid digt"
       echo "e.g : num num num ..."
       return 2
   fi
}

fun_num()       #判斷是否為數字
{
   while [ "$1" ];do
       if [[ $1 =~ ^[0-9]+$ ]];then
           shift
       else        
           return 2
       fi
   done
}

while read -p "Please input number(1 2 3 ...): " N;do
   if [[ $N =~ [Qq]|[Qq][Uu][Ii][Tt] ]];then
       break
   elif `fun_num $N` ;then
       array $N
       STR=`bubble_sort $N`
       echo $STR
       MIN=`echo $STR | cut -d " " -f 1`
       MAX=`echo $STR | cut -d " " -f ${#NUM[@]}`
       echo MIN=$MIN MAX=$MAX
   fi
done

冒泡算法

2、將下圖所示，實現轉置矩陣matrix.sh

    1 2 3         1 4 7
    4 5 6 ===>     2 5 8
    7 8 9         3 6 9
    
declare -a NUM=({1..9})
for ((J=0;J<3;J++));do
    if [ $J -eq 0 ];then
        A=${NUM[@]:0:3}
        B=`echo "${NUM[$J]} ${NUM[$[$J+3]]} ${NUM[$[$J+6]]}"`
        echo -e "$A\t$B"
    elif [ $J -eq 1 ];then
        A=${NUM[@]:3:3}
        B=`echo "${NUM[$J]} ${NUM[$[$J+3]]} ${NUM[$[$J+6]]}"`
        echo -e "$A\t$B"
    elif [ $J -eq 2 ];then
        A=${NUM[@]:6:3}
        B=`echo "${NUM[$J]} ${NUM[$[$J+3]]} ${NUM[$[$J+6]]}"`
        echo -e "$A\t$B"                                                                                                       
    fi
done        

轉置矩陣

3、打印楊輝三角形

read -p "Please input number: " N
declare -a NUM

for I in `seq 1 $N`;do
    if [ $I -eq 1 ];then
        NUM[0]=1                                #數列0為1
    elif [ $I -eq 2 ];then
        NUM[1]=1                                #數列1為1
    elif [ $I -gt 2  ];then                        #數列2開始計算
        declare -a TMP
        for J in `seq 0 $[${#NUM[@]}-1]`;do        #把上一個NUM數列存到TMP中
            TMP[$J]=${NUM[$J]}                    
        done
        for L in `seq 0 $[$N-3]` ;do
            A=$[$L+1]
            B=$L
            if [ -n "${TMP[$A]}" ] && [ -n "${TMP[$B]}" ];then
                SUM=`expr ${TMP[$A]} + ${TMP[$B]}`    #把TMP中的數列按順序相加
                NUM[$A]=$SUM
            fi
        done
        NUM[${#NUM[@]}]=1                        #數列最后值為1
    fi
    for ((j=1;j<=$N-$I;j++)) ;do
        echo -en " "
    done
    for ((k=1;k<=1;k++)) ;do
        echo -en "${NUM[@]}"
    done
    echo
done

楊輝三角形

字符串切片

${#var}:返回字符串變量var的長度
${var:offset}:返回字符串變量var中從第offset個字符后（不包括第offset個字符）的字
              符開始，到最后的部分，offset的取值在0 到 ${#var}-1 之間(bash4.2后，允許為負值)
${var:offset:number}：返回字符串變量var中從第offset個字符后（不包括第offset個
                      字符）的字符開始，長度為number的部分
${var: -length}：取字符串的最右側幾個字符
    注意：冒號后必須有一空白字符
${var:offset:-length}：從最左側跳過offset字符，一直向右取到距離最右側lengh個字符之前的內容
${var: -length:-offset}：先從最右側向左取到length個字符開始，再向右取到距離最右側offset個字符之間的內容
    注意：-length前空格

#小筆記
NAME=magedu教育
echo ${#NAME} = 8個字符
echo ${NAME:2} = gedu教育
echo ${NAME:2:3} = ged
echo ${NAME: -3} = u教育
echo ${NAME:2:-3} = ged
echo ${NAME: -5:-4} = e        #僅支持cenots7以上
echo ${NAME: -6:-4} = ge        #僅支持cenots7以上

字符串處理

基于模式取子串
    ${var#*word}：其中word可以是指定的任意字符
    功能：自左而右，查找var變量所存儲的字符串中，第一次出現的word, 刪
          除字符串開頭至第一次出現word字符串（含）之間的所有字符
    ${var##*word}：同上，貪婪模式，不同的是，刪除的是字符串開頭至最后
    一次由word指定的字符之間的所有內容
示例：
    file=“var/log/messages”
    ${file#*/}: log/messages
    ${file##*/}: messages

字符串處理

${var%word*}：其中word可以是指定的任意字符
    功能：自右而左，查找var變量所存儲的字符串中，第一次出現的word, 刪
          除字符串最后一個字符向左至第一次出現word字符串（含）之間的所有字符
    file="/var/log/messages"
    ${file%/*}: /var/log
${var%%word*}：同上，只不過刪除字符串最右側的字符向左至最后一次出現word字符之間的所有字符
示例：
    url=http://www.magedu.com:80
    ${url##*:} 80
    ${url%%:*} http

查找替換
    ${var/pattern/substr}：查找var所表示的字符串中，第一次被pattern所匹    配到的字符串，以substr替換之
    ${var//pattern/substr}: 查找var所表示的字符串中，所有能被pattern所匹配到的字符串，以substr替換之
    ${var/#pattern/substr}：查找var所表示的字符串中，行首被pattern所匹配到的字符串，以substr替換之
    ${var/%pattern/substr}：查找var所表示的字符串中，行尾被pattern所匹配到的字符串，以substr替換之
    
查找并刪除
    ${var/pattern}：刪除var表示的字符串中第一次被pattern匹配到的字符串
    ${var//pattern}：刪除var表示的字符串中所有被pattern匹配到的字符串
    ${var/#pattern}：刪除var表示的字符串中所有以pattern為行首匹配到的字符串
    ${var/%pattern}：刪除var所表示的字符串中所有以pattern為行尾所匹配到的字符串
字符大小寫轉換
    ${var^^}：把var中的所有小寫字母轉換為大寫
    ${var,,}：把var中的所有大寫字母轉換為小寫

變量賦值

image.png

高級變量用法-有類型變量

Shell變量一般是無類型的，但是bash Shell提供了declare和typeset兩個命令
用于指定變量的類型，兩個命令是等價的
declare [選項] 變量名
-r 聲明或顯示只讀變量
-i 將變量定義為整型數
-a 將變量定義為數組
-A 將變量定義為關聯(lián)數組
-f 顯示已定義的所有函數名及其內容
-F 僅顯示已定義的所有函數名
-x 聲明或顯示環(huán)境變量和函數
-l 聲明變量為小寫字母 declare –l var=UPPER
-u 聲明變量為大寫字母 declare –u var=lower

eval命令

● eval命令將會首先掃描命令行進行所有的置換，然后再執(zhí)行該命令。該命令適用于那些一次掃描無法實現其功能的變量.該命令對變量進行兩次掃描
示例：
    [root@server ~]# CMD=whoami
    [root@server ~]# echo $CMD
    whoami
    [root@server ~]# eval $CMD
    root
    [root@server ~]# n=10
    [root@server ~]# echo {0..$n}
    {0..10}
    [root@server ~]# eval echo {0..$n}
    0 1 2 3 4 5 6 7 8 9 10

間接變量引用

● 如果第一個變量的值是第二個變量的名字，從第一個變量引用第二個變量的值就稱為間接變量引用variable1的值是variable2，而variable2又是變量名，variable2的值為value，
● 間接變量引用是指通過variable1獲得變量值value的行為
    variable1=variable2
    variable2=value
    
    title=name
    name=mage
    eval echo \$$title    = echo ${!title}
    輸出值：mage

間接變量引用

bash Shell提供了兩種格式實現間接變量引用
    eval tempvar=\$$variable1
    tempvar=${!variable1}
示例：
    [root@server ~]# N=NAME
    [root@server ~]# NAME=wangxiaochun
    [root@server ~]# N1=${!N}
    [root@server ~]# echo $N1
    wangxiaochun
    [root@server ~]# eval N2=\$$N
    [root@server ~]# echo $N2
    wangxiaochun

創(chuàng)建臨時文件

mktemp命令：創(chuàng)建并顯示臨時文件，可避免沖突
mktemp [OPTION]... [TEMPLATE]
    TEMPLATE: filenameXXX
        X至少要出現三個
OPTION：
    -d: 創(chuàng)建臨時目錄
    -p DIR或--tmpdir=DIR：指明臨時文件所存放目錄位置
示例：
    mktemp /tmp/testXXX
    tmpdir=`mktemp –d /tmp/testdirXXX`
    mktemp --tmpdir=/testdir testXXXXXX

安裝復制文件

install命令：
    install [OPTION]... [-T] SOURCE DEST 單文件
    install [OPTION]... SOURCE... DIRECTORY
    install [OPTION]... -t DIRECTORY SOURCE...
    install [OPTION]... -d DIRECTORY...創(chuàng)建空目錄
選項：
    -m MODE，默認755
    -o OWNER
    -g GROUP
示例：
    install -m 700 -o wang -g admins srcfile desfile
    install –m 770 –d /testdir/installdir

expect介紹

● expect 是由Don Libes基于Tcl（ Tool Command Language ）語言開發(fā)的，主要應用于自動化交互式操作的場景，借助 expect 處理交互的命令，可以將交互過程如：ssh登錄，ftp登錄等寫在一個腳本上，使之自動化完成。尤其適用于需要對多臺服務器執(zhí)行相同操作的環(huán)境中，可以大大提高系統(tǒng)管理人員的工作效率

expect命令

expect 語法：
    expect [選項] [ -c cmds ] [ [ -[f|b] ] cmdfile ] [ args ]
選項
-c：從命令行執(zhí)行expect腳本，默認expect是交互地執(zhí)行的
    示例：expect -c 'expect "\n" {send "pressed enter\n"}
-d：可以輸出輸出調試信息
    示例：expect -d ssh.exp
expect中相關命令
    spawn 啟動新的進程
    send 用于向進程發(fā)送字符串
    expect 從進程接收字符串
    interact 允許用戶交互
    exp_continue 匹配多個字符串在執(zhí)行動作后加此命令

expect最常用的語法(tcl語言:模式-動作)
單一分支模式語法：
    expect “hi” {send “You said hi\n"}
    匹配到hi后，會輸出“you said hi” ，并換行
多分支模式語法：
    expect "hi" { send "You said hi\n" } \
    "hehe" { send "Hehe yourself\n" } \
    "bye" { send "Good bye\n" }
匹配hi,hello,bye任意字符串時，執(zhí)行相應輸出。等同如下：
    expect {
    "hi" { send "You said hi\n"}
    "hehe" { send "Hehe yourself\n"}
    "bye" { send " Good bye\n"}
    }

示例

#scp自動傳輸
#!/usr/bin/expect
spawn scp /etc/fstab 192.168.8.100:/app
expect {
    "yes/no" { send "yes\n";exp_continue }
    "password" { send "magedu\n" }
}
expect eof

#ssh自動連接
#!/usr/bin/expect
spawn ssh 192.168.8.100
expect {
"yes/no" { send "yes\n";exp_continue }
"password" { send "magedu\n" }
}
interact
#expect eof

#變量
#!/usr/bin/expect
set ip 192.168.8.100
set user root
set password magedu
set timeout 10
spawn ssh $user@$ip
expect {
"yes/no" { send "yes\n";exp_continue }
"password" { send "$password\n" }
}
interact

#位置參數
#!/usr/bin/expect
set ip [lindex $argv 0]
set user [lindex $argv 1]
set password [lindex $argv 2]
spawn ssh $user@$ip
expect {
"yes/no" { send "yes\n";exp_continue }
"password" { send "$password\n" }
}
interact
#./ssh3.exp 192.168.8.100 root magedu

#執(zhí)行多個命令
#!/usr/bin/expect
set ip [lindex $argv 0]
set user [lindex $argv 1]
set password [lindex $argv 2]
set timeout 10
spawn ssh $user@$ip
expect {
"yes/no" { send "yes\n";exp_continue }
"password" { send "$password\n" }
}
expect "]#" { send "useradd haha\n" }
expect "]#" { send "echo magedu |passwd --stdin haha\n" }
send "exit\n"
expect eof
#./ssh4.exp 192.168.8.100 root magedu

示例：shell腳本調用expect
#!/bin/bash
ip=$1
user=$2
password=$3
expect <<EOF
set timeout 20
spawn ssh $user@$ip
expect {
"yes/no" { send "yes\n";exp_continue }
"password" { send "$password\n" }
}
expect "]#" { send "useradd hehe\n" }
expect "]#" { send "echo magedu |passwd --stdin hehe\n" }
expect "]#" { send "exit\n" }
expect eof
EOF
#./ssh5.sh 192.168.8.100 root magedu