本篇中涉及到算術運算，使用了$[]這種我未在官方手冊中見到的用法，但是確實可用的，在此前的博文《Bash腳本編程學習筆記03：算術運算》中我有說明不要使用，不過自己忘記了，大家還是盡量使用其他的方法進行算術運算，

簡介

Bash具有三種回圈結構：

for回圈，
while回圈，
untile回圈，

在使用回圈結構體的時候，需要注意回圈的進入條件和結束條件，避免出現死回圈的情況，

for回圈

for回圈又分為兩種格式：遍歷串列和控制變數，

遍歷串列

for VAR in LIST; do
    BODY
done

VAR：變數，在每次回圈時，都會被LIST中的元素所賦值，

LIST：串列，生成串列的方式有多種，后面會詳述，

BODY：回圈體，由各種各樣的命令所構成，在回圈體中會參考變數VAR，

進入回圈條件：只要LIST中有元素即可，

離開回圈條件：LIST中的元素遍歷完畢，

LIST的生成方式

這里的LIST生成方式的分類并非官方，甚至看起來蠻重復的，大家實際敲過之后就大概能明白串列是個什么東西了，

官方的LIST其實就是shell展開，

1、直接給出，

[root@c7-server ~]# cat for_list.sh
#!/bin/bash
for i in 1 2 3 4 5; do
    echo $i
done
[root@c7-server ~]# bash for_list.sh
1
2
3
4
5

2、通過大括號或者seq命令生成的整數串列，

[root@c7-server ~]# cat for_list.sh
#!/bin/bash
for i in {1..5}; do
    echo $i
done
[root@c7-server ~]# bash for_list.sh 
1
2
3
4
5

seq是一個外部命令，一般用于生成一個整數序列，

seq [FIRST [INCREMENT]] LAST

見名知意，大家試試以下幾種命令生成的整數串列就懂了，

# seq 10
# seq 1 10
# seq 2 10
# seq 1 2 10
# seq 2 2 10

seq在使用的時候要結合bash的命令替換機制，即下面要說的就是了，

3、參考回傳串列的命令，

像剛才的seq其實就類似于這種，其他的例如應用ls命令的結果的也是可以，

4、Glob風格的展開，

----2020-01-13----

{x..y}：當x和y是正整數的時候，相比大家都會用，需要注意的是它可以加入一個增量，

{x..y[..incr]}

示例如下：

[root@c7-server ~]# echo {1..10}
1 2 3 4 5 6 7 8 9 10
[root@c7-server ~]# echo {1..10..2}
1 3 5 7 9

5、位置引數（$@, $*）的參考，

練習

1、撰寫一個腳本，批量創建5個用戶，

#!/bin/bash

for i in zwl0{1..5}; do
    if id $i &> /dev/null; then
        echo "User $i has already exists."
    else
        useradd $i
    fi
done

2、撰寫一個腳本，統計100以內的整數之和、奇數之和與偶數之和，

整數之和，

#!/bin/bash

declare -i sum=0
for i in $(seq 100); do
    echo "sum is $sum, i is $i."
    sum=$[$sum+$i]
done
echo "sum is $sum."

奇數之和：只要將seq替換為“seq 1 2 100”即可，

偶數之和：只要將seq替換為“seq 2 2 100”即可，

3、撰寫一個腳本，判斷某目錄下的所有檔案的型別，

#!/bin/bash

for i in /root/*; do
    file $i
done

其實file命令本身即可實作，主要是了解一下可以以通配符展開來生成LIST，

# file /root/*

4、計算當前所有用戶的UID之和，

#!/bin/bash

declare -i sum=0
for i in $(cut -d : -f 3 /etc/passwd); do
    sum=$[$sum+$i]
done
echo "The sum of UIDs is $sum."

5、統計某個目錄下的文本檔案總數，以及文本檔案的行數之和，注：無需遞回，僅統計目錄下第一層即可，

#!/bin/bash

if [ ! -d $1 ]; then
    echo "The file you input is not a directory,exit!"
    exit 1
fi

declare -i textCount=0
declare -i lineCount=0

for i in $1/*; do
    if [ -f $i ]; then
        lines=$(wc -l $i | cut -d " " -f 1)
        textCount=$[$textCount+1]
        lineCount=$[$lineCount+$lines]
    fi
done

echo "The number of text file is $textCount."
echo "The number of line of text file is $lineCount."

控制變數

for陳述句的控制變數，其實就是類似于C風格的for陳述句，

for ((expr1; expr2; expr3)); do
    BODY
done

此類for陳述句，只用于數值類的計算，寫起來更像C語言，在(())不需要再使用$對變數進行展開，寫起來更簡潔方便，

expr1：只有在第一次回圈時執行，一般用于對某個變數進行賦初值的操作，

expr2：每次都會執行，一般是對賦值的變數進行條件判斷，為真執行BODY；為假的話，結束回圈，

expr3：對賦值的變數進行數值調整，使其將來滿足expr2為假的情況從而結束回圈，

示例：計算100以內所有奇數之和，

#!/bin/bash

declare -i sum=0
for ((i=1;i<=100;i+=2)); do
    ((sum+=i))
done
echo "Sum is $sum."

while回圈

while CONDITION; do
    CMD
done

當CONDITION為真時，執行CMD，直到CONDITION為假的時候才退出回圈，

CMD中一般會包含一些可以在將來改變CONDITION的判定結果的操作，否則會出現死回圈，

while回圈相比for回圈的優勢在于，for回圈需要事先生成一個串列，如果串列元素比較大，例如{1..10000}，那么就會占用比較多的記憶體空間；而while回圈只需要占用一個變數的記憶體空間即可，（結論來自馬哥，我覺得應該沒錯吧）

我們使用while回圈來實作計算100以內的正整數之和，

[root@c7-server ~]# cat while_sum.sh
#!/bin/bash

declare -i sum=0
declare -i i=1
while [ $i -le 100 ]; do
    ((sum+=i))
    ((i++))
done

echo "sum is $sum."

幾個注意事項：

后綴自增/減運算和賦值（如：+=, -=, *=, /=等等）時，涉及變數的時候不要將變數展開，否則會報錯，

[root@c7-server ~]# declare -i i=1
[root@c7-server ~]# (($i++))
-bash: ((: 1++: syntax error: operand expected (error token is "+")
[root@c7-server ~]# (($i+=1))
-bash: ((: 1+=1: attempted assignment to non-variable (error token is "+=1")

同樣的方式，在前綴自增/減時雖然不會報錯，但是也不會達到預期的效果，

[root@c7-server ~]# ((++$i))
[root@c7-server ~]# echo $i
1

因為一旦使用了展開，bash會先進行展開，再進行算術運算，展開后就變成了，

((1++))
((++1))
((1+=1))

正確的用法是：

((i++))
((++i))
((i+=1))

賦值時，等于號右邊的變數，可以不展開，以下是等效的，

((a=a+b))
((a=$a+$b))
((a+=b))
((a+=$b))

特殊用法：遍歷檔案內容

while回圈有一種特殊的用法，可以遍歷檔案的內容（以行為單位），進行處理，檔案內容遍歷完畢后退出，

while read VAR; do
    BODY
done < /PATH/FROM/SOMEFILE

示例：列印UID為偶數的用戶的名稱、UID和默認shell，

#!/bin/bash

while read line; do
    userName=$(echo $line | cut -d : -f 1)
    userID=$(echo $line | cut -d : -f 3)
    userShell=$(echo $line | cut -d : -f 7)
    if [ $((userID%2)) -eq 0 ]; then
        echo "User name is $userName. User ID is $userID. User shell is $userShell."
    fi
done < /etc/passwd

使用for+cat命令替換也可以實作類似的功能，

for i in $(cat /PATH/TO/SOMEFILE); do
    echo $i
done

檔案中的每一行也會被賦值給i，但是如果行記憶體在空格，那么那一行會被理解為多行，因此比較穩妥的方法還是使用while的特殊用法，

until回圈

untile CONDITION; do
    CMD
done

與while回圈的進入回圈和退出回圈的邏輯正好相反，當CONDITION為假時，執行CMD，直到CONDITION為真的時候才退出回圈，

同樣，CMD中一般會包含一些可以在將來改變CONDITION的判定結果的操作，否則會出現死回圈，

until回圈和while回圈只是邏輯相反，因此用的比較少，while比較常用，

同樣我們也使用until回圈實作100以內的正整數之和的計算，

#!/bin/bash

declare -i sum=0
declare -i i=1
until [ $i -gt 100 ]; do
    ((sum+=i))
    ((i++))
done

echo "sum is $sum."

練習

1、使用四種回圈結構體實作乘法口訣表的正向和反向列印，

for回圈正向列印，

[root@c7-server ~]# cat for_jiujiu.sh 
#!/bin/bash

for i in {1..9}; do
    for j in $(seq $i); do
        echo -ne "$j*$i=$((i*j))\t"
    done
    echo
done
[root@c7-server ~]# bash for_jiujiu.sh
1*1=1    
1*2=2    2*2=4    
1*3=3    2*3=6    3*3=9    
1*4=4    2*4=8    3*4=12    4*4=16    
1*5=5    2*5=10    3*5=15    4*5=20    5*5=25    
1*6=6    2*6=12    3*6=18    4*6=24    5*6=30    6*6=36    
1*7=7    2*7=14    3*7=21    4*7=28    5*7=35    6*7=42    7*7=49    
1*8=8    2*8=16    3*8=24    4*8=32    5*8=40    6*8=48    7*8=56    8*8=64    
1*9=9    2*9=18    3*9=27    4*9=36    5*9=45    6*9=54    7*9=63    8*9=72    9*9=81

這里需要注意的一點，是：

for j in $(seq $i)

不可以換成

for j in {1..$i}

具體示例如下，

[root@c7-server ~]# echo {1..5}
1 2 3 4 5
[root@c7-server ~]# declare -i i=5
[root@c7-server ~]# echo {1..$i}
{1..5}

造成此結果的原因，在官方的關于大括號展開中有提及，

Brace expansion is performed before any other expansions, and any characters special to other expansions are preserved in the result. It is strictly textual. Bash does not apply any syntactic interpretation to the context of the expansion or the text between the braces.

for回圈的反向列印，只要將{1..9}換成{9..1}即可，

[root@c7-server ~]# bash for_jiujiu.sh
1*9=9    2*9=18    3*9=27    4*9=36    5*9=45    6*9=54    7*9=63    8*9=72    9*9=81    
1*8=8    2*8=16    3*8=24    4*8=32    5*8=40    6*8=48    7*8=56    8*8=64    
1*7=7    2*7=14    3*7=21    4*7=28    5*7=35    6*7=42    7*7=49    
1*6=6    2*6=12    3*6=18    4*6=24    5*6=30    6*6=36    
1*5=5    2*5=10    3*5=15    4*5=20    5*5=25    
1*4=4    2*4=8    3*4=12    4*4=16    
1*3=3    2*3=6    3*3=9    
1*2=2    2*2=4    
1*1=1

C風格的for回圈的正向列印，

#!/bin/bash

for ((i=1;i<=9;i++)); do
    for ((j=1;j<=i;j++)); do
        echo -ne "$j*$i=$((i*j))\t"
    done
    echo
done

C風格的for回圈的反向列印，

#!/bin/bash

for ((i=9;i>=1;i--)); do
    for ((j=1;j<=i;j++)); do
        echo -ne "$j*$i=$((i*j))\t"
    done
    echo
done

while回圈正向列印，

#!/bin/bash

declare -i i=1
while [ $i -le 9 ]; do
    declare -i j=1
    while [ $j -le $i ]; do
        echo -ne "$j*$i=$((i*j))\t"
        ((j++))
    done
    ((i++))
    echo
done

while回圈反向列印，

#!/bin/bash

declare -i i=9
while [ $i -gt 0 ]; do
    declare -i j=1
    while [ $j -le $i ]; do
        echo -ne "$j*$i=$((i*j))\t"
        ((j++))
    done
    ((i--))
    echo
done

until回圈正向列印，

#!/bin/bash

declare -i sum=0
declare -i i=1
until [ $i -gt 9 ]; do
    declare -i j=1
    until [ $j -gt $i ]; do
        echo -ne "$j*$i=$((i*j))\t"
        ((j++))
    done
    ((i++))
    echo
done

until回圈反向列印，

#!/bin/bash

declare -i sum=0
declare -i i=9
until [ $i -le 0 ]; do
    declare -i j=1
    until [ $j -gt $i ]; do
        echo -ne "$j*$i=$((i*j))\t"
        ((j++))
    done
    ((i--))
    echo
done

回圈控制指令

此前講解回圈時，回圈的每一輪，都是要執行的，直到回圈退出條件滿足時才退出，而回圈控制指令continue和break，可以改變這種默認的機制，

continue：結束本輪回圈，進入下一輪回圈，大致結構如下，

for i in LIST; do
    CMD1
    ...
    if TEST; then
        continue
    fi
    CMDn
    ...
done

進入下一輪回圈的條件是本輪回圈的BODY部分全部執行完，因此continue不應該放在整個BODY的末尾，否則就有點畫蛇添足了，

continue一般放在BODY的中間，結合某些判斷跳出本輪回圈，例如，當LIST是100以內的所有正整數時，求所有偶數之和，

#!/bin/bash

declare -i sum=0
for i in {1..100}; do
    if [ $((i%2)) -eq 1 ]; then
        continue
    fi
    ((sum+=i))
done
echo "sum is $sum."

break：直接結束所有的回圈，繼續執行腳本剩余的部分，這里要注意和exit區分，如果break出現的位置換成了exit的話，那么exit結束的是整個腳本，而不僅僅是回圈而已，腳本直接退出了，不會執行腳本剩余部分，

break一般會結合死回圈一起使用，死回圈一般會結合sleep命令一起使用，

sleep命令基本語法，

sleep n[suffix]

n：具體的數值，默認單位是秒，

suffix：后綴，表示單位，s秒、n分鐘、h小時、d天數，

大致的語法就是這個樣子，整個回圈是一個死回圈，sleep控制了死回圈的回圈間隔，防止消耗資源過多；if+break實作了對死回圈的控制，達到某個條件就退出，

while true; do
    CMD1
    ...
    if TEST; then
        break
    fi
    [CMDn
    ...]
    sleep ...
done

使用死回圈+break求100以內所有奇數之和，

#!/bin/bash

declare -i i=1
declare -i sum=0
while true; do
    if [ $i -gt 100 ]; then
        break
    fi
    ((sum+=i))
    ((i+=2))
done
echo "sum is $sum."

練習：每隔3秒監控系統中已登錄的用戶，如果發現alongdidi則記錄于日志中并退出腳本，

思路一：死回圈監控

[root@c7-server ~]# cat user_monitor.sh
#!/bin/bash

while true; do
    if who | grep "^alongdidi\>" &> /dev/null; then
        echo "$(date +"%F %T") alongdidi logined." >> /var/log/user_monitor.log
        break
    else
        sleep 3
    fi
done
[root@c7-server ~]# cat /var/log/user_monitor.log 
2020-01-14 15:52:32 alongdidi logined.

思路二：直到alongdidi登錄，否則繼續回圈，

#!/bin/bash

until who | grep "^alongdidi\>" &> /dev/null; do
    sleep 3
done
echo "$(date +"%F %T") alongdidi logined." >> /var/log/user_monitor.log

continue和break在使用的時候可以帶上引數n，

continue n：跳出n輪回圈，

break n：結束幾個回圈體，這種在嵌套回圈的情況下才會遇到，

while ...; do
    while ...; do
        break 2
    done
done

轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/141621.html

標籤：Linux

上一篇：Bash腳本編程學習筆記06：條件結構體

下一篇：谷歌BBR擁塞演算法內核更新

Bash腳本編程學習筆記07：回圈結構體

簡介