在我們 bash 學習旅程中的最后一站，我們將看一些零星的知識點。當然我們在之前的章節(jié)中已經(jīng) 涵蓋了很多方面，但是還有許多 bash 特性我們沒有涉及到。其中大部分特性相當晦澀，主要對 那些把 bash 集成到 Linux 發(fā)行版的程序有用處。然而還有一些特性，雖然不常用， 但是對某些程序問題是很有幫助的。我們將在這里介紹它們。
bash 允許把命令組合在一起?？梢酝ㄟ^兩種方式完成；要么用一個 group 命令，要么用一個子 shell。 這里是每種方式的語法示例：
組命令：
{ command1; command2; [command3; ...] }子 shell：
(command1; command2; [command3;...])這兩種形式的不同之處在于，組命令用花括號把它的命令包裹起來，而子 shell 用括號。值得注意的是，鑒于 bash 實現(xiàn)組命令的方式， 花括號與命令之間必須有一個空格，并且最后一個命令必須用一個分號或者一個換行符終止。
那么組命令和子 shell 命令對什么有好處呢？ 盡管它們有一個很重要的差異（我們馬上會接觸到），但它們都是用來管理重定向的。 讓我們考慮一個對多個命令執(zhí)行重定向的腳本片段。
ls -l > output.txt
echo "Listing of foo.txt" >> output.txt
cat foo.txt >> output.txt這些代碼相當簡潔明了。三個命令的輸出都重定向到一個名為 output.txt 的文件中。 使用一個組命令，我們可以重新編 寫這些代碼，如下所示：
{ ls -l; echo "Listing of foo.txt"; cat foo.txt; } > output.txt使用一個子 shell 是相似的：
(ls -l; echo "Listing of foo.txt"; cat foo.txt) > output.txt使用這樣的技術(shù)，我們?yōu)槲覀冏约汗?jié)省了一些打字時間，但是組命令和子 shell 真正閃光的地方是與管道線相結(jié)合。 當構(gòu)建一個管道線命令的時候，通常把幾個命令的輸出結(jié)果合并成一個流是很有用的。 組命令和子 shell 使這種操作變得很簡單：
{ ls -l; echo "Listing of foo.txt"; cat foo.txt; } | lpr這里我們已經(jīng)把我們的三個命令的輸出結(jié)果合并在一起，并把它們用管道輸送給命令 lpr 的輸入，以便產(chǎn)生一個打印報告。
在下面的腳本中，我們將使用組命令，看幾個與關(guān)聯(lián)數(shù)組結(jié)合使用的編程技巧。這個腳本，稱為 array-2，當給定一個目錄名，打印出目錄中的文件列表， 伴隨著每個文件的文件所有者和組所有者。在文件列表的末尾，腳本打印出屬于每個所有者和組的文件數(shù)目。 這里我們看到的結(jié)果（縮短的，為簡單起見），是給定腳本的目錄為 /usr/bin 的時候：
[me@linuxbox ~]$ array-2 /usr/bin
/usr/bin/2to3-2.6 root root
/usr/bin/2to3 root root
/usr/bin/a2p root root
/usr/bin/abrowser root root
/usr/bin/aconnect root root
/usr/bin/acpi_fakekey root root
/usr/bin/acpi_listen root root
/usr/bin/add-apt-repository root root
.
/usr/bin/zipgrep root root
/usr/bin/zipinfo root root
/usr/bin/zipnote root root
/usr/bin/zip root root
/usr/bin/zipsplit root root
/usr/bin/zjsdecode root root
/usr/bin/zsoelim root root
File owners:
daemon : 1 file(s)
root : 1394 file(s) File group owners:
crontab : 1 file(s)
daemon : 1 file(s)
lpadmin : 1 file(s)
mail : 4 file(s)
mlocate : 1 file(s)
root : 1380 file(s)
shadow : 2 file(s)
ssh : 1 file(s)
tty : 2 file(s)
utmp : 2 file(s)這里是腳本代碼列表（帶有行號）：
1 #!/bin/bash
2
3 # array-2: Use arrays to tally file owners
4
5 declare -A files file_group file_owner groups owners
6
7 if [[ ! -d "$1" ]]; then
8 echo "Usage: array-2 dir" >&2
9 exit 1
10 fi
11
12 for i in "$1"/*; do
13 owner=$(stat -c %U "$i")
14 group=$(stat -c %G "$i")
15 files["$i"]="$i"
16 file_owner["$i"]=$owner
17 file_group["$i"]=$group
18 ((++owners[$owner]))
19 ((++groups[$group]))
20 done
21
22 # List the collected files
23 { for i in "${files[@]}"; do
24 printf "%-40s %-10s %-10s\n" \
25 "$i" ${file_owner["$i"]} ${file_group["$i"]}
26 done } | sort
27 echo
28
29 # List owners
30 echo "File owners:"
31 { for i in "${!owners[@]}"; do
32 printf "%-10s: %5d file(s)\n" "$i" ${owners["$i"]}
33 done } | sort
34 echo
35
36 # List groups
37 echo "File group owners:"
38 { for i in "${!groups[@]}"; do
39 printf "%-10s: %5d file(s)\n" "$i" ${groups["$i"]}
40 done } | sort讓我們看一下這個腳本的運行機制：
行5： 關(guān)聯(lián)數(shù)組必須用帶有 -A 選項的 declare 命令創(chuàng)建。在這個腳本中我們創(chuàng)建了如下五個數(shù)組：
files 包含了目錄中文件的名字，按文件名索引
file_group 包含了每個文件的組所有者，按文件名索引
file_owner 包含了每個文件的所有者，按文件名索引
groups 包含了屬于索引的組的文件數(shù)目
owners 包含了屬于索引的所有者的文件數(shù)目
行7-10：查看是否一個有效的目錄名作為位置參數(shù)傳遞給程序。如果不是，就會顯示一條使用信息，并且腳本退出，退出狀態(tài)為1。
行12-20：循環(huán)遍歷目錄中的所有文件。使用 stat 命令，行13和行14抽取文件所有者和組所有者， 并把值賦給它們各自的數(shù)組（行16，17），使用文件名作為數(shù)組索引。同樣地，文件名自身也賦值給 files 數(shù)組。
行18-19：屬于文件所有者和組所有者的文件總數(shù)各自加1。
行22-27：輸出文件列表。為做到這一點，使用了 “${array[@]}” 參數(shù)展開，展開成整個的數(shù)組元素列表， 并且每個元素被當做是一個單獨的詞。從而允許文件名包含空格的情況。也要注意到整個循環(huán)是包裹在花括號中， 從而形成了一個組命令。這樣就允許整個循環(huán)輸出會被管道輸送給 sort 命令的輸入。這是必要的，因為 展開的數(shù)組元素是無序的。
行29-40：這兩個循環(huán)與文件列表循環(huán)相似，除了它們使用 “${!array[@]}” 展開，展開成數(shù)組索引的列表 而不是數(shù)組元素的。
雖然組命令和子 shell 看起來相似，并且它們都能用來在重定向中合并流，但是兩者之間有一個很重要的不同。 然而，一個組命令在當前 shell 中執(zhí)行它的所有命令，而一個子 shell（顧名思義）在當前 shell 的一個 子副本中執(zhí)行它的命令。這意味著運行環(huán)境被復(fù)制給了一個新的 shell 實例。當這個子 shell 退出時，環(huán)境副本會消失， 所以在子 shell 環(huán)境（包括變量賦值）中的任何更改也會消失。因此，在大多數(shù)情況下，除非腳本要求一個子 shell， 組命令比子 shell 更受歡迎。組命令運行很快并且占用的內(nèi)存也少。
我們在第20章中看到過一個子 shell 運行環(huán)境問題的例子，當我們發(fā)現(xiàn)管道線中的一個 read 命令 不按我們所期望的那樣工作的時候。為了重現(xiàn)問題，我們構(gòu)建一個像這樣的管道線：
echo "foo" | read
echo $REPLY該 REPLY 變量的內(nèi)容總是為空，是因為這個 read 命令在一個子 shell 中執(zhí)行，所以它的 REPLY 副本會被毀掉， 當該子 shell 終止的時候。因為管道線中的命令總是在子 shell 中執(zhí)行，任何給變量賦值的命令都會遭遇這樣的問題。 幸運地是，shell 提供了一種奇異的展開方式，叫做進程替換，它可以用來解決這種麻煩。進程替換有兩種表達方式：
一種適用于產(chǎn)生標準輸出的進程：
<(list)另一種適用于接受標準輸入的進程：
>(list)這里的 list 是一串命令列表：
為了解決我們的 read 命令問題，我們可以雇傭進程替換，像這樣：
read < <(echo "foo")
echo $REPLY進程替換允許我們把一個子 shell 的輸出結(jié)果當作一個用于重定向的普通文件。事實上，因為它是一種展開形式，我們可以檢驗它的真實值：
[me@linuxbox ~]$ echo <(echo "foo")
/dev/fd/63通過使用 echo 命令，查看展開結(jié)果，我們看到子 shell 的輸出結(jié)果，由一個名為 /dev/fd/63 的文件提供。
進程替換經(jīng)常被包含 read 命令的循環(huán)用到。這里是一個 read 循環(huán)的例子，處理一個目錄列表的內(nèi)容，內(nèi)容創(chuàng)建于一個子 shell：
#!/bin/bash
# pro-sub : demo of process substitution
while read attr links owner group size date time filename; do
cat <<- EOF
Filename: $filename
Size: $size
Owner: $owner
Group: $group
Modified: $date $time
Links: $links
Attributes: $attr
EOF
done < <(ls -l | tail -n +2)這個循環(huán)對目錄列表的每一個條目執(zhí)行 read 命令。列表本身產(chǎn)生于該腳本的最后一行代碼。這一行代碼把從進程替換得到的輸出 重定向到這個循環(huán)的標準輸入。這個包含在管道線中的 tail 命令，是為了消除列表的第一行文本，這行文本是多余的。
當腳本執(zhí)行后，腳本產(chǎn)生像這樣的輸出：
[me@linuxbox ~]$ pro_sub | head -n 20
Filename: addresses.ldif
Size: 14540
Owner: me
Group: me
Modified: 2009-04-02 11:12
Links:
1
Attributes: -rw-r--r--
Filename: bin
Size: 4096
Owner: me
Group: me
Modified: 2009-07-10 07:31
Links: 2
Attributes: drwxr-xr-x
Filename: bookmarks.html
Size: 394213
Owner: me
Group: me在第10章中，我們看到過程序是怎樣響應(yīng)信號的。我們也可以把這個功能添加到我們的腳本中。然而到目前為止， 我們所編寫過的腳本還不需要這種功能（因為它們運行時間非常短暫，并且不創(chuàng)建臨時文件），大且更復(fù)雜的腳本 可能會受益于一個信息處理程序。
當我們設(shè)計一個大的，復(fù)雜的腳本的時候，若腳本仍在運行時，用戶注銷或關(guān)閉了電腦，這時候會發(fā)生什么，考慮到這一點非常重要。 當像這樣的事情發(fā)生了，一個信號將會發(fā)送給所有受到影響的進程。依次地，代表這些進程的程序會執(zhí)行相應(yīng)的動作，來確保程序 合理有序的終止。比方說，例如，我們編寫了一個會在執(zhí)行時創(chuàng)建臨時文件的腳本。在一個好的設(shè)計流程，我們應(yīng)該讓腳本刪除創(chuàng)建的 臨時文件，當腳本完成它的任務(wù)之后。若腳本接收到一個信號，表明該程序即將提前終止的信號， 此時讓腳本刪除創(chuàng)建的臨時文件，也會是很精巧的設(shè)計。
為滿足這樣需求，bash 提供了一種機制，眾所周知的 trap。陷阱由被恰當命令的內(nèi)部命令 trap 實現(xiàn)。 trap 使用如下語法：
trap argument signal [signal...]這里的 argument 是一個字符串，它被讀取并被當作一個命令，signal 是一個信號的說明，它會觸發(fā)執(zhí)行所要解釋的命令。
這里是一個簡單的例子：
#!/bin/bash
# trap-demo : simple signal handling demo
trap "echo 'I am ignoring you.'" SIGINT SIGTERM
for i in {1..5}; do
echo "Iteration $i of 5"
sleep 5
done這個腳本定義一個陷阱，當腳本運行的時候，這個陷阱每當接受到一個 SIGINT 或 SIGTERM 信號時，就會執(zhí)行一個 echo 命令。 當用戶試圖通過按下 Ctrl-c 組合鍵終止腳本運行的時候，該程序的執(zhí)行結(jié)果看起來像這樣：
[me@linuxbox ~]$ trap-demo
Iteration 1 of 5
Iteration 2 of 5
I am ignoring you.
Iteration 3 of 5
I am ignoring you.
Iteration 4 of 5
Iteration 5 of 5正如我們所看到的，每次用戶試圖中斷程序時，會打印出這條信息。
構(gòu)建一個字符串形成一個有用的命令序列是很笨拙的，所以通常的做法是指定一個 shell 函數(shù)作為命令。在這個例子中， 為每一個信號指定了一個單獨的 shell 函數(shù)來處理：
#!/bin/bash
# trap-demo2 : simple signal handling demo
exit_on_signal_SIGINT () {
echo "Script interrupted." 2>&1
exit 0
}
exit_on_signal_SIGTERM () {
echo "Script terminated." 2>&1
exit 0
}
trap exit_on_signal_SIGINT SIGINT
trap exit_on_signal_SIGTERM SIGTERM
for i in {1..5}; do
echo "Iteration $i of 5"
sleep 5
done這個腳本的特色是有兩個 trap 命令，每個命令對應(yīng)一個信號。每個 trap，依次，當接受到相應(yīng)的特殊信號時， 會執(zhí)行指定的 shell 函數(shù)。注意每個信號處理函數(shù)中都包含了一個 exit 命令。沒有 exit 命令， 信號處理函數(shù)執(zhí)行完后，該腳本將會繼續(xù)執(zhí)行。
當用戶在這個腳本執(zhí)行期間，按下 Ctrl-c 組合鍵的時候，輸出結(jié)果看起來像這樣：
[me@linuxbox ~]$ trap-demo2
Iteration 1 of 5
Iteration 2 of 5
Script interrupted.臨時文件
把信號處理程序包含在腳本中的一個原因是刪除臨時文件，在腳本執(zhí)行期間，腳本可能會創(chuàng)建臨時文件來存放中間結(jié)果。 命名臨時文件是一種藝術(shù)。傳統(tǒng)上，在類似于 unix 系統(tǒng)中的程序會在 /tmp 目錄下創(chuàng)建它們的臨時文件，/tmp 是 一個服務(wù)于臨時文件的共享目錄。然而，因為這個目錄是共享的，這會引起一定的安全顧慮，尤其對那些用 超級用戶特權(quán)運行的程序。除了為暴露給系統(tǒng)中所有用戶的文件設(shè)置合適的權(quán)限，這一明顯步驟之外， 給臨時文件一個不可預(yù)測的文件名是很重要的。這就避免了一種為大眾所知的 temp race 攻擊。 一種創(chuàng)建一個不可預(yù)測的（但是仍有意義的）臨時文件名的方法是，做一些像這樣的事情：
tempfile=/tmp/$(basename $0).$$.$RANDOM
這將創(chuàng)建一個由程序名字，程序進程的 ID（PID）文件名，和一個隨機整數(shù)組成。注意，然而，該 $RANDOM shell 變量 只能返回一個范圍在1-32767內(nèi)的整數(shù)值，這在計算機術(shù)語中不是一個很大的范圍，所以一個單一的該變量實例是不足以克服一個堅定的攻擊者的。
一個比較好的方法是使用 mktemp 程序（不要和 mktemp 標準庫函數(shù)相混淆）來命名和創(chuàng)建臨時文件。 這個 mktemp 程序接受一個用于創(chuàng)建文件名的模板作為參數(shù)。這個模板應(yīng)該包含一系列的 “X” 字符， 隨后這些字符會被相應(yīng)數(shù)量的隨機字母和數(shù)字替換掉。一連串的 “X” 字符越長，則一連串的隨機字符也就越長。 這里是一個例子：
tempfile=$(mktemp /tmp/foobar.$$.XXXXXXXXXX)
這里創(chuàng)建了一個臨時文件，并把臨時文件的名字賦值給變量 tempfile。因為模板中的 “X” 字符會被隨機字母和 數(shù)字代替，所以最終的文件名（在這個例子中，文件名也包含了特殊參數(shù) $$ 的展開值，進程的 PID）可能像這樣：
/tmp/foobar.6593.UOZuvM6654
對于那些由普通用戶操作執(zhí)行的腳本，避免使用 /tmp 目錄，而是在用戶家目錄下為臨時文件創(chuàng)建一個目錄， 通過像這樣的一行代碼：
[[ -d $HOME/tmp ]] || mkdir $HOME/tmp
有時候需要同時執(zhí)行多個任務(wù)。我們已經(jīng)知道現(xiàn)在所有的操作系統(tǒng)若不是多用戶的但至少是多任務(wù)的。 腳本也可以構(gòu)建成多任務(wù)處理的模式。
通常這涉及到啟動一個腳本，依次，啟動一個或多個子腳本來執(zhí)行額外的任務(wù)，而父腳本繼續(xù)運行。然而，當一系列腳本 以這種方式運行時，要保持父子腳本之間協(xié)調(diào)工作，會有一些問題。也就是說，若父腳本或子腳本依賴于另一方，并且 一個腳本必須等待另一個腳本結(jié)束任務(wù)之后，才能完成它自己的任務(wù)，這應(yīng)該怎么辦？
bash 有一個內(nèi)置命令，能幫助管理諸如此類的異步執(zhí)行的任務(wù)。wait 命令導致一個父腳本暫停運行，直到一個 特定的進程（例如，子腳本）運行結(jié)束。
首先我們將演示一下 wait 命令的用法。為此，我們需要兩個腳本，一個父腳本：
#!/bin/bash
# async-parent : Asynchronous execution demo (parent)
echo "Parent: starting..."
echo "Parent: launching child script..."
async-child &
pid=$!
echo "Parent: child (PID= $pid) launched."
echo "Parent: continuing..."
sleep 2
echo "Parent: pausing to wait for child to finish..."
wait $pid
echo "Parent: child is finished. Continuing..."
echo "Parent: parent is done. Exiting."和一個子腳本：
#!/bin/bash
# async-child : Asynchronous execution demo (child)
echo "Child: child is running..."
sleep 5
echo "Child: child is done. Exiting."在這個例子中，我們看到該子腳本是非常簡單的。真正的操作通過父腳本完成。在父腳本中，子腳本被啟動， 并被放置到后臺運行。子腳本的進程 ID 記錄在 pid 變量中，這個變量的值是 $! shell 參數(shù)的值，它總是 包含放到后臺執(zhí)行的最后一個任務(wù)的進程 ID 號。
父腳本繼續(xù)，然后執(zhí)行一個以子進程 PID 為參數(shù)的 wait 命令。這就導致父腳本暫停運行，直到子腳本退出， 意味著父腳本結(jié)束。
當執(zhí)行后，父子腳本產(chǎn)生如下輸出：
[me@linuxbox ~]$ async-parent
Parent: starting...
Parent: launching child script...
Parent: child (PID= 6741) launched.
Parent: continuing...
Child: child is running...
Parent: pausing to wait for child to finish...
Child: child is done. Exiting.
Parent: child is finished. Continuing...
Parent: parent is done. Exiting.在大多數(shù)類似也 Unix 的操作系統(tǒng)中，有可能創(chuàng)建一種特殊類型的餓文件，叫做命名管道。命名管道用來在 兩個進程之間建立連接，也可以像其它類型的文件一樣使用。雖然它們不是那么流行，但是它們值得我們?nèi)チ私狻?/p>
有一種常見的編程架構(gòu)，叫做客戶端-服務(wù)器，它可以利用像命名管道這樣的通信方式， 也可以使用其它類型的進程間通信方式，比如網(wǎng)絡(luò)連接。
最為廣泛使用的客戶端-服務(wù)器系統(tǒng)類型是，當然，一個 web 瀏覽器與一個 web 服務(wù)器之間進行通信。 web 瀏覽器作為客戶端，向服務(wù)器發(fā)出請求，服務(wù)器響應(yīng)請求，并把對應(yīng)的網(wǎng)頁發(fā)送給瀏覽器。
命令管道的行為類似于文件，但實際上形成了先入先出（FIFO）的緩沖。和普通（未命令的）管道一樣， 數(shù)據(jù)從一端進入，然后從另一端出現(xiàn)。通過命令管道，有可能像這樣設(shè)置一些東西：
process1 > named_pipe和
process2 < named_pipe表現(xiàn)出來就像這樣：
process1 | process2首先，我們必須創(chuàng)建一個命名管道。使用 mkfifo 命令能夠創(chuàng)建命令管道：
[me@linuxbox ~]$ mkfifo pipe1
[me@linuxbox ~]$ ls -l pipe1
prw-r--r-- 1 me
me
0 2009-07-17 06:41 pipe1這里我們使用 mkfifo 創(chuàng)建了一個名為 pipe1 的命名管道。使用 ls 命令，我們查看這個文件， 看到位于屬性字段的第一個字母是 “p”，表明它是一個命名管道。
為了演示命名管道是如何工作的，我們將需要兩個終端窗口（或用兩個虛擬控制臺代替）。 在第一個終端中，我們輸入一個簡單命令，并把命令的輸出重定向到命名管道：
[me@linuxbox ~]$ ls -l > pipe1我們按下 Enter 按鍵之后，命令將會掛起。這是因為在管道的另一端沒有任何接受數(shù)據(jù)。當這種現(xiàn)象發(fā)生的時候， 據(jù)說是管道阻塞了。一旦我們綁定一個進程到管道的另一端，該進程開始從管道中讀取輸入的時候，這種情況會消失。 使用第二個終端窗口，我們輸入這個命令：
[me@linuxbox ~]$ cat < pipe1然后產(chǎn)自第一個終端窗口的目錄列表出現(xiàn)在第二個終端中，并作為來自 cat 命令的輸出。在第一個終端 窗口中的 ls 命令一旦它不再阻塞，會成功地結(jié)束。
嗯，我們已經(jīng)完成了我們的旅程?，F(xiàn)在剩下的唯一要做的事就是練習，練習，再練習。 縱然在我們的長途跋涉中，我們涉及了很多命令，但是就命令行而言，我們只是觸及了它的表面。 仍留有成千上萬的命令行程序，需要去發(fā)現(xiàn)和享受。開始挖掘 /usr/bin 目錄吧，你將會看到！
bash 手冊頁的 “復(fù)合命令” 部分包含了對組命令和子 shell 表示法的詳盡描述。
bash 手冊也的 EXPANSION 部分包含了一小部分進程替換的內(nèi)容：
《高級 Bash 腳本指南》也有對進程替換的討論：
《Linux 雜志》有兩篇關(guān)于命令管道的好文章。第一篇，源于1997年9月：
和第二篇，源于2009年3月：
http://www.linuxjournal.com/content/using-named-pipes-fifos-bash
掃碼關(guān)注鍍金池微信號
手機訂課，優(yōu)惠多多