轉(zhuǎn)自：
http://blog.csdn.net/chinalinuxzend/archive/2007/10/16/1826623.aspxshell 十三問(wèn)：
1) 為何叫做 shell ？
2) shell prompt(PS1) 與 Carriage Return(CR) 的關(guān)系？
3) 別人 echo、你也 echo ，是問(wèn) echo 知多少？
4) " "(雙引號(hào)) 與 ' '(單引號(hào))差在哪？
5) var=value？export 前后差在哪？
6) exec 跟 source 差在哪？
7) ( ) 與 { } 差在哪？
8) $(( )) 與 $( ) 還有${ } 差在哪？
9) $@ 與 $* 差在哪？
10) && 與 || 差在哪？
11) >; 與 < 差在哪？
12) 你要 if 還是 case 呢？
13) for what? while 與 until 差在哪？
------------------------------------------------------------------------------------------------------------
1) 為何叫做 shell ？
在介紹 shell 是甚么東西之前，不妨讓我們重新檢視使用者與計(jì)算機(jī)系統(tǒng)的關(guān)系：
我們知道計(jì)算機(jī)的運(yùn)作不能離開硬件，但使用者卻無(wú)法直接對(duì)硬件作驅(qū)動(dòng)，硬件的驅(qū)動(dòng)只能透過(guò)一個(gè)稱為"操作系統(tǒng)(Operating System)"的軟件來(lái)控管，事實(shí)上，我們每天所談的
linux ，嚴(yán)格來(lái)說(shuō)只是一個(gè)操作系統(tǒng)，我們稱之為"核心(kernel)"。然而，從使用者的角度來(lái)說(shuō)，使用者也沒(méi)辦法直接操作 kernel ，而是透過(guò) kernel 的"外殼"程序，也就是所謂的 shell ，來(lái)與 kernel 溝通。這也正是 kernel 跟 shell 的形像命名關(guān)系。
從技術(shù)角度來(lái)說(shuō)，shell 是一個(gè)使用者與系統(tǒng)的互動(dòng)界面(interface)，主要是讓使用者透過(guò)命令行(command line)來(lái)使用系統(tǒng)以完成工作。因此，shell 的最簡(jiǎn)單的定義就是---命令解譯器(Command Interpreter)：
* 將使用者的命令翻譯給核心處理，
* 同時(shí)，將核心處理結(jié)果翻譯給使用者。
每次當(dāng)我們完成系統(tǒng)登入(log in)，我們就取得一個(gè)互動(dòng)模式的 shell ，也稱為 login shell 或 primary shell。若從行程(process)角度來(lái)說(shuō)，我們?cè)?shell 所下達(dá)的命令，均是 shell 所產(chǎn)生的子行程。這現(xiàn)像，我們暫可稱之為 fork 。如果是執(zhí)行腳本(shell script)的話，腳本中的命令則是由另外一個(gè)非互動(dòng)模式的子 shell (sub shell)來(lái)執(zhí)行的。也就是 primary shell 產(chǎn)生 sub shell 的行程，sub shell 再產(chǎn)生 script 中所有命令的行程。
(關(guān)于行程，我們?nèi)蘸笥袡C(jī)會(huì)再補(bǔ)充。)
這里，我們必須知道：kernel 與 shell 是不同的兩套軟件，而且都是可以被替換的：
* 不同的操作系統(tǒng)使用不同的 kernel ，
* 而在同一個(gè) kernel 之上，也可使用不同的 shell 。
在
linux 的預(yù)設(shè)系統(tǒng)中，通常都可以找到好幾種不同的 shell ，且通常會(huì)被列于如下檔案里：
/etc/shells
不同的 shell 有著不同的功能，且也彼此各異、或說(shuō)"大同小異"。常見的 shell 主要分為兩大主流：
sh：
burne shell (sh)
burne again shell (bash)
csh：
c shell (csh)
tc shell (tcsh)
korn shell (ksh)
大部份的
linux 系統(tǒng)的預(yù)設(shè) shell 都是 bash ，其原因大致如下兩點(diǎn)：
* 自由軟件
* 功能強(qiáng)大
bash 是 gnu project 最成功的產(chǎn)品之一，自推出以來(lái)深受廣大 Unix 用戶喜愛，且也逐漸成為不少組織的系統(tǒng)標(biāo)準(zhǔn)。
------------------------------------------------------------------
2) shell prompt(PS1) 與 Carriage Return(CR) 的關(guān)系？
當(dāng)你成功登錄進(jìn)一個(gè)文字界面之后，大部份情形下，你會(huì)在熒幕上看到一個(gè)不斷閃爍的方塊或底線(視不同版本而別)，
我們稱之為*游標(biāo)*(coursor)。游標(biāo)的作用就是告訴你接下來(lái)你從鍵盤輸入的按鍵所插入的位置，且每輸如一鍵游標(biāo)便向右邊移動(dòng)一個(gè)格子，若連續(xù)輸入太多的話，則自動(dòng)接在下一行輸入。
假如你剛完成登錄還沒(méi)輸入任何按鍵之前，你所看到的游標(biāo)所在位置的同一行的左邊部份，我們稱之為*提示符號(hào)*(prompt)。提示符號(hào)的格式或因不同系統(tǒng)版本而各有不同，在
linux 上，只需留意最接近游標(biāo)的一個(gè)可見的提示符號(hào)，通常是如下兩者之一：
$：給一般使用者賬號(hào)使用
#：給 root (管理員)賬號(hào)使用
事實(shí)上，shell prompt 的意思很簡(jiǎn)單：
* 是 shell 告訴使用者：您現(xiàn)在可以輸入命令行了。我們可以說(shuō)，使用者只有在得到 shell prompt 才能打命令行，
而 cursor 是指示鍵盤在命令行所輸入的位置，使用者每輸入一個(gè)鍵，cursor 就往后移動(dòng)一格，直到碰到命令行讀進(jìn) CR(Carriage Return，由 Enter 鍵產(chǎn)生)字符為止。CR 的意思也很簡(jiǎn)單：
* 是使用者告訴 shell：老兄你可以執(zhí)行我的命令行了。
嚴(yán)格來(lái)說(shuō)：
* 所謂的命令行，就是在 shell prompt 與 CR 字符之間所輸入的文字。 (思考：為何我們這里堅(jiān)持使用 CR 字符而不說(shuō) Enter 鍵呢？答案在后面的學(xué)習(xí)中揭曉。)
不同的命令可接受的命令行格式或有不同，一般情況下，一個(gè)標(biāo)準(zhǔn)的命令行格式為如下所列：
command-name options argument
若從技術(shù)細(xì)節(jié)來(lái)看，shell 會(huì)依據(jù) IFS(Internal Field Seperator) 將 command line 所輸入的文字給拆解為"字段"(word)。
然后再針對(duì)特殊字符(meta)先作處理，最后再重組整行 command line 。(注意：請(qǐng)務(wù)必理解上兩句話的意思，我們?nèi)蘸蟮膶W(xué)習(xí)中會(huì)常回到這里思考。)
其中的 IFS 是 shell 預(yù)設(shè)使用的字段分隔符，可以由一個(gè)及多個(gè)如下按鍵組成：
* 空格鍵(White Space)
* 表格鍵(Tab)
* 回車鍵(Enter)
系統(tǒng)可接受的命令名稱(command-name)可以從如下途徑獲得：
* 明確路徑所指定的外部命令
* 命令別名(alias)
* 自定功能(function)
* shell 內(nèi)建命令(built-in)
* $PATH 之下的外部命令
每一個(gè)命令行均必需含用命令名稱，這是不能缺少的。
---------------------------------------------------------------------------------------------
3) 別人 echo、你也 echo ，是問(wèn) echo 知多少？
承接上一章所介紹的 command line ，這里我們用 echo 這個(gè)命令加以進(jìn)一步說(shuō)明。溫習(xí)---標(biāo)準(zhǔn)的 command line 包含三個(gè)部件：* command_name option argument
echo 是一個(gè)非常簡(jiǎn)單、直接的
linux 命令：* 將 argument 送出至標(biāo)準(zhǔn)輸出(STDOUT)，通常就是在監(jiān)視器(monitor)上輸出。為了更好理解，不如先讓我們先跑一下 echo 命令好了：
$ echo
$
你會(huì)發(fā)現(xiàn)只有一個(gè)空白行，然后又回到 shell prompt 上了。這是因?yàn)?echo 在預(yù)設(shè)上，在顯示完 argument 之后，還會(huì)送出一個(gè)換行符號(hào)(new-line charactor)。但是上面的 command 并沒(méi)任何的 argument ，那結(jié)果就只剩一個(gè)換行符號(hào)了...
若你要取消這個(gè)換行符號(hào)，可利用 echo 的 -n option ：
$ echo -n
$
不妨讓我們回到 command line 的概念上來(lái)討論上例的 echo 命令好了：
* command line 只有 command_name(echo) 及 option(-n)，并沒(méi)有任何 argument 。
要想看看 echo 的 argument ，那還不簡(jiǎn)單﹗接下來(lái)，你可試試如下的輸入：
CODE:[Copy to clipboard]$ echo first line
first line
$ echo -n first line
first line $
于上兩個(gè) echo 命令中，你會(huì)發(fā)現(xiàn) argument 的部份顯示在你的熒幕，而換行符號(hào)則視 -n option 的有無(wú)而別。
很明顯的，第二個(gè) echo 由于換行符號(hào)被取消了，接下來(lái)的 shell prompt 就接在輸出結(jié)果同一行了... ^_^
事實(shí)上，echo 除了 -n options 之外，常用選項(xiàng)還有：
-e ：?jiǎn)⒂梅葱本€控制字符的轉(zhuǎn)換(參考下表)
-E：關(guān)閉反斜線控制字符的轉(zhuǎn)換(預(yù)設(shè)如此)
-n ：取消行末之換行符號(hào)(與 -e 選項(xiàng)下的 \c 字符同意)
關(guān)于 echo 命令所支持的反斜線控制字符如下表：
\a：ALERT / BELL (從系統(tǒng)喇叭送出鈴聲)
\b：BACKSPACE ，也就是向左刪除鍵
\c：取消行末之換行符號(hào)
\E：ESCAPE，跳脫鍵
\f：FORMFEED，換頁(yè)字符
\n：NEWLINE，換行字符
\r：RETURN，回車鍵
\t：TAB，表格跳位鍵
\v：VERTICAL TAB，垂直表格跳位鍵
\n：ASCII 八進(jìn)位編碼(以 x 開首為十六進(jìn)制)
\\：反斜線本身
(表格數(shù)據(jù)來(lái)自 O'Reilly 出版社之 Learning the Bash Shell, 2nd Ed.)
或許，我們可以透過(guò)實(shí)例來(lái)了解 echo 的選項(xiàng)及控制字符：
例一：
CODE:[Copy to clipboard]$ echo -e "a\tb\tc\nd\te\tf"
a b c
d e f
上例運(yùn)用 \t 來(lái)區(qū)隔 abc 還有 def ，及用 \n 將 def 換至下一行。
例二：
CODE:[Copy to clipboard]$ echo -e "\141\011\142\011\143\012\144\011\145\011\146"
a b c
d e f
與例一的結(jié)果一樣，只是使用 ASCII 八進(jìn)位編碼。
例三：
CODE:[Copy to clipboard]$ echo -e "\x61\x09\x62\x09\x63\x0a\x64\x09\x65\x09\x66"
a b c
d e f
與例二差不多，只是這次換用 ASCII 十六進(jìn)制編碼。
例四：
CODE:[Copy to clipboard]$ echo -ne "a\tb\tc\nd\te\bf\a"
a b c
d f $
因?yàn)?e 字母后面是刪除鍵(\b)，因此輸出結(jié)果就沒(méi)有 e 了。
在結(jié)束時(shí)聽到一聲鈴向，那是 \a 的杰作﹗
由于同時(shí)使用了 -n 選項(xiàng)，因此 shell prompt 緊接在第二行之后。
若你不用 -n 的話，那你在 \a 后再加個(gè) \c ，也是同樣的效果。
事實(shí)上，在日后的 shell 操作及 shell script 設(shè)計(jì)上，echo 命令是最常被使用的命令之一。
比方說(shuō)，用 echo 來(lái)檢查變量值：
CODE:[Copy to clipboard]$ A=B
$ echo $A
B
$ echo $?
0
(注：關(guān)于變量概念，我們留到下兩章才跟大家說(shuō)明。)
好了，更多的關(guān)于 command line 的格式，以及 echo 命令的選項(xiàng)，
就請(qǐng)您自行多加練習(xí)、運(yùn)用了...
-------------------------------------------------------------------------------------------------------------
4) " "(雙引號(hào)) 與 ' '(單引號(hào))差在哪？
還是回到我們的 command line 來(lái)吧...
經(jīng)過(guò)前面兩章的學(xué)習(xí)，應(yīng)該很清楚當(dāng)你在 shell prompt 后面敲打鍵盤、直到按下 Enter 的時(shí)候，
你輸入的文字就是 command line 了，然后 shell 才會(huì)以行程的方式執(zhí)行你所交給它的命令。
但是，你又可知道：你在 command line 輸入的每一個(gè)文字，對(duì) shell 來(lái)說(shuō)，是有類別之分的呢？
簡(jiǎn)單而言(我不敢說(shuō)這是精確的定議，注一)，command line 的每一個(gè) charactor ，分為如下兩種：
* literal：也就是普通純文字，對(duì) shell 來(lái)說(shuō)沒(méi)特殊功能。
* meta：對(duì) shell 來(lái)說(shuō)，具有特定功能的特殊保留字符。
(注一：關(guān)于 bash shell 在處理 command line 時(shí)的順序說(shuō)明，
請(qǐng)參考 O'Reilly 出版社之 Learning the Bash Shell, 2nd Edition，第 177 - 180 頁(yè)的說(shuō)明，
尤其是 178 頁(yè)的流程圖 Figure 7-1 ... )
Literal 沒(méi)甚么好談的，凡舉 abcd、123456 這些"文字"都是 literal ... (easy？)
但 meta 卻常使我們困惑..... (confused?)
事實(shí)上，前兩章我們?cè)?command line 中已碰到兩個(gè)機(jī)乎每次都會(huì)碰到的 meta ：
* IFS：由 <space>; 或 <tab>; 或 <enter>; 三者之一組成(我們常用 space )。
* CR：由 <enter>; 產(chǎn)生。
IFS 是用來(lái)拆解 command line 的每一個(gè)詞(word)用的，因?yàn)?shell command line 是按詞來(lái)處理的。
而 CR 則是用來(lái)結(jié)束 command line 用的，這也是為何我們敲 <enter>; 命令就會(huì)跑的原因。
除了 IFS 與 CR ，常用的 meta 還有：
= ： 設(shè)定變量。
$ ： 作變量或運(yùn)算替換(請(qǐng)不要與 shell prompt 搞混了)。
>; ：重導(dǎo)向 stdout。
< ：重導(dǎo)向 stdin。
|：命令管線。
& ：重導(dǎo)向 file descriptor ，或?qū)⒚钪糜诒尘硤?zhí)行。
( )：將其內(nèi)的命令置于 nested subshell 執(zhí)行，或用于運(yùn)算或命令替換。
{ }：將其內(nèi)的命令置于 non-named function 中執(zhí)行，或用在變量替換的界定范圍。
; ：在前一個(gè)命令結(jié)束時(shí)，而忽略其返回值，繼續(xù)執(zhí)行下一個(gè)命令。
&& ：在前一個(gè)命令結(jié)束時(shí)，若返回值為 true，繼續(xù)執(zhí)行下一個(gè)命令。
|| ：在前一個(gè)命令結(jié)束時(shí)，若返回值為 false，繼續(xù)執(zhí)行下一個(gè)命令。
!：執(zhí)行 history 列表中的命令
....
假如我們需要在 command line 中將這些保留字符的功能關(guān)閉的話，就需要 quoting 處理了。
在 bash 中，常用的 quoting 有如下三種方法：
* hard quote：' ' (單引號(hào))，凡在 hard quote 中的所有 meta 均被關(guān)閉。
* soft quote： " " (雙引號(hào))，在 soft quoe 中大部份 meta 都會(huì)被關(guān)閉，但某些則保留(如 $ )。(注二)
* escape ： \ (反斜線)，只有緊接在 escape (跳脫字符)之后的單一 meta 才被關(guān)閉。
( 注二：在 soft quote 中被豁免的具體 meta 清單，我不完全知道，
有待大家補(bǔ)充，或透過(guò)實(shí)作來(lái)發(fā)現(xiàn)及理解。 )
下面的例子將有助于我們對(duì) quoting 的了解：
CODE:[Copy to clipboard] $ A=B C # 空格鍵未被關(guān)掉，作為 IFS 處理。
$ C: command not found.
$ echo $A
$ A="B C" # 空格鍵已被關(guān)掉，僅作為空格鍵處理。
$ echo $A
B C
在第一次設(shè)定 A 變量時(shí)，由于空格鍵沒(méi)被關(guān)閉，command line 將被解讀為：
* A=B 然后碰到<IFS>;，再執(zhí)行 C 命令
在第二次設(shè)定 A 變量時(shí)，由于空格鍵被置于 soft quote 中，因此被關(guān)閉，不再作為 IFS ：
* A=B<space>;C
事實(shí)上，空格鍵無(wú)論在 soft quote 還是在 hard quote 中，均會(huì)被關(guān)閉。Enter 鍵亦然：
CODE:[Copy to clipboard] $ A='B
>; C
>; '
$ echo "$A"
B
C
在上例中，由于 <enter>; 被置于 hard quote 當(dāng)中，因此不再作為 CR 字符來(lái)處理。
這里的 <enter>; 單純只是一個(gè)斷行符號(hào)(new-line)而已，由于 command line 并沒(méi)得到 CR 字符，
因此進(jìn)入第二個(gè) shell prompt (PS2，以 >; 符號(hào)表示)，command line 并不會(huì)結(jié)束，
直到第三行，我們輸入的 <enter>; 并不在 hard quote 里面，因此并沒(méi)被關(guān)閉，
此時(shí)，command line 碰到 CR 字符，于是結(jié)束、交給 shell 來(lái)處理。
上例的 <enter>; 要是被置于 soft quote 中的話， CR 也會(huì)同樣被關(guān)閉：
CODE:[Copy to clipboard] $ A="B
>; C
>; "
$ echo $A
B C
然而，由于 echo $A 時(shí)的變量沒(méi)至于 soft quote 中，因此當(dāng)變量替換完成后并作命令行重組時(shí)，<enter>; 會(huì)被解釋為 IFS ，而不是解釋為 New Line 字符。
同樣的，用 escape 亦可關(guān)閉 CR 字符：
CODE:[Copy to clipboard] $ A=B\
>; C\
>;
$ echo $A
BC
上例中，第一個(gè) <enter>; 跟第二個(gè) <enter>; 均被 escape 字符關(guān)閉了，因此也不作為 CR 來(lái)處理，
但第三個(gè) <enter>; 由于沒(méi)被跳脫，因此作為 CR 結(jié)束 command line 。
但由于 <enter>; 鍵本身在 shell meta 中的特殊性，在 \ 跳脫后面，僅僅取消其 CR 功能，而不會(huì)保留其 IFS 功能。
您或許發(fā)現(xiàn)光是一個(gè) <enter>; 鍵所產(chǎn)生的字符就有可能是如下這些可能：
CR
IFS
NL(New Line)
FF(Form Feed)
NULL
...
至于甚么時(shí)候會(huì)解釋為甚么字符，這個(gè)我就沒(méi)去深挖了，或是留給讀者諸君自行慢慢摸索了... ^_^
至于 soft quote 跟 hard quote 的不同，主要是對(duì)于某些 meta 的關(guān)閉與否，以 $ 來(lái)作說(shuō)明：
CODE:[Copy to clipboard] $ A=B\ C
$ echo "$A"
B C
$ echo '$A'
$A
在第一個(gè) echo 命令行中，$ 被置于 soft quote 中，將不被關(guān)閉，因此繼續(xù)處理變量替換，
因此 echo 將 A 的變量值輸出到熒幕，也就得到 "B C" 的結(jié)果。
在第二個(gè) echo 命令行中，$ 被置于 hard quote 中，則被關(guān)閉，因此 $ 只是一個(gè) $ 符號(hào)，
并不會(huì)用來(lái)作變量替換處理，因此結(jié)果是 $ 符號(hào)后面接一個(gè) A 字母：$A 。
--------------------------------------
練習(xí)與思考：如下結(jié)果為何不同？
CODE:[Copy to clipboard] $ A=B\ C
$ echo '"$A"' # 最外面的是單引號(hào)
"$A"
$ echo "'$A'" # 最外面的是雙引號(hào)
'B C'
(提示：?jiǎn)我?hào)及雙引號(hào)，在 quoting 中均被關(guān)?#93;了。)
--------------------------------------
在 CU 的 shell 版里，我發(fā)現(xiàn)有很多初學(xué)者的問(wèn)題，都與 quoting 理解的有關(guān)。
比方說(shuō)，若我們?cè)?awk 或 sed 的命令參數(shù)中調(diào)用之前設(shè)定的一些變量時(shí)，常會(huì)問(wèn)及為何不能的問(wèn)題。
要解決這些問(wèn)題，關(guān)鍵點(diǎn)就是：
* 區(qū)分出 shell meta 與 command meta
前面我們提到的那些 meta ，都是在 command line 中有特殊用途的，
比方說(shuō) { } 是將其內(nèi)一系列 command line 置于不具名的函式中執(zhí)行(可簡(jiǎn)單視為 command block )，
但是，awk 卻需要用 { } 來(lái)區(qū)分出 awk 的命令區(qū)段(BEGIN, MAIN, END)。
若你在 command line 中如此輸入：
CODE:[Copy to clipboard]$ awk {print $0} 1.txt
由于 { } 在 shell 中并沒(méi)關(guān)閉，那 shell 就將 {print $0} 視為 command block ，
但同時(shí)又沒(méi)有" ; "符號(hào)作命令區(qū)隔，因此就出現(xiàn) awk 的語(yǔ)法錯(cuò)誤結(jié)果。
要解決之，可用 hard quote ：
CODE:[Copy to clipboard]$ awk '{print $0}' 1.txt
上面的 hard quote 應(yīng)好理解，就是將原本的 {、<space>;、$(注三)、} 這幾個(gè) shell meta 關(guān)閉，
避免掉在 shell 中遭到處理，而完整的成為 awk 參數(shù)中的 command meta 。
( 注三：而其中的 $0 是 awk 內(nèi)建的 field number ，而非 awk 的變量，
awk 自身的變量無(wú)需使用 $ 。)
要是理解了 hard quote 的功能，再來(lái)理解 soft quote 與 escape 就不難：
CODE:[Copy to clipboard]awk "{print \$0}" 1.txt
awk \{print\ \$0\} 1.txt
然而，若你要改變 awk 的 $0 的 0 值是從另一個(gè) shell 變量讀進(jìn)呢？
比方說(shuō)：已有變量 $A 的值是 0 ，那如何在 command line 中解決 awk 的 $$A 呢？
你可以很直接否定掉 hard quoe 的方案：
CODE:[Copy to clipboard]$ awk '{print $$A}' 1.txt
那是因?yàn)?$A 的 $ 在 hard quote 中是不能替換變量的。
聰明的讀者(如你!)，經(jīng)過(guò)本章學(xué)習(xí)，我想，應(yīng)該可以解釋為何我們可以使用如下操作了吧：
CODE:[Copy to clipboard]A=0
awk "{print \$$A}" 1.txt
awk \{print\ \$$A\} 1.txt
awk '{print $'$A'}' 1.txt
awk '{print $'"$A"'}' 1.txt # 注："$A" 包在 soft quote 中
或許，你能舉出更多的方案呢.... ^_^
--------------------------------------
練習(xí)與思考：請(qǐng)運(yùn)用本章學(xué)到的知識(shí)分析如下兩串討論：
[url]http://bbs.chinaunix.net/forum/viewtopic.php?t=207178[/url]
[url]http://bbs.chinaunix.net/forum/viewtopic.php?t=216729[/url]
-----------------------------------------------------------------------------------------------------------------------
5) var=value？export 前后差在哪？
這次讓我們暫時(shí)丟開 command line ，先來(lái)了解一下 bash 變量(variable)吧...
所謂的變量，就是就是利用一個(gè)特定的"名稱"(name)來(lái)存取一段可以變化的"值"(value)。
*設(shè)定(set)*
在 bash 中，你可以用 "=" 來(lái)設(shè)定或重新定義變量的內(nèi)容：
name=value
在設(shè)定變量的時(shí)侯，得遵守如下規(guī)則：
* 等號(hào)左右兩邊不能使用區(qū)隔符號(hào)(IFS)，也應(yīng)避免使用 shell 的保留字符(meta charactor)。
* 變量名稱不能使用 $ 符號(hào)。
* 變量名稱的第一個(gè)字母不能是數(shù)字(number)。
* 變量名稱長(zhǎng)度不可超過(guò) 256 個(gè)字母。
* 變量名稱及變量值之大小寫是有區(qū)別的(case sensitive)。
如下是一些變量設(shè)定時(shí)常見的錯(cuò)誤：
A= B ：不能有 IFS
1A=B ：不能以數(shù)字開頭
$A=B ：名稱不能有 $
a=B ：這跟 a=b 是不同的
如下則是可以接受的設(shè)定：
A=" B" ：IFS 被關(guān)閉了 (請(qǐng)參考前面的 quoting 章節(jié))
A1=B ：并非以數(shù)字開頭
A=$B ：$ 可用在變量值內(nèi)
This_Is_A_Long_Name=b ：可用 _ 連接較長(zhǎng)的名稱或值，且大小寫有別。
*變量替換(substitution)*
Shell 之所以強(qiáng)大，其中的一個(gè)因素是它可以在命令行中對(duì)變量作替換(substitution)處理。
在命令行中使用者可以使用 $ 符號(hào)加上變量名稱(除了在用 = 號(hào)定義變量名稱之外)，
將變量值給替換出來(lái)，然后再重新組建命令行。
比方：
CODE:[Copy to clipboard] $ A=ls
$ B=la
$ C=/tmp
$ $A -$B $C
(注意：以上命令行的第一個(gè) $ 是 shell prompt ，并不在命令行之內(nèi)。)
必需強(qiáng)調(diào)的是，我們所提的變量替換，只發(fā)生在 command line 上面。(是的，讓我們?cè)倩氐?command line 吧﹗)
仔細(xì)分析最后那行 command line ，不難發(fā)現(xiàn)在被執(zhí)行之前(在輸入 CR 字符之前)，
$ 符號(hào)會(huì)對(duì)每一個(gè)變量作替換處理(將變量值替換出來(lái)再重組命令行)，最后會(huì)得出如下命令行：
CODE:[Copy to clipboard] ls -la /tmp
還記得第二章我請(qǐng)大家"務(wù)必理解"的那兩句嗎？若你忘了，那我這里再重貼一遍：
QUOTE:
若從技術(shù)細(xì)節(jié)來(lái)看，shell 會(huì)依據(jù) IFS(Internal Field Seperator) 將 command line 所輸入的文字給拆解為"字段"(word)。
然后再針對(duì)特殊字符(meta)先作處理，最后再重組整行 command line 。
這里的 $ 就是 command line 中最經(jīng)典的 meta 之一了，就是作變量替換的﹗
在日常的 shell 操作中，我們常會(huì)使用 echo 命令來(lái)查看特定變量的值，例如：
CODE:[Copy to clipboard] $ echo $A -$B $C
我們已學(xué)過(guò)， echo 命令只單純將其 argument 送至"標(biāo)準(zhǔn)輸出"(STDOUT，通常是我們的熒幕)。
所以上面的命令會(huì)在熒幕上得到如下結(jié)果：
CODE:[Copy to clipboard] ls -la /tmp
這是由于 echo 命令在執(zhí)行時(shí)，會(huì)先將 $A(ls)、$B(la)、跟 $C(/tmp) 給替換出來(lái)的結(jié)果。
利用 shell 對(duì)變量的替換處理能力，我們?cè)谠O(shè)定變量時(shí)就更為靈活了：
A=B
B=$A
這樣，B 的變量值就可繼承 A 變量"當(dāng)時(shí)"的變量值了。
不過(guò)，不要以"數(shù)學(xué)羅輯"來(lái)套用變量的設(shè)定，比方說(shuō)：
A=B
B=C
這樣并不會(huì)讓 A 的變量值變成 C 。再如：
A=B
B=$A
A=C
同樣也不會(huì)讓 B 的值換成 C 。
上面是單純定義了兩個(gè)不同名稱的變量：A 與 B ，它們的值分別是 B 與 C 。
若變量被重復(fù)定義的話，則原有舊值將被新值所取代。(這不正是"可變的量"嗎？ ^_^)
當(dāng)我們?cè)谠O(shè)定變量的時(shí)侯，請(qǐng)記著這點(diǎn)：
* 用一個(gè)名稱儲(chǔ)存一個(gè)數(shù)值
僅此而已。
此外，我們也可利用命令行的變量替換能力來(lái)"擴(kuò)充"(append)變量值：
A=B:C:D
A=$A:E
這樣，第一行我們?cè)O(shè)定 A 的值為 "B:C:D"，然后，第二行再將值擴(kuò)充為 "A:B:C:E" 。
上面的擴(kuò)充范例，我們使用區(qū)隔符號(hào)( : )來(lái)達(dá)到擴(kuò)充目的，
要是沒(méi)有區(qū)隔符號(hào)的話，如下是有問(wèn)題的：
A=BCD
A=$AE
因?yàn)榈诙问菍?A 的值繼承 $AE 的提換結(jié)果，而非 $A 再加 E ﹗
要解決此問(wèn)題，我們可用更嚴(yán)謹(jǐn)?shù)奶鎿Q處理：
A=BCD
A=${A}E
上例中，我們使用 {} 將變量名稱的范圍給明確定義出來(lái)，
如此一來(lái)，我們就可以將 A 的變量值從 BCD 給擴(kuò)充為 BCDE 。
(提示：關(guān)于 ${name} 事實(shí)上還可做到更多的變量處理能力，這些均屬于比較進(jìn)階的變量處理，
現(xiàn)階段暫時(shí)不介紹了，請(qǐng)大家自行參考數(shù)據(jù)。如 CU 的貼子：
[url]http://www.chinaunix.net/forum/viewtopic.php?t=201843[/url]
)
* export *
嚴(yán)格來(lái)說(shuō)，我們?cè)诋?dāng)前 shell 中所定義的變量，均屬于"本地變量"(local variable)，
只有經(jīng)過(guò) export 命令的"輸出"處理，才能成為環(huán)境變量(environment variable)：
CODE:[Copy to clipboard] $ A=B
$ export A
或：
CODE:[Copy to clipboard] $ export A=B
經(jīng)過(guò) export 輸出處理之后，變量 A 就能成為一個(gè)環(huán)境變量供其后的命令使用。
在使用 export 的時(shí)侯，請(qǐng)別忘記 shell 在命令行對(duì)變量的"替換"(substitution)處理，
比方說(shuō)：
CODE:[Copy to clipboard] $ A=B
$ B=C
$ export $A
上面的命令并未將 A 輸出為環(huán)境變量，而是將 B 作輸出，
這是因?yàn)樵谶@個(gè)命令行中，$A 會(huì)首先被提換出 B 然后再"塞回"作 export 的參數(shù)。
要理解這個(gè) export ，事實(shí)上需要從 process 的角度來(lái)理解才能透徹。
我將于下一章為大家說(shuō)明 process 的觀念，敬請(qǐng)留意。
*取消變量*
要取消一個(gè)變量，在 bash 中可使用 unset 命令來(lái)處理：
CODE:[Copy to clipboard] unset A
與 export 一樣，unset 命令行也同樣會(huì)作變量替換(這其實(shí)就是 shell 的功能之一)，
因此：
CODE:[Copy to clipboard] $ A=B
$ B=C
$ unset $A
事實(shí)上所取消的變量是 B 而不是 A 。
此外，變量一旦經(jīng)過(guò) unset 取消之后，其結(jié)果是將整個(gè)變量拿掉，而不僅是取消其變量值。
如下兩行其實(shí)是很不一樣的：
CODE:[Copy to clipboard] $ A=
$ unset A
第一行只是將變量 A 設(shè)定為"空值"(null value)，但第二行則讓變量 A 不在存在。
雖然用眼睛來(lái)看，這兩種變量狀態(tài)在如下命令結(jié)果中都是一樣的：
CODE:[Copy to clipboard] $ A=
$ echo $A
$ unset A
$ echo $A
請(qǐng)學(xué)員務(wù)必能識(shí)別 null value 與 unset 的本質(zhì)區(qū)別，這在一些進(jìn)階的變量處理上是很嚴(yán)格的。
比方說(shuō)：
CODE:[Copy to clipboard] $ str= # 設(shè)為 null
$ var=${str=expr} # 定義 var
$ echo $var
$ echo $str
$ unset str # 取消
$ var=${str=expr} # 定義 var
$ echo $var
expr
$ echo $str
expr
聰明的讀者(yes, you!)，稍加思考的話，
應(yīng)該不難發(fā)現(xiàn)為何同樣的 var=${str=expr} 在 null 與 unset 之下的不同吧？
若你看不出來(lái)，那可能是如下原因之一：
a. 你太笨了
b. 不了解 var=${str=expr} 這個(gè)進(jìn)階處理
c. 對(duì)本篇說(shuō)明還沒(méi)來(lái)得及消化吸收
e. 我講得不好
不知，你選哪個(gè)呢？.... ^_^
-----------------------------------------------------------------------------------------------------
6) exec 跟 source 差在哪？
這次先讓我們從 CU Shell 版的一個(gè)實(shí)例貼子來(lái)談起吧：
( [url]http://www.chinaunix.net/forum/viewtopic.php?t=194191[/url] )
例中的提問(wèn)是：
QUOTE:
cd /etc/aa/bb/cc可以執(zhí)行
但是把這條命令寫入shell時(shí)shell不執(zhí)行！
這是什么原因呀！
我當(dāng)時(shí)如何回答暫時(shí)別去深究，先讓我們了解一下行程(process)的觀念好了。
首先，我們所執(zhí)行的任何程序，都是由父行程(parent process)所產(chǎn)生出來(lái)的一個(gè)子行程(child process)，
子行程在結(jié)束后，將返回到父行程去。此一現(xiàn)像在 linux 系統(tǒng)中被稱為 fork 。
(為何要程為 fork 呢？嗯，畫一下圖或許比較好理解... ^_^ )
當(dāng)子行程被產(chǎn)生的時(shí)候，將會(huì)從父行程那里獲得一定的資源分配、及(更重要的是)繼承父行程的環(huán)境﹗
讓我們回到上一章所談到的"環(huán)境變量"吧：
* 所謂環(huán)境變量其實(shí)就是那些會(huì)傳給子行程的變量。
簡(jiǎn)單而言，"遺傳性"就是區(qū)分本地變量與環(huán)境變量的決定性指標(biāo)。
然而，從遺傳的角度來(lái)看，我們也不難發(fā)現(xiàn)環(huán)境變量的另一個(gè)重要特征：
* 環(huán)境變量只能從父行程到子行程單向繼承。換句話說(shuō)：在子行程中的環(huán)境如何變更，均不會(huì)影響父行程的環(huán)境。
接下來(lái)，再讓我們了解一下命令腳本(shell script)的概念。
所謂的 shell script 講起來(lái)很簡(jiǎn)單，就是將你平時(shí)在 shell prompt 后所輸入的多行 command line 依序?qū)懭胍粋€(gè)文件去而已。
其中再加上一些條件判斷、互動(dòng)界面、參數(shù)運(yùn)用、函數(shù)調(diào)用、等等技巧，得以讓 script 更加"聰明"的執(zhí)行，
但若撇開這些技巧不談，我們真的可以簡(jiǎn)單的看成 script 只不過(guò)依次執(zhí)行預(yù)先寫好的命令行而已。
再結(jié)合以上兩個(gè)概念(process + script)，那應(yīng)該就不難理解如下這句話的意思了：
* 正常來(lái)說(shuō)，當(dāng)我們執(zhí)行一個(gè) shell script 時(shí)，其實(shí)是先產(chǎn)生一個(gè) sub-shell 的子行程，然后 sub-shell 再去產(chǎn)生命令行的子行程。
然則，那讓我們回到本章開始時(shí)所提到的例子再?gòu)男滤伎迹?br>
QUOTE:
cd /etc/aa/bb/cc可以執(zhí)行
但是把這條命令寫入shell時(shí)shell不執(zhí)行！
這是什么原因呀！
我當(dāng)時(shí)的答案是這樣的：
QUOTE:
因?yàn)椋话阄覀兣艿?shell script 是用 subshell 去執(zhí)行的。
從 process 的觀念來(lái)看，是 parent process 產(chǎn)生一個(gè) child process 去執(zhí)行，
當(dāng) child 結(jié)束后，會(huì)返回 parent ，但 parent 的環(huán)境是不會(huì)因 child 的改變而改變的。
所謂的環(huán)境元數(shù)很多，凡舉 effective id, variable, workding dir 等等...
其中的 workding dir ($PWD) 正是樓主的疑問(wèn)所在：
當(dāng)用 subshell 來(lái)跑 script 的話，sub shell 的 $PWD 會(huì)因?yàn)?cd 而變更，
但當(dāng)返回 primary shell 時(shí)，$PWD 是不會(huì)變更的。
能夠了解問(wèn)題的原因及其原理是很好的，但是？如何解決問(wèn)題恐怕是我們更感興趣的﹗是吧？^_^
那好，接下來(lái)，再讓我們了解一下 source 命令好了。
當(dāng)你有了 fork 的概念之后，要理解 source 就不難：
* 所謂 source 就是讓 script 在當(dāng)前 shell 內(nèi)執(zhí)行、而不是產(chǎn)生一個(gè) sub-shell 來(lái)執(zhí)行。
由于所有執(zhí)行結(jié)果均于當(dāng)前 shell 內(nèi)完成，若 script 的環(huán)境有所改變，當(dāng)然也會(huì)改變當(dāng)前環(huán)境了﹗
因此，只要我們要將原本單獨(dú)輸入的 script 命令行變成 source 命令的參數(shù)，就可輕易解決前例提到的問(wèn)題了。
比方說(shuō)，原本我們是如此執(zhí)行 script 的：
CODE:[Copy to clipboard]./my.script
現(xiàn)在改成這樣即可：
CODE:[Copy to clipboard]source ./my.script
或：
. ./my.script
說(shuō)到這里，我想，各位有興趣看看 /etc 底下的眾多設(shè)定文件，
應(yīng)該不難理解它們被定議后，如何讓其它 script 讀取并繼承了吧？
若然，日后你有機(jī)會(huì)寫自己的 script ，應(yīng)也不難專門指定一個(gè)設(shè)定文件以供不同的 script 一起"共享"了... ^_^
okay，到這里，若你搞得懂 fork 與 source 的不同，那接下來(lái)再接受一個(gè)挑戰(zhàn)：
---- 那 exec 又與 source/fork 有何不同呢？
哦... 要了解 exec 或許較為復(fù)雜，尤其扯上 File Descriptor 的話...
不過(guò)，簡(jiǎn)單來(lái)說(shuō)：
* exec 也是讓 script 在同一個(gè)行程上執(zhí)行，但是原有行程則被結(jié)束了。
也就是簡(jiǎn)而言之：原有行程會(huì)否終止，就是 exec 與 source/fork 的最大差異了。
嗯，光是從理論去理解，或許沒(méi)那么好消化，不如動(dòng)手"實(shí)作+思考"來(lái)的印像深刻哦。
下面讓我們寫兩個(gè)簡(jiǎn)單的 script ，分別命令為 1.sh 及 2.sh ：
1.sh
CODE:[Copy to clipboard]
#!/bin/bash
A=B
echo "PID for 1.sh before exec/source/fork:$$"
export A
echo "1.sh: \$A is $A"
case $1 in
exec)
echo "using exec..."
exec ./2.sh ;;
source)
echo "using source..."
. ./2.sh ;;
*)
echo "using fork by default..."
./2.sh ;;
esac
echo "PID for 1.sh after exec/source/fork:$$"
echo "1.sh: \$A is $A"
2.sh
CODE:[Copy to clipboard]#!/bin/bash
echo "PID for 2.sh: $$"
echo "2.sh get \$A=$A from 1.sh"
A=C
export A
echo "2.sh: \$A is $A"
然后，分別跑如下參數(shù)來(lái)觀察結(jié)果：
CODE:[Copy to clipboard]$ ./1.sh fork
$ ./1.sh source
$ ./1.sh exec
或是，你也可以參考 CU 上的另一貼子：
[url]http://www.chinaunix.net/forum/viewtopic.php?t=191051[/url]
好了，別忘了仔細(xì)比較輸出結(jié)果的不同及背后的原因哦...
若有疑問(wèn)，歡迎提出來(lái)一起討論討論~~~
happy scripting! ^_^
------------------------------------------------------------------------------------
7) ( ) 與 { } 差在哪？
嗯，這次輕松一下，不講太多... ^_^
先說(shuō)一下，為何要用 ( ) 或 { } 好了。
許多時(shí)候，我們?cè)?shell 操作上，需要在一定條件下一次執(zhí)行多個(gè)命令，
也就是說(shuō)，要么不執(zhí)行，要么就全執(zhí)行，而不是每次依序的判斷是否要執(zhí)行下一個(gè)命令。
或是，需要從一些命令執(zhí)行優(yōu)先次順中得到豁免，如算術(shù)的 2*(3+4) 那樣...
這時(shí)候，我們就可引入"命令群組"(command group)的概念：將多個(gè)命令集中處理。
在 shell command line 中，一般人或許不太計(jì)較 ( ) 與 { } 這兩對(duì)符號(hào)的差異，
雖然兩者都可將多個(gè)命令作群組化處理，但若從技術(shù)細(xì)節(jié)上，卻是很不一樣的：
( ) 將 command group 置于 sub-shell 去執(zhí)行，也稱 nested sub-shell。
{ } 則是在同一個(gè) shell 內(nèi)完成，也稱為 non-named command group。
若，你對(duì)上一章的 fork 與 source 的概念還記得了的話，那就不難理解兩者的差異了。
要是在 command group 中扯上變量及其它環(huán)境的修改，我們可以根據(jù)不同的需求來(lái)使用 ( ) 或 { } 。
通常而言，若所作的修改是臨時(shí)的，且不想影響原有或以后的設(shè)定，那我們就 nested sub-shell ，
反之，則用 non-named command group 。
是的，光從 command line 來(lái)看，( ) 與 { } 的差別就講完了，夠輕松吧~~~ ^_^
然而，若這兩個(gè) meta 用在其它 command meta 或領(lǐng)域中(如 Regular Expression)，還是有很多差別的。
只是，我不打算再去說(shuō)明了，留給讀者自己慢慢發(fā)掘好了...
我這里只想補(bǔ)充一個(gè)概念，就是 function 。
所謂的 function ，就是用一個(gè)名字去命名一個(gè) command group ，然后再調(diào)用這個(gè)名字去執(zhí)行 command group 。
從 non-named command group 來(lái)推斷，大概你也可以猜到我要說(shuō)的是 { } 了吧？(yes! 你真聰明﹗ ^_^ )
在 bash 中，function 的定義方式有兩種：
方式一：
CODE:[Copy to clipboard]function function_name {
command1
command2
command3
....
}
方式二：
CODE:[Copy to clipboard]fuction_name () {
command1
command2
command3
....
}
用哪一種方式無(wú)所謂，只是若碰到所定意的名稱與現(xiàn)有的命令或別名(Alias)沖突的話，方式二或許會(huì)失敗。
但方式二起碼可以少打 function 這一串英文字母，對(duì)懶人來(lái)說(shuō)(如我)，又何樂(lè)不為呢？... ^_^
function 在某一程度來(lái)說(shuō)，也可稱為"函式"，但請(qǐng)不要與傳統(tǒng)編程所使用的函式(library)搞混了，畢竟兩者差異很大。
惟一相同的是，我們都可以隨時(shí)用"已定義的名稱"來(lái)調(diào)用它們...
若我們?cè)?shell 操作中，需要不斷的重復(fù)質(zhì)行某些命令，我們首先想到的，或許是將命令寫成命令稿(shell script)。
不過(guò)，我們也可以寫成 function ，然后在 command line 中打上 function_name 就可當(dāng)一舨的 script 來(lái)使用了。
只是若你在 shell 中定義的 function ，除了可用 unset function_name 取消外，一旦退出 shell ，function 也跟著取消。
然而，在 script 中使用 function 卻有許多好處，除了可以提高整體 script 的執(zhí)行效能外(因?yàn)橐驯患虞d)，
還可以節(jié)省許多重復(fù)的代碼...
簡(jiǎn)單而言，若你會(huì)將多個(gè)命令寫成 script 以供調(diào)用的話，那，你可以將 function 看成是 script 中的 script ... ^_^
而且，透過(guò)上一章介紹的 source 命令，我們可以自行定義許許多多好用的 function ，再集中寫在特定文件中，
然后，在其它的 script 中用 source 將它們加載并反復(fù)執(zhí)行。
若你是 RedHat linux 的使用者，或許，已經(jīng)猜得出 /etc/rc.d/init.d/functions 這個(gè)文件是作啥用的了~~~ ^_^
okay，說(shuō)要輕松點(diǎn)的嘛，那這次就暫時(shí)寫到這吧。祝大家學(xué)習(xí)愉快﹗ ^_^
------------------------------------------------------------------------------------------------
8) $(( )) 與 $( ) 還有${ } 差在哪？
我們上一章介紹了 ( ) 與 { } 的不同，這次讓我們擴(kuò)展一下，看看更多的變化：$( ) 與 ${ } 又是啥玩意兒呢？
在 bash shell 中，$( ) 與 ` ` (反引號(hào)) 都是用來(lái)做命令替換用(command substitution)的。
所謂的命令替換與我們第五章學(xué)過(guò)的變量替換差不多，都是用來(lái)重組命令行：
* 完成引號(hào)里的命令行，然后將其結(jié)果替換出來(lái)，再重組命令行。
例如：
CODE:[Copy to clipboard]$ echo the last sunday is $(date -d "last sunday" +%Y-%m-%d)
如此便可方便得到上一星期天的日期了... ^_^
在操作上，用 $( ) 或 ` ` 都無(wú)所謂，只是我"個(gè)人"比較喜歡用 $( ) ，理由是：
1, ` ` 很容易與 ' ' ( 單引號(hào))搞混亂，尤其對(duì)初學(xué)者來(lái)說(shuō)。
有時(shí)在一些奇怪的字形顯示中，兩種符號(hào)是一模一樣的(直豎兩點(diǎn))。
當(dāng)然了，有經(jīng)驗(yàn)的朋友還是一眼就能分辯兩者。只是，若能更好的避免混亂，又何樂(lè)不為呢？ ^_^
2, 在多層次的復(fù)合替換中，` ` 須要額外的跳脫( \` )處理，而 $( ) 則比較直觀。例如：
這是錯(cuò)的：
CODE:[Copy to clipboard]command1 `command2 `command3` `
原本的意圖是要在 command2 `command3` 先將 command3 提換出來(lái)給 command 2 處理，
然后再將結(jié)果傳給 command1 `command2 ...` 來(lái)處理。
然而，真正的結(jié)果在命令行中卻是分成了 `command2 ` 與 `` 兩段。
正確的輸入應(yīng)該如下：
CODE:[Copy to clipboard]command1 `command2 \`command3\` `
要不然，換成 $( ) 就沒(méi)問(wèn)題了：
CODE:[Copy to clipboard]command1 $(command2 $(command3))
只要你喜歡，做多少層的替換都沒(méi)問(wèn)題啦~~~ ^_^
不過(guò)，$( ) 并不是沒(méi)有斃端的...
首先，` ` 基本上可用在全部的 unix shell 中使用，若寫成 shell script ，其移植性比較高。
而 $( ) 并不見的每一種 shell 都能使用，我只能跟你說(shuō)，若你用 bash2 的話，肯定沒(méi)問(wèn)題... ^_^
接下來(lái)，再讓我們看 ${ } 吧... 它其實(shí)就是用來(lái)作變量替換用的啦。
一般情況下，$var 與 ${var} 并沒(méi)有啥不一樣。
但是用 ${ } 會(huì)比較精確的界定變量名稱的范圍，比方說(shuō)：
CODE:[Copy to clipboard]$ A=B
$ echo $AB
原本是打算先將 $A 的結(jié)果替換出來(lái)，然后再補(bǔ)一個(gè) B 字母于其后，
但在命令行上，真正的結(jié)果卻是只會(huì)提換變量名稱為 AB 的值出來(lái)...
若使用 ${ } 就沒(méi)問(wèn)題了：
CODE:[Copy to clipboard]$ echo ${A}B
BB
不過(guò)，假如你只看到 ${ } 只能用來(lái)界定變量名稱的話，那你就實(shí)在太小看 bash 了﹗
有興趣的話，你可先參考一下 cu 本版的精華文章：
[url]http://www.chinaunix.net/forum/viewtopic.php?t=201843[/url]
為了完整起見，我這里再用一些例子加以說(shuō)明 ${ } 的一些特異功能：
假設(shè)我們定義了一個(gè)變量為：
file=/dir1/dir2/dir3/my.file.txt
我們可以用 ${ } 分別替換獲得不同的值：
${file#*/}：拿掉第一條 / 及其左邊的字符串：dir1/dir2/dir3/my.file.txt
${file##*/}：拿掉最后一條 / 及其左邊的字符串：my.file.txt
${file#*.}：拿掉第一個(gè) . 及其左邊的字符串：file.txt
${file##*.}：拿掉最后一個(gè) . 及其左邊的字符串：txt
${file%/*}：拿掉最后條 / 及其右邊的字符串：/dir1/dir2/dir3
${file%%/*}：拿掉第一條 / 及其右邊的字符串：(空值)
${file%.*}：拿掉最后一個(gè) . 及其右邊的字符串：/dir1/dir2/dir3/my.file
${file%%.*}：拿掉第一個(gè) . 及其右邊的字符串：/dir1/dir2/dir3/my
記憶的方法為：
# 是去掉左邊(在鑒盤上 # 在 $ 之左邊)
% 是去掉右邊(在鑒盤上 % 在 $ 之右邊)
單一符號(hào)是最小匹配﹔兩個(gè)符號(hào)是最大匹配。
${file:0:5}：提取最左邊的 5 個(gè)字節(jié)：/dir1
${file:5:5}：提取第 5 個(gè)字節(jié)右邊的連續(xù) 5 個(gè)字節(jié)：/dir2
我們也可以對(duì)變量值里的字符串作替換：
${file/dir/path}：將第一個(gè) dir 提換為 path：/path1/dir2/dir3/my.file.txt
${file//dir/path}：將全部 dir 提換為 path：/path1/path2/path3/my.file.txt
利用 ${ } 還可針對(duì)不同的變量狀態(tài)賦值(沒(méi)設(shè)定、空值、非空值)：
${file-my.file.txt} ：假如 $file 沒(méi)有設(shè)定，則使用 my.file.txt 作傳回值。(空值及非空值時(shí)不作處理)
${file:-my.file.txt} ：假如 $file 沒(méi)有設(shè)定或?yàn)榭罩担瑒t使用 my.file.txt 作傳回值。 (非空值時(shí)不作處理)
${file+my.file.txt} ：假如 $file 設(shè)為空值或非空值，均使用 my.file.txt 作傳回值。(沒(méi)設(shè)定時(shí)不作處理)
${file:+my.file.txt} ：若 $file 為非空值，則使用 my.file.txt 作傳回值。 (沒(méi)設(shè)定及空值時(shí)不作處理)
${file=my.file.txt} ：若 $file 沒(méi)設(shè)定，則使用 my.file.txt 作傳回值，同時(shí)將 $file 賦值為 my.file.txt 。 (空值及非空值時(shí)不作處理)
${file:=my.file.txt} ：若 $file 沒(méi)設(shè)定或?yàn)榭罩担瑒t使用 my.file.txt 作傳回值，同時(shí)將 $file 賦值為 my.file.txt 。 (非空值時(shí)不作處理)
${file?my.file.txt} ：若 $file 沒(méi)設(shè)定，則將 my.file.txt 輸出至 STDERR。 (空值及非空值時(shí)不作處理)
${file:?my.file.txt} ：若 $file 沒(méi)設(shè)定或?yàn)榭罩担瑒t將 my.file.txt 輸出至 STDERR。 (非空值時(shí)不作處理)
tips:
以上的理解在于, 你一定要分清楚 unset 與 null 及 non-null 這三種賦值狀態(tài).
一般而言, : 與 null 有關(guān), 若不帶 : 的話, null 不受影響, 若帶 : 則連 null 也受影響.
還有哦，${#var} 可計(jì)算出變量值的長(zhǎng)度：
${#file} 可得到 27 ，因?yàn)?/dir1/dir2/dir3/my.file.txt 剛好是 27 個(gè)字節(jié)...
接下來(lái)，再為大家介稍一下 bash 的組數(shù)(array)處理方法。
一般而言，A="a b c def" 這樣的變量只是將 $A 替換為一個(gè)單一的字符串，
但是改為 A=(a b c def) ，則是將 $A 定義為組數(shù)...
bash 的組數(shù)替換方法可參考如下方法：
${A[@]} 或 ${A
} 可得到 a b c def (全部組數(shù))
${A[0]} 可得到 a (第一個(gè)組數(shù))，${A[1]} 則為第二個(gè)組數(shù)...
${#A[@]} 或 ${#A
} 可得到 4 (全部組數(shù)數(shù)量)
${#A[0]} 可得到 1 (即第一個(gè)組數(shù)(a)的長(zhǎng)度)，${#A[3]} 可得到 3 (第四個(gè)組數(shù)(def)的長(zhǎng)度)
A[3]=xyz 則是將第四個(gè)組數(shù)重新定義為 xyz ...
諸如此類的....
能夠善用 bash 的 $( ) 與 ${ } 可大大提高及簡(jiǎn)化 shell 在變量上的處理能力哦~~~ ^_^
好了，最后為大家介紹 $(( )) 的用途吧：它是用來(lái)作整數(shù)運(yùn)算的。
在 bash 中，$(( )) 的整數(shù)運(yùn)算符號(hào)大致有這些：
+ - * / ：分別為 "加、減、乘、除"。
% ：余數(shù)運(yùn)算
& | ^ !：分別為 "AND、OR、XOR、NOT" 運(yùn)算。
例：
CODE:[Copy to clipboard]$ a=5; b=7; c=2
$ echo $(( a+b*c ))
19
$ echo $(( (a+b)/c ))
6
$ echo $(( (a*b)%c))
1
在 $(( )) 中的變量名稱，可于其前面加 $ 符號(hào)來(lái)替換，也可以不用，如：
$(( $a + $b * $c)) 也可得到 19 的結(jié)果
此外，$(( )) 還可作不同進(jìn)位(如二進(jìn)制、八進(jìn)位、十六進(jìn)制)作運(yùn)算呢，只是，輸出結(jié)果皆為十進(jìn)制而已：
echo $((16#2a)) 結(jié)果為 42 (16進(jìn)位轉(zhuǎn)十進(jìn)制)
以一個(gè)實(shí)用的例子來(lái)看看吧：
假如當(dāng)前的 umask 是 022 ，那么新建文件的權(quán)限即為：
CODE:[Copy to clipboard]$ umask 022
$ echo "obase=8;$(( 8#666 & (8#777 ^ 8#$(umask)) ))" | bc
644
事實(shí)上，單純用 (( )) 也可重定義變量值，或作 testing：
a=5; ((a++)) 可將 $a 重定義為 6
a=5; ((a--)) 則為 a=4
a=5; b=7; ((a < b)) 會(huì)得到 0 (true) 的返回值。
常見的用于 (( )) 的測(cè)試符號(hào)有如下這些：
<：小于
>;：大于
<=：小于或等于
>;=：大于或等于
==：等于
!=：不等于
不過(guò)，使用 (( )) 作整數(shù)測(cè)試時(shí)，請(qǐng)不要跟 [ ] 的整數(shù)測(cè)試搞混亂了。(更多的測(cè)試我將于第十章為大家介紹)
怎樣？好玩吧.. ^_^ okay，這次暫時(shí)說(shuō)這么多...
上面的介紹，并沒(méi)有詳列每一種可用的狀態(tài)，更多的，就請(qǐng)讀者參考手冊(cè)文件啰...
-----------------------------------------------------------------------------------------------------------------
9) $@ 與 $* 差在哪？
要說(shuō) $@ 與 $* 之前，需得先從 shell script 的 positional parameter 談起...
我們都已經(jīng)知道變量(variable)是如何定義及替換的，這個(gè)不用再多講了。
但是，我們還需要知道有些變量是 shell 內(nèi)定的，且其名稱是我們不能隨意修改的，
其中就有 positional parameter 在內(nèi)。
在 shell script 中，我們可用 $0, $1, $2, $3 ... 這樣的變量分別提取命令行中的如下部份：
CODE:[Copy to clipboard]script_name parameter1 parameter2 parameter3 ...
我們很容易就能猜出 $0 就是代表 shell script 名稱(路徑)本身，而 $1 就是其后的第一個(gè)參數(shù)，如此類推....
須得留意的是 IFS 的作用，也就是，若 IFS 被 quoting 處理后，那么 positional parameter 也會(huì)改變。
如下例：
CODE:[Copy to clipboard]my.sh p1 "p2 p3" p4
由于在 p2 與 p3 之間的空格鍵被 soft quote 所關(guān)閉了，因此 my.sh 中的 $2 是 "p2 p3" 而 $3 則是 p4 ...
還記得前兩章我們提到 fucntion 時(shí)，我不是說(shuō)過(guò)它是 script 中的 script 嗎？ ^_^
是的，function 一樣可以讀取自己的(有別于 script 的) postitional parameter ，惟一例外的是 $0 而已。
舉例而言：假設(shè) my.sh 里有一個(gè) fucntion 叫 my_fun , 若在 script 中跑 my_fun fp1 fp2 fp3 ，
那么，function 內(nèi)的 $0 是 my.sh ，而 $1 則是 fp1 而非 p1 了...
不如寫個(gè)簡(jiǎn)單的 my.sh script 看看吧：
CODE:[Copy to clipboard]#!/bin/bash
my_fun() {
echo '$0 inside function is '$0
echo '$1 inside function is '$1
echo '$2 inside function is '$2
}
echo '$0 outside function is '$0
echo '$1 outside function is '$1
echo '$2 outside function is '$2
my_fun fp1 "fp2 fp3"
然后在 command line 中跑一下 script 就知道了：
CODE:[Copy to clipboard]chmod +x my.sh
./my.sh p1 "p2 p3"
$0 outside function is ./my.sh
$1 outside function is p1
$2 outside function is p2 p3
$0 inside function is ./my.sh
$1 inside function is fp1
$2 inside function is fp2 fp3
然而，在使用 positional parameter 的時(shí)候，我們要注意一些陷阱哦：
* $10 不是替換第 10 個(gè)參數(shù)，而是替換第一個(gè)參數(shù)($1)然后再補(bǔ)一個(gè) 0 于其后﹗
也就是，my.sh one two three four five six seven eigth nine ten 這樣的 command line ，
my.sh 里的 $10 不是 ten 而是 one0 哦... 小心小心﹗
要抓到 ten 的話，有兩種方法：
方法一是使用我們上一章介紹的 ${ } ，也就是用 ${10} 即可。
方法二，就是 shift 了。
用通俗的說(shuō)法來(lái)說(shuō)，所謂的 shift 就是取消 positional parameter 中最左邊的參數(shù)( $0 不受影響)。
其默認(rèn)值為 1 ，也就是 shift 或 shift 1 都是取消 $1 ，而原本的 $2 則變成 $1、$3 變成 $2 ...
若 shift 3 則是取消前面三個(gè)參數(shù)，也就是原本的 $4 將變成 $1 ...
那，親愛的讀者，你說(shuō)要 shift 掉多少個(gè)參數(shù)，才可用 $1 取得 ${10} 呢？ ^_^
okay，當(dāng)我們對(duì) positional parameter 有了基本概念之后，那再讓我們看看其它相關(guān)變量吧。
首先是 $# ：它可抓出 positional parameter 的數(shù)量。
以前面的 my.sh p1 "p2 p3" 為例：
由于 p2 與 p3 之間的 IFS 是在 soft quote 中，因此 $# 可得到 2 的值。
但如果 p2 與 p3 沒(méi)有置于 quoting 中話，那 $# 就可得到 3 的值了。
同樣的道理在 function 中也是一樣的...
因此，我們常在 shell script 里用如下方法測(cè)試 script 是否有讀進(jìn)參數(shù)：
CODE:[Copy to clipboard][ $# = 0 ]
假如為 0 ，那就表示 script 沒(méi)有參數(shù)，否則就是有帶參數(shù)...
接下來(lái)就是 $@ 與 $* ：
精確來(lái)講，兩者只有在 soft quote 中才有差異，否則，都表示"全部參數(shù)"( $0 除外)。
舉例來(lái)說(shuō)好了：
若在 command line 上跑 my.sh p1 "p2 p3" p4 的話，
不管是 $@ 還是 $* ，都可得到 p1 p2 p3 p4 就是了。
但是，如果置于 soft quote 中的話：
"$@" 則可得到 "p1" "p2 p3" "p4" 這三個(gè)不同的詞段(word)﹔
"$*" 則可得到 "p1 p2 p3 p4" 這一整串單一的詞段。
我們可修改一下前面的 my.sh ，使之內(nèi)容如下：
CODE:[Copy to clipboard]#!/bin/bash
my_fun() {
echo "$#"
}
echo 'the number of parameter in "$@" is '$(my_fun "$@")
echo 'the number of parameter in "$*" is '$(my_fun "$*")
然后再執(zhí)行 ./my.sh p1 "p2 p3" p4 就知道 $@ 與 $* 差在哪了 ... ^_^
|
10) && 與 || 差在哪？
好不容易，進(jìn)入兩位數(shù)的章節(jié)了... 一路走來(lái)，很辛苦吧？也很快樂(lè)吧？ ^_^
在解答本章題目之前，先讓我們了解一個(gè)概念：return value ﹗
我們?cè)?shell 下跑的每一個(gè) command 或 function ，在結(jié)束的時(shí)候都會(huì)傳回父行程一個(gè)值，稱為 return value 。
在 shell command line 中可用 $? 這個(gè)變量得到最"新"的一個(gè) return value ，也就是剛結(jié)束的那個(gè)行程傳回的值。
Return Value(RV) 的取值為 0-255 之間，由程序(或 script)的作者自行定議：
* 若在 script 里，用 exit RV 來(lái)指定其值，若沒(méi)指定，在結(jié)束時(shí)以最后一道命令之 RV 為值。
* 若在 function 里，則用 return RV 來(lái)代替 exit RV 即可。
Return Value 的作用，是用來(lái)判斷行程的退出狀態(tài)(exit status)，只有兩種：
* 0 的話為"真"( true )
* 非 0 的話為"假"( false )
舉個(gè)例子來(lái)說(shuō)明好了：
假設(shè)當(dāng)前目錄內(nèi)有一份 my.file 的文件，而 no.file 是不存在的：
CODE:[Copy to clipboard]$ touch my.file
$ ls my.file
$ echo $? # first echo
0
$ ls no.file
ls: no.file: No such file or directory
$ echo $? # second echo
1
$ echo $? # third echo
0
上例的第一個(gè) echo 是關(guān)于 ls my.file 的 RV ，可得到 0 的值，因此為 true ﹔
第二個(gè) echo 是關(guān)于 ls no.file 的 RV ，則得到非 0 的值，因此為 false ﹔
第三個(gè) echo 是關(guān)于第二個(gè) echo $? 的 RV ，為 0 的值，因此也為 true 。
請(qǐng)記住：每一個(gè) command 在結(jié)束時(shí)都會(huì)送回 return value 的﹗不管你跑甚么樣的命令...
然而，有一個(gè)命令卻是"專門"用來(lái)測(cè)試某一條件而送出 return value 以供 true 或 false 的判斷，
它就是 test 命令了﹗
若你用的是 bash ，請(qǐng)?jiān)?command line 下打 man test 或 man bash 來(lái)了解這個(gè) test 的用法。
這是你可用作參考的最精確的文件了，要是聽別人說(shuō)的，僅作參考就好...
下面我只簡(jiǎn)單作一些輔助說(shuō)明，其余的一律以 man 為準(zhǔn)：
首先，test 的表示式我們稱為 expression ，其命令格式有兩種：
CODE:[Copy to clipboard]test expression
or:
[ expression ]
(請(qǐng)務(wù)必注意 [ ] 之間的空格鍵﹗)
用哪一種格式?jīng)]所謂，都是一樣的效果。(我個(gè)人比較喜歡后者...)
其次，bash 的 test 目前支持的測(cè)試對(duì)像只有三種：
* string：字符串，也就是純文字。
* integer：整數(shù)( 0 或正整數(shù)，不含負(fù)數(shù)或小數(shù)點(diǎn))。
* file：文件。
請(qǐng)初學(xué)者一定要搞清楚這三者的差異，因?yàn)?test 所用的 expression 是不一樣的。
以 A=123 這個(gè)變量為例：
* [ "$A" = 123 ]：是字符串的測(cè)試，以測(cè)試 $A 是否為 1、2、3 這三個(gè)連續(xù)的"文字"。
* [ "$A" -eq 123 ]：是整數(shù)的測(cè)試，以測(cè)試 $A 是否等于"一百二十三"。
* [ -e "$A" ]：是關(guān)于文件的測(cè)試，以測(cè)試 123 這份"文件"是否存在。
第三，當(dāng) expression 測(cè)試為"真"時(shí)，test 就送回 0 (true) 的 return value ，否則送出非 0 (false)。
若在 expression 之前加上一個(gè) " ! "(感嘆號(hào))，則是當(dāng) expression 為"假時(shí)" 才送出 0 ，否則送出非 0 。
同時(shí)，test 也允許多重的覆合測(cè)試：
* expression1 -a expression2 ：當(dāng)兩個(gè) exrepssion 都為 true ，才送出 0 ，否則送出非 0 。
* expression1 -o expression2 ：只需其中一個(gè) exrepssion 為 true ，就送出 0 ，只有兩者都為 false 才送出非 0 。
例如：
CODE:[Copy to clipboard][ -d "$file" -a -x "$file" ]
是表示當(dāng) $file 是一個(gè)目錄、且同時(shí)具有 x 權(quán)限時(shí)，test 才會(huì)為 true 。
第四，在 command line 中使用 test 時(shí)，請(qǐng)別忘記命令行的"重組"特性，
也就是在碰到 meta 時(shí)會(huì)先處理 meta 再重新組建命令行。(這個(gè)特性我在第二及第四章都曾反復(fù)強(qiáng)調(diào)過(guò))
比方說(shuō)，若 test 碰到變量或命令替換時(shí)，若不能滿足 expression 格式時(shí)，將會(huì)得到語(yǔ)法錯(cuò)誤的結(jié)果。
舉例來(lái)說(shuō)好了：
關(guān)于 [ string1 = string2 ] 這個(gè) test 格式，
在 = 號(hào)兩邊必須要有字符串，其中包括空(null)字符串(可用 soft quote 或 hard quote 取得)。
假如 $A 目前沒(méi)有定義，或被定議為空字符串的話，那如下的寫法將會(huì)失敗：
CODE:[Copy to clipboard]$ unset A
$ [ $A = abc ]
[: =: unary operator expected
這是因?yàn)槊钚信龅?nbsp; $ 這個(gè) meta 時(shí)，會(huì)替換 $A 的值，然后再重組命令行，那就變成了：
[ = abc ]
如此一來(lái) = 號(hào)左邊就沒(méi)有字符串存在了，因此造成 test 的語(yǔ)法錯(cuò)誤﹗
但是，下面這個(gè)寫法則是成立的：
CODE:[Copy to clipboard]$ [ "$A" = abc ]
$ echo $?
1
這是因?yàn)樵诿钚兄亟M后的結(jié)果為：
[ "" = abc ]
由于 = 左邊我們用 soft quote 得到一個(gè)空字符串，而讓 test 語(yǔ)法得以通過(guò)...
讀者諸君請(qǐng)務(wù)必留意這些細(xì)節(jié)哦，因?yàn)樯砸徊簧鳎瑢?huì)導(dǎo)至 test 的結(jié)果變了個(gè)樣﹗
若您對(duì) test 還不是很有經(jīng)驗(yàn)的話，那在使用 test 時(shí)不妨先采用如下這一個(gè)"法則"：
* 假如在 test 中碰到變量替換，用 soft quote 是最保險(xiǎn)的﹗
若你對(duì) quoting 不熟的話，請(qǐng)重新溫習(xí)第四章的內(nèi)容吧... ^_^
okay，關(guān)于更多的 test 用法，老話一句：請(qǐng)看 man page 吧﹗ ^_^
雖然洋洋灑灑講了一大堆，或許你還在嘀咕.... 那... 那個(gè) return value 有啥用啊？﹗
問(wèn)得好﹗
告訴你：return value 的作用可大了﹗若你想讓你的 shell 變"聰明"的話，就全靠它了：
* 有了 return value，我們可以讓 shell 跟據(jù)不同的狀態(tài)做不同的時(shí)情...
這時(shí)候，才讓我來(lái)揭曉本章的答案吧~~~ ^_^
&& 與 || 都是用來(lái)"組建"多個(gè) command line 用的：
* command1 && command2 ：其意思是 command2 只有在 RV 為 0 (true) 的條件下執(zhí)行。
* command1 || command2 ：其意思是 command2 只有在 RV 為非 0 (false) 的條件下執(zhí)行。
來(lái)，以例子來(lái)說(shuō)好了：
CODE:[Copy to clipboard]$ A=123
$ [ -n "$A" ] && echo "yes! it's ture."
yes! it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes! it's ture."
$ [ -n "$A" ] || echo "no, it's NOT ture."
no, it's NOT ture.
(注：[ -n string ] 是測(cè)試 string 長(zhǎng)度大于 0 則為 true 。)
上例的第一個(gè) && 命令行之所以會(huì)執(zhí)行其右邊的 echo 命令，是因?yàn)樯弦粋€(gè) test 送回了 0 的 RV 值﹔
但第二次就不會(huì)執(zhí)行，因?yàn)闉?test 送回非 0 的結(jié)果...
同理，|| 右邊的 echo 會(huì)被執(zhí)行，卻正是因?yàn)樽筮叺?test 送回非 0 所引起的。
事實(shí)上，我們?cè)谕幻钚兄校捎枚鄠€(gè) && 或 || 來(lái)組建呢：
CODE:[Copy to clipboard]$ A=123
$ [ -n "$A" ] && echo "yes! it's ture." || echo "no, it's NOT ture."
yes! it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes! it's ture." || echo "no, it's NOT ture."
no, it's NOT ture.
怎樣，從這一刻開始，你是否覺得我們的 shell 是"很聰明"的呢？ ^_^
好了，最后，布置一道習(xí)題給大家做做看、、、
下面的判斷是：當(dāng) $A 被賦與值時(shí)，再看是否小于 100 ，否則送出 too big! ：
CODE:[Copy to clipboard]$ A=123
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
若我將 A 取消，照理說(shuō)，應(yīng)該不會(huì)送文字才對(duì)啊(因?yàn)榈谝粋€(gè)條件就不成立了)...
CODE:[Copy to clipboard]$ unset A
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
為何上面的結(jié)果也可得到呢？
又，如何解決之呢？
(提示：修改方法很多，其中一種方法可利用第七章介紹過(guò)的 command group ...)
快﹗告我我答案﹗其余免談....
11) >; 與 < 差在哪？
這次的題目之前我在 CU 的 shell 版已說(shuō)明過(guò)了：
[url]http://bbs.chinaunix.net/forum/24/20031030/191375.html[/url]
這次我就不重寫了，將貼子的內(nèi)容"抄"下來(lái)就是了...
11.1
談到 I/O redirection ，不妨先讓我們認(rèn)識(shí)一下 File Descriptor (FD) 。
程序的運(yùn)算，在大部份情況下都是進(jìn)行數(shù)據(jù)(data)的處理，
這些數(shù)據(jù)從哪讀進(jìn)？又，送出到哪里呢？
這就是 file descriptor (FD) 的功用了。
在 shell 程序中，最常使用的 FD 大概有三個(gè)，分別為：
0: Standard Input (STDIN)
1: Standard Output (STDOUT)
2: Standard Error Output (STDERR)
在標(biāo)準(zhǔn)情況下，這些 FD 分別跟如下設(shè)備(device)關(guān)聯(lián)：
stdin(0): keyboard
stdout(1): monitor
stderr(2): monitor
我們可以用如下下命令測(cè)試一下：
CODE:[Copy to clipboard]$ mail -s test root
this is a test mail.
please skip.
^d (同時(shí)按 crtl 跟 d 鍵)
很明顯，mail 程序所讀進(jìn)的數(shù)據(jù)，就是從 stdin 也就是 keyboard 讀進(jìn)的。
不過(guò)，不見得每個(gè)程序的 stdin 都跟 mail 一樣從 keyboard 讀進(jìn)，
因?yàn)槌绦蜃髡呖梢詮臋n案參數(shù)讀進(jìn) stdin ，如：
CODE:[Copy to clipboard]$ cat /etc/passwd
但，要是 cat 之后沒(méi)有檔案參數(shù)則又如何呢？
哦，請(qǐng)您自己玩玩看啰.... ^_^
CODE:[Copy to clipboard]$ cat
(請(qǐng)留意數(shù)據(jù)輸出到哪里去了，最后別忘了按 ^d 離開...)
至于 stdout 與 stderr ，嗯... 等我有空再續(xù)吧... ^_^
還是，有哪位前輩要來(lái)玩接龍呢？
--------------
11.2
沿文再續(xù)，書接上一回... ^_^
相信，經(jīng)過(guò)上一個(gè)練習(xí)后，你對(duì) stdin 與 stdout 應(yīng)該不難理解吧？
然后，讓我們繼續(xù)看 stderr 好了。
事實(shí)上，stderr 沒(méi)甚么難理解的：說(shuō)穿了就是"錯(cuò)誤信息"要往哪邊送而已...
比方說(shuō)，若讀進(jìn)的檔案參數(shù)是不存在的，那我們?cè)?monitor 上就看到了：
CODE:[Copy to clipboard]$ ls no.such.file
ls: no.such.file: No such file or directory
若，一個(gè)命令同時(shí)產(chǎn)生 stdout 與 stderr 呢？
那還不簡(jiǎn)單，都送到 monitor 來(lái)就好了：
CODE:[Copy to clipboard]$ touch my.file
$ ls my.file no.such.file
ls: no.such.file: No such file or directory
my.file
okay，至此，關(guān)于 FD 及其名稱、還有相關(guān)聯(lián)的設(shè)備，相信你已經(jīng)沒(méi)問(wèn)題了吧？
那好，接下來(lái)讓我們看看如何改變這些 FD 的預(yù)設(shè)數(shù)據(jù)信道，
我們可用 < 來(lái)改變讀進(jìn)的數(shù)據(jù)信道(stdin)，使之從指定的檔案讀進(jìn)。
我們可用 >; 來(lái)改變送出的數(shù)據(jù)信道(stdout, stderr)，使之輸出到指定的檔案。
比方說(shuō)：
CODE:[Copy to clipboard]$ cat < my.file
就是從 my.file 讀進(jìn)數(shù)據(jù)
CODE:[Copy to clipboard]$ mail -s test root < /etc/passwd
則是從 /etc/passwd 讀進(jìn)...
這樣一來(lái)，stdin 將不再是從 keyboard 讀進(jìn)，而是從檔案讀進(jìn)了...
嚴(yán)格來(lái)說(shuō)，< 符號(hào)之前需要指定一個(gè) FD 的(之間不能有空白)，
但因?yàn)?0 是 < 的默認(rèn)值，因此 < 與 0< 是一樣的﹗
okay，這個(gè)好理解吧？
那，要是用兩個(gè) << 又是啥呢？
這是所謂的 HERE Document ，它可以讓我們輸入一段文本，直到讀到 << 后指定的字符串。
比方說(shuō)：
CODE:[Copy to clipboard]$ cat <<FINISH
first line here
second line there
third line nowhere
FINISH
這樣的話，cat 會(huì)讀進(jìn) 3 行句子，而無(wú)需從 keyboard 讀進(jìn)數(shù)據(jù)且要等 ^d 結(jié)束輸入。
至于 >; 又如何呢？
且聽下回分解....
--------------
11.3
okay，又到講古時(shí)間~~~
當(dāng)你搞懂了 0< 原來(lái)就是改變 stdin 的數(shù)據(jù)輸入信道之后，相信要理解如下兩個(gè) redirection 就不難了：
* 1>;
* 2>;
前者是改變 stdout 的數(shù)據(jù)輸出信道，后者是改變 stderr 的數(shù)據(jù)輸出信道。
兩者都是將原本要送出到 monitor 的數(shù)據(jù)轉(zhuǎn)向輸出到指定檔案去。
由于 1 是 >; 的默認(rèn)值，因此，1>; 與 >; 是相同的，都是改 stdout 。
用上次的 ls 例子來(lái)說(shuō)明一下好了：
CODE:[Copy to clipboard]$ ls my.file no.such.file 1>;file.out
ls: no.such.file: No such file or directory
這樣 monitor 就只剩下 stderr 而已。因?yàn)?stdout 給寫進(jìn) file.out 去了。
CODE:[Copy to clipboard]$ ls my.file no.such.file 2>;file.err
my.file
這樣 monitor 就只剩下 stdout ，因?yàn)?stderr 寫進(jìn)了 file.err 。
CODE:[Copy to clipboard]$ ls my.file no.such.file 1>;file.out 2>;file.err
這樣 monitor 就啥也沒(méi)有，因?yàn)?stdout 與 stderr 都給轉(zhuǎn)到檔案去了...
呵~~~ 看來(lái)要理解 >; 一點(diǎn)也不難啦﹗是不？沒(méi)騙你吧？ ^_^
不過(guò)，有些地方還是要注意一下的。
首先，是 file locking 的問(wèn)題。比方如下這個(gè)例子：
CODE:[Copy to clipboard]$ ls my.file no.such.file 1>;file.both 2>;file.both
從 file system 的角度來(lái)說(shuō)，單一檔案在單一時(shí)間內(nèi)，只能被單一的 FD 作寫入。
假如 stdout(1) 與 stderr(2) 都同時(shí)在寫入 file.both 的話，
則要看它們?cè)趯懭霑r(shí)否碰到同時(shí)競(jìng)爭(zhēng)的情形了，基本上是"先搶先贏"的原則。
讓我們用周星馳式的"慢鏡頭"來(lái)看一下 stdout 與 stderr 同時(shí)寫入 file.out 的情形好了：
* 第 1, 2, 3 秒為 stdout 寫入
* 第 3, 4, 5 秒為 stderr 寫入
那么，這時(shí)候 stderr 的第 3 秒所寫的數(shù)據(jù)就丟失掉了﹗
要是我們能控制 stderr 必須等 stdout 寫完再寫，或倒過(guò)來(lái)，stdout 等 stderr 寫完再寫，那問(wèn)題就能解決。
但從技術(shù)上，較難掌控的，尤其是 FD 在作"長(zhǎng)期性"的寫入時(shí)...
那，如何解決呢？所謂山不轉(zhuǎn)路轉(zhuǎn)、路不轉(zhuǎn)人轉(zhuǎn)嘛，
我們可以換一個(gè)思維：將 stderr 導(dǎo)進(jìn) stdout 或?qū)?stdout 導(dǎo)進(jìn) sterr ，而不是大家在搶同一份檔案，不就行了﹗
bingo﹗就是這樣啦：
* 2>;&1 就是將 stderr 并進(jìn) stdout 作輸出
* 1>;&2 或 >;&2 就是將 stdout 并進(jìn) stderr 作輸出
于是，前面的錯(cuò)誤操作可以改為：
CODE:[Copy to clipboard]$ ls my.file no.such.file 1>;file.both 2>;&1
或
$ ls my.file no.such.file 2>;file.both >;&2
這樣，不就皆大歡喜了嗎？ 呵~~~ ^_^
不過(guò)，光解決了 locking 的問(wèn)題還不夠，我們還有其它技巧需要了解的。
故事還沒(méi)結(jié)束，別走開﹗廣告后，我們?cè)倩貋?lái)...﹗
--------------
11.4
okay，這次不講 I/O Redirction ，講佛吧...
(有沒(méi)搞錯(cuò)？﹗網(wǎng)中人是否頭殼燒壞了？...) 嘻~~~ ^_^
學(xué)佛的最高境界，就是"四大皆空"。至于是空哪四大塊？我也不知，因?yàn)槲疫€沒(méi)到那境界...
但這個(gè)"空"字，卻非常值得我們返復(fù)把玩的：
--- 色即是空、空即是色﹗
好了，施主要是能夠領(lǐng)會(huì)"空"的禪意，那離修成正果不遠(yuǎn)矣~~~
在 linux 檔案系統(tǒng)里，有個(gè)設(shè)備檔位于 /dev/null 。
許多人都問(wèn)過(guò)我那是甚么玩意兒？我跟你說(shuō)好了：那就是"空"啦﹗
沒(méi)錯(cuò)﹗空空如也的空就是 null 了.... 請(qǐng)問(wèn)施主是否忽然有所頓誤了呢？然則恭喜了~~~ ^_^
這個(gè) null 在 I/O Redirection 中可有用得很呢：
* 若將 FD1 跟 FD2 轉(zhuǎn)到 /dev/null 去，就可將 stdout 與 stderr 弄不見掉。
* 若將 FD0 接到 /dev/null 來(lái)，那就是讀進(jìn) nothing 。
比方說(shuō)，當(dāng)我們?cè)趫?zhí)行一個(gè)程序時(shí)，畫面會(huì)同時(shí)送出 stdout 跟 stderr ，
假如你不想看到 stderr (也不想存到檔案去)，那可以：
CODE:[Copy to clipboard]$ ls my.file no.such.file 2>;/dev/null
my.file
若要相反：只想看到 stderr 呢？還不簡(jiǎn)單﹗將 stdout 弄到 null 就行：
CODE:[Copy to clipboard]$ ls my.file no.such.file >;/dev/null
ls: no.such.file: No such file or directory
那接下來(lái)，假如單純只跑程序，不想看到任何輸出結(jié)果呢？
哦，這里留了一手上次節(jié)目沒(méi)講的法子，專門贈(zèng)予有緣人﹗... ^_^
除了用 >;/dev/null 2>;&1 之外，你還可以如此：
CODE:[Copy to clipboard]$ ls my.file no.such.file &>;/dev/null
(提示：將 &>; 換成 >;& 也行啦~~! )
okay？講完佛，接下來(lái)，再讓我們看看如下情況：
CODE:[Copy to clipboard]$ echo "1" >; file.out
$ cat file.out
1
$ echo "2" >; file.out
$ cat file.out
2
看來(lái)，我們?cè)谥貙?dǎo) stdout 或 stderr 進(jìn)一份檔案時(shí)，似乎永遠(yuǎn)只獲得最后一次導(dǎo)入的結(jié)果。
那，之前的內(nèi)容呢？
呵~~~ 要解決這個(gè)問(wèn)提很簡(jiǎn)單啦，將 >; 換成 >;>; 就好：
CODE:[Copy to clipboard]$ echo "3" >;>; file.out
$ cat file.out
2
3
如此一來(lái)，被重導(dǎo)的目標(biāo)檔案之內(nèi)容并不會(huì)失去，而新的內(nèi)容則一直增加在最后面去。
easy ？ 呵 ... ^_^
但，只要你再一次用回單一的 >; 來(lái)重導(dǎo)的話，那么，舊的內(nèi)容還是會(huì)被"洗"掉的﹗
這時(shí)，你要如何避免呢？
----備份﹗ yes ，我聽到了﹗不過(guò).... 還有更好的嗎？
既然與施主這么有緣份，老納就送你一個(gè)錦囊妙法吧：
CODE:[Copy to clipboard]$ set -o noclobber
$ echo "4" >; file.out
-bash: file: cannot overwrite existing file
那，要如何取消這個(gè)"限制"呢？
哦，將 set -o 換成 set +o 就行：
CODE:[Copy to clipboard]$ set +o noclobber
$ echo "5" >; file.out
$ cat file.out
5
再問(wèn)：那... 有辦法不取消而又"臨時(shí)"蓋寫目標(biāo)檔案嗎？
哦，佛曰：不可告也﹗
啊~~~ 開玩笑的、開玩笑的啦~~~ ^_^ 唉，早就料到人心是不足的了﹗
CODE:[Copy to clipboard]$ set -o noclobber
$ echo "6" >;| file.out
$ cat file.out
6
留意到?jīng)]有：在 >; 后面再加個(gè)" | "就好(注意： >; 與 | 之間不能有空白哦)....
呼.... (深呼吸吐納一下吧)~~~ ^_^
再來(lái)還有一個(gè)難題要你去參透的呢：
CODE:[Copy to clipboard]$ echo "some text here" >; file
$ cat < file
some text here
$ cat < file >; file.bak
$ cat < file.bak
some text here
$ cat < file >; file
$ cat < file
嗯？﹗注意到?jīng)]有？﹗﹗
---- 怎么最后那個(gè) cat 命令看到的 file 竟是空的？﹗
why? why? why?
同學(xué)們：下節(jié)課不要遲到啰~~~!
--------------
11.5
當(dāng)當(dāng)當(dāng)~~~ 上課啰~~~ ^_^
前面提到：$ cat < file >; file 之后原本有內(nèi)容的檔案結(jié)果卻被洗掉了﹗
要理解這一現(xiàn)像其實(shí)不難，這只是 priority 的問(wèn)題而已：
* 在 IO Redirection 中，stdout 與 stderr 的管道會(huì)先準(zhǔn)備好，才會(huì)從 stdin 讀進(jìn)資料。
也就是說(shuō)，在上例中，>; file 會(huì)先將 file 清空，然后才讀進(jìn) < file ，
但這時(shí)候檔案已經(jīng)被清空了，因此就變成讀不進(jìn)任何數(shù)據(jù)了...
哦~~~ 原來(lái)如此~~~~ ^_^
那... 如下兩例又如何呢？
CODE:[Copy to clipboard]$ cat <>; file
$ cat < file >;>; file
嗯... 同學(xué)們，這兩個(gè)答案就當(dāng)練習(xí)題啰，下節(jié)課之前請(qǐng)交作業(yè)﹗
好了，I/O Redirection 也快講完了，sorry，因?yàn)槲乙仓恢肋@么多而已啦~~~ 嘻~~ ^_^
不過(guò)，還有一樣?xùn)|東是一定要講的，各位觀眾(請(qǐng)自行配樂(lè)~!#@!$%) ：
---- 就是 pipe line 也﹗
談到 pipe line ，我相信不少人都不會(huì)陌生：
我們?cè)诤芏?command line 上常看到的" | "符號(hào)就是 pipe line 了。
不過(guò)，究竟 pipe line 是甚么東東呢？
別急別急... 先查一下英漢字典，看看 pipe 是甚么意思？
沒(méi)錯(cuò)﹗它就是"水管"的意思...
那么，你能想象一下水管是怎么一根接著一根的嗎？
又，每根水管之間的 input 跟 output 又如何呢？
嗯？？
靈光一閃：原來(lái) pipe line 的 I/O 跟水管的 I/O 是一模一樣的：
* 上一個(gè)命令的 stdout 接到下一個(gè)命令的 stdin 去了﹗
的確如此... 不管在 command line 上你使用了多少個(gè) pipe line ，
前后兩個(gè) command 的 I/O 都是彼此連接的﹗(恭喜：你終于開竅了﹗ ^_^ )
不過(guò)... 然而... 但是... ... stderr 呢？
好問(wèn)題﹗不過(guò)也容易理解：
* 若水管漏水怎么辦？
也就是說(shuō)：在 pipe line 之間，前一個(gè)命令的 stderr 是不會(huì)接進(jìn)下一命令的 stdin 的，
其輸出，若不用 2>; 導(dǎo)到 file 去的話，它還是送到監(jiān)視器上面來(lái)﹗
這點(diǎn)請(qǐng)你在 pipe line 運(yùn)用上務(wù)必要注意的。
那，或許你又會(huì)問(wèn)：
* 有辦法將 stderr 也喂進(jìn)下一個(gè)命令的 stdin 去嗎？
(貪得無(wú)厭的家伙﹗)
方法當(dāng)然是有，而且你早已學(xué)過(guò)了﹗ ^_^
我提示一下就好：
* 請(qǐng)問(wèn)你如何將 stderr 合并進(jìn) stdout 一同輸出呢？
若你答不出來(lái)，下課之后再來(lái)問(wèn)我吧... (如果你臉皮真夠厚的話...)
或許，你仍意尤未盡﹗或許，你曾經(jīng)碰到過(guò)下面的問(wèn)題：
* 在 cm1 | cm2 | cm3 ... 這段 pipe line 中，若要將 cm2 的結(jié)果存到某一檔案呢？
若你寫成 cm1 | cm2 >; file | cm3 的話，
那你肯定會(huì)發(fā)現(xiàn) cm3 的 stdin 是空的﹗(當(dāng)然啦，你都將水管接到別的水池了﹗)
聰明的你或許會(huì)如此解決：
CODE:[Copy to clipboard]cm1 | cm2 >; file ; cm3 < file
是的，你的確可以這樣做，但最大的壞處是：這樣一來(lái)，file I/O 會(huì)變雙倍﹗
在 command 執(zhí)行的整個(gè)過(guò)程中，file I/O 是最常見的最大效能殺手。
凡是有經(jīng)驗(yàn)的 shell 操作者，都會(huì)盡量避免或降低 file I/O 的頻率。
那，上面問(wèn)題還有更好方法嗎？
有的，那就是 tee 命令了。
* 所謂 tee 命令是在不影響原本 I/O 的情況下，將 stdout 復(fù)制一份到檔案去。
因此，上面的命令行可以如此打：
CODE:[Copy to clipboard]cm1 | cm2 | tee file | cm3
在預(yù)設(shè)上，tee 會(huì)改寫目標(biāo)檔案，若你要改為增加內(nèi)容的話，那可用 -a 參數(shù)達(dá)成。
基本上，pipe line 的應(yīng)用在 shell 操作上是非常廣泛的，尤其是在 text filtering 方面，
凡舉 cat, more, head, tail, wc, expand, tr, grep, sed, awk, ... 等等文字處理工具，
搭配起 pipe line 來(lái)使用，你會(huì)驚覺 command line 原來(lái)是活得如此精彩的﹗
常讓人有"眾里尋他千百度，驀然回首，那人卻在燈火闌珊處﹗"之感... ^_^
....
好了，關(guān)于 I/O Redirection 的介紹就到此告一段落。
若日后有空的話，再為大家介紹其它在 shell 上好玩的東西﹗bye... ^_^
-------------------------------------------------------------------------------------------------
12) 你要 if 還是 case 呢？
放了一個(gè)愉快的春節(jié)假期，人也變得懶懶散散的... 只是，答應(yīng)了大家的作業(yè)，還是要堅(jiān)持完成就是了~~~
還記得我們?cè)诘?10 章所介紹的 return value 嗎？
是的，接下來(lái)介紹的內(nèi)容與之有關(guān)，若你的記憶也被假期的歡樂(lè)時(shí)光所抵消掉的話，
那，建議您還是先回去溫習(xí)溫習(xí)再回來(lái)...
若你記得 return value ，我想你也應(yīng)該記得了 && 與 || 是甚么意思吧？
用這兩個(gè)符號(hào)再配搭 command group 的話，我們可讓 shell script 變得更加聰明哦。
比方說(shuō)：
CODE:[Copy to clipboard]comd1 && {
comd2
comd3
} || {
comd4
comd5
}
意思是說(shuō)：
假如 comd1 的 return value 為 true 的話，
然則執(zhí)行 comd2 與 comd3 ，
否則執(zhí)行 comd4 與 comd5 。
事實(shí)上，我們?cè)趯?shell script 的時(shí)候，經(jīng)常需要用到這樣那樣的條件以作出不同的處理動(dòng)作。
用 && 與 || 的確可以達(dá)成條件執(zhí)行的效果，然而，從"人類語(yǔ)言"上來(lái)理解，卻不是那么直觀。
更多時(shí)候，我們還是喜歡用 if .... then ... else ... 這樣的 keyword 來(lái)表達(dá)條件執(zhí)行。
在 bash shell 中，我們可以如此修改上一段代碼：
CODE:[Copy to clipboard]if comd1
then
comd2
comd3
else
comd4
comd5
fi
這也是我們?cè)?shell script 中最常用到的 if 判斷式：
只要 if 后面的 command line 返回 true 的 return value (我們最常用 test 命令來(lái)送出 return value)，
然則就執(zhí)行 then 后面的命令，否則執(zhí)行 else 后的命令﹔fi 則是用來(lái)結(jié)束判斷式的 keyword 。
在 if 判斷式中，else 部份可以不用，但 then 是必需的。
(若 then 后不想跑任何 command ，可用" ： " 這個(gè) null command 代替)。
當(dāng)然，then 或 else 后面，也可以再使用更進(jìn)一層的條件判斷式，這在 shell script 設(shè)計(jì)上很常見。
若有多項(xiàng)條件需要"依序"進(jìn)行判斷的話，那我們則可使用 elif 這樣的 keyword ：
CODE:[Copy to clipboard]if comd1; then
comd2
elif comd3; then
comd4
else
comd5
fi
意思是說(shuō)：
若 comd1 為 true ，然則執(zhí)行 comd2 ﹔
否則再測(cè)試 comd3 ，然則執(zhí)行 comd4 ﹔
倘若 comd1 與 comd3 均不成立，那就執(zhí)行 comd5 。
if 判斷式的例子很常見，你可從很多 shell script 中看得到，我這里就不再舉例子了...
接下來(lái)要為大家介紹的是 case 判斷式。
雖然 if 判斷式已可應(yīng)付大部份的條件執(zhí)行了，然而，在某些場(chǎng)合中，卻不夠靈活，
尤其是在 string 式樣的判斷上，比方如下：
CODE:[Copy to clipboard]QQ () {
echo -n "Do you want to continue? (Yes/No): "
read YN
if [ "$YN" = Y -o "$YN" = y -o "$YN" = "Yes" -o "$YN" = "yes" -o "$YN" = "YES" ]
then
QQ
else
exit 0
fi
}
QQ
從例中，我們看得出來(lái)，最麻煩的部份是在于判斷 YN 的值可能有好幾種式樣。
聰明的你或許會(huì)如此修改：
CODE:[Copy to clipboard]...
if echo "$YN" | grep -q '^[Yy]\([Ee][Ss]\)*$'
...
也就是用 Regular Expression 來(lái)簡(jiǎn)化代碼。(我們有機(jī)會(huì)再來(lái)介紹 RE)
只是... 是否有其它更方便的方法呢？
有的，就是用 case 判斷式即可：
CODE:[Copy to clipboard]QQ () {
echo -n "Do you want to continue? (Yes/No): "
read YN
case "$YN" in
[Yy]|[Yy][Ee][Ss])
QQ
;;
*)
exit 0
;;
esac
}
QQ
我們常 case 的判斷式來(lái)判斷某一變量在同的值(通常是 string)時(shí)作出不同的處理，
比方說(shuō)，判斷 script 參數(shù)以執(zhí)行不同的命令。
若你有興趣、且用 linux 系統(tǒng)的話，不妨挖一挖 /etc/init.d/* 里那堆 script 中的 case 用法。
如下就是一例：
CODE:[Copy to clipboard]case "$1" in
start)
start
;;
stop)
stop
;;
status)
rhstatus
;;
restart|reload)
restart
;;
condrestart)
[ -f /var/lock/subsys/syslog ] && restart || :
;;
*)
echo $"Usage: $0 {start|stop|status|restart|condrestart}"
exit 1
esac
(若你對(duì) positional parameter 的印像已經(jīng)模糊了，請(qǐng)重看第 9 章吧。)
---------------------------------------------------------------------------------------------------------
13) for what? while 與 until 差在哪？
終于，來(lái)到 shell 十三問(wèn)的最后一問(wèn)了... 長(zhǎng)長(zhǎng)吐一口氣~~~~
最后要介紹的是 shell script 設(shè)計(jì)中常見的"循環(huán)"(loop)。
所謂的 loop 就是 script 中的一段在一定條件下反復(fù)執(zhí)行的代碼。
bash shell 中常用的 loop 有如下三種：
* for
* while
* until
for loop 是從一個(gè)清單列表中讀進(jìn)變量值，并"依次"的循環(huán)執(zhí)行 do 到 done 之間的命令行。
例：
CODE:[Copy to clipboard]for var in one two three four five
do
echo -----------
echo '$var is '$var
echo
done
上例的執(zhí)行結(jié)果將會(huì)是：
1) for 會(huì)定義一個(gè)叫 var 的變量，其值依次是 one two three four five 。
2) 因?yàn)橛?5 個(gè)變量值，因此 do 與 done 之間的命令行會(huì)被循環(huán)執(zhí)行 5 次。
3) 每次循環(huán)均用 echo 產(chǎn)生三行句子。
而第二行中不在 hard quote 之內(nèi)的 $var 會(huì)依次被替換為 one two three four five 。
4) 當(dāng)最后一個(gè)變量值處理完畢，循環(huán)結(jié)束。
我們不難看出，在 for loop 中，變量值的多寡，決定循環(huán)的次數(shù)。
然而，變量在循環(huán)中是否使用則不一定，得視設(shè)計(jì)需求而定。
倘若 for loop 沒(méi)有使用 in 這個(gè) keyword 來(lái)指定變量值清單的話，其值將從 $@ (或 $* )中繼承：
CODE:[Copy to clipboard]for var; do
....
done
(若你忘記了 positional parameter ，請(qǐng)溫習(xí)第 9 章...)
for loop 用于處理"清單"(list)項(xiàng)目非常方便，
其清單除了可明確指定或從 positional parameter 取得之外，
也可從變量替換或命令替換取得... (再一次提醒：別忘了命令行的"重組"特性﹗)
然而，對(duì)于一些"累計(jì)變化"的項(xiàng)目(如整數(shù)加減)，for 亦能處理：
CODE:[Copy to clipboard]for ((i=1;i<=10;i++))
do
echo "num is $i"
done
除了 for loop ，上面的例子我們也可改用 while loop 來(lái)做到：
CODE:[Copy to clipboard]num=1
while [ "$num" -le 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
while loop 的原理與 for loop 稍有不同：
它不是逐次處理清單中的變量值，而是取決于 while 后面的命令行之 return value ：
* 若為 ture ，則執(zhí)行 do 與 done 之間的命令，然后重新判斷 while 后的 return value 。
* 若為 false ，則不再執(zhí)行 do 與 done 之間的命令而結(jié)束循環(huán)。
分析上例：
1) 在 while 之前，定義變量 num=1 。
2) 然后測(cè)試(test) $num 是否小于或等于 10 。
3) 結(jié)果為 true ，于是執(zhí)行 echo 并將 num 的值加一。
4) 再作第二輪測(cè)試，其時(shí) num 的值為 1+1=2 ，依然小于或等于 10，因此為 true ，繼續(xù)循環(huán)。
5) 直到 num 為 10+1=11 時(shí)，測(cè)試才會(huì)失敗... 于是結(jié)束循環(huán)。
我們不難發(fā)現(xiàn)：
* 若 while 的測(cè)試結(jié)果永遠(yuǎn)為 true 的話，那循環(huán)將一直永久執(zhí)行下去：
CODE:[Copy to clipboard]while :; do
echo looping...
done
上例的" : "是 bash 的 null command ，不做任何動(dòng)作，除了送回 true 的 return value 。
因此這個(gè)循環(huán)不會(huì)結(jié)束，稱作死循環(huán)。
死循環(huán)的產(chǎn)生有可能是故意設(shè)計(jì)的(如跑 daemon)，也可能是設(shè)計(jì)錯(cuò)誤。
若要結(jié)束死尋環(huán)，可透過(guò) signal 來(lái)終止(如按下 ctrl-c )。
(關(guān)于 process 與 signal ，等日后有機(jī)會(huì)再補(bǔ)充，十三問(wèn)暫時(shí)略過(guò)。)
一旦你能夠理解 while loop 的話，那，就能理解 until loop ：
* 與 while 相反，until 是在 return value 為 false 時(shí)進(jìn)入循環(huán)，否則結(jié)束。
因此，前面的例子我們也可以輕松的用 until 來(lái)寫：
CODE:[Copy to clipboard]num=1
until [ ! "$num" -le 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
或是：
CODE:[Copy to clipboard]num=1
until [ "$num" -gt 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
okay ，關(guān)于 bash 的三個(gè)常用的 loop 暫時(shí)介紹到這里。
在結(jié)束本章之前，再跟大家補(bǔ)充兩個(gè)與 loop 有關(guān)的命令：
* break
* continue
這兩個(gè)命令常用在復(fù)合式循環(huán)里，也就是在 do ... done 之間又有更進(jìn)一層的 loop ，
當(dāng)然，用在單一循環(huán)中也未嘗不可啦... ^_^
break 是用來(lái)打斷循環(huán)，也就是"強(qiáng)迫結(jié)束" 循環(huán)。
若 break 后面指定一個(gè)數(shù)值 n 的話，則"從里向外"打斷第 n 個(gè)循環(huán)，
默認(rèn)值為 break 1 ，也就是打斷當(dāng)前的循環(huán)。
在使用 break 時(shí)需要注意的是， 它與 return 及 exit 是不同的：
* break 是結(jié)束 loop
* return 是結(jié)束 function
* exit 是結(jié)束 script/shell
而 continue 則與 break 相反：強(qiáng)迫進(jìn)入下一次循環(huán)動(dòng)作。
若你理解不來(lái)的話，那你可簡(jiǎn)單的看成：在 continue 到 done 之間的句子略過(guò)而返回循環(huán)頂端...
與 break 相同的是：continue 后面也可指定一個(gè)數(shù)值 n ，以決定繼續(xù)哪一層(從里向外計(jì)算)的循環(huán)，
默認(rèn)值為 continue 1 ，也就是繼續(xù)當(dāng)前的循環(huán)。
在 shell script 設(shè)計(jì)中，若能善用 loop ，將能大幅度提高 script 在復(fù)雜條件下的處理能力。
請(qǐng)多加練習(xí)吧....
posted on 2009-06-02 09:03
chatler 閱讀(494)
評(píng)論(0) 編輯 收藏 引用 所屬分類:
Shell