shell 十三問?

IFS=; 其實就是 IFS=
請記著﹗

當 IFS 為 null 時，在 $* (也就是 positional parameter)將被視為單一的 word ，因為跟本沒區隔嘛(想想 IFS 作啥用？)....
a=" abc"
之後，若 IFS 沒改變的話，那下面兩行是有差別的：
echo $a
echo "$a"
差別就在 quoting ! (自己再想想 space 在 soft quote 是否為 IFS ？)

若 IFS=
再跑上兩行 echo ，那就沒差了，
因為不管 space 在 quoting 內還是外，都不是 IFS ﹗

shell 十三問?

渐渐清楚了一些,也就是说
IFS=
就是说command_line无间隔,把command_line当作一个整体,对行处理,因为处理用的分隔符为空,就是没有.
网中人兄:
    我是这样认为的,请问对吗!!!

shell 十三問?

[quote][i]原帖由 "黑骏马"]就是说command_line无间隔,把command_line当作一个整体[/quote 发表：[/i]

精確來說，不是整行 command line ，而是 $1 這個 positional parameter 之後的部份。
$0 與 $1 之間那個 space 還是 IFS ，但後面的就不是了...

(要是對 $0 $1 ... 這些 positional parameter 不了解，請看我日後的續貼吧...)

shell 十三問?

5) var=value？export 前後差在哪？

這次讓我們暫時丟開 command line ，先來了解一下 bash 變量(variable)吧...

所謂的變量，就是利用一個特定的"名稱"(name)來存取一段可以變化的"值"(value)。

*設定(set)*
在 bash 中，你可以用 "=" 來設定或重新定義變量的內容：
        name=value
在設定變量的時侯，得遵守如下規則：
        * 等號左右兩邊不能使用區隔符號(IFS)，也應避免使用 shell 的保留字元(meta charactor)。
        * 變量名稱不能使用 $ 符號。
        * 變量名稱的第一個字母不能是數字(number)。
        * 變量名稱長度不可超過 256 個字母。
        * 變量名稱及變量值之大小寫是有區別的(case sensitive)。

如下是一些變量設定時常見的錯誤：
        A= B        ：不能有 IFS
        1A=B        ：不能以數字開頭
        $A=B        ：名稱不能有 $
        a=B                ：這跟 a=b 是不同的（這不是錯誤，提醒 windows 的使用者要特別注意）
如下則是可以接受的設定：
        A=" B"        ：IFS 被關閉了 (請參考前面的 quoting 章節)
        A1=B        ：並非以數字開頭
        A=$B        ：$ 可用在變量值內
        This_Is_A_Long_Name=b        ：可用 _ 連接較長的名稱或值，且大小寫有別。

*變量替換(substitution)*
Shell 之所以強大，其中的一個因素是它可以在命令行中對變量作替換(substitution)處理。
在命令行中使用者可以使用 $ 符號加上變量名稱(除了在用 = 號定義變量名稱之外)，
將變量值給替換出來，然後再重新組建命令行。
比方：
[code]        $ A=ls
        $ B=la
        $ C=/tmp
        $ $A -$B $C[/code]
        (注意：以上命令行的第一個 $ 是 shell prompt ，並不在命令行之內。)
必需強調的是，我們所提的變量替換，只發生在 command line 上面。(是的，讓我們再回到 command line 吧﹗)
仔細分析最後那行 command line ，不難發現在被執行之前(在輸入 CR 字符之前)，
$ 符號會對每一個變量作替換處理(將變量值替換出來再重組命令行)，最後會得出如下命令行：
[code]        ls -la /tmp[/code]
還記得第二章我請大家"務必理解"的那兩句嗎？若你忘了，那我這裡再重貼一遍：
[quote]若從技術細節來看，shell 會依據 IFS(Internal Field Seperator) 將 command line 所輸入的文字給拆解為"字段"(word)。
然後再針對特殊字符(meta)先作處理，最後再重組整行 command line 。 [/quote]
這裡的 $ 就是 command line 中最經典的 meta 之一了，就是作變量替換的﹗
在日常的 shell 操作中，我們常會使用 echo 命令來查看特定變量的值，例如：
[code]        $ echo $A -$B $C[/code]
我們已學過， echo 命令只單純將其 argument 送至"標準輸出"(STDOUT，通常是我們的熒幕)。
所以上面的命令會在熒幕上得到如下結果：
[code]        ls -la /tmp[/code]
這是由於 echo 命令在執行時，會先將 $A(ls)、$B(la)、跟 $C(/tmp) 給替換出來的結果。

利用 shell 對變量的替換處理能力，我們在設定變量時就更為靈活了：
        A=B
        B=$A
這樣，B 的變量值就可繼承 A 變量"當時"的變量值了。
不過，不要以"數學羅輯"來套用變量的設定，比方說：
        A=B
        B=C
這樣並不會讓 A 的變量值變成 C 。再如：
        A=B
        B=$A
        A=C
同樣也不會讓 B 的值換成 C 。
上面是單純定義了兩個不同名稱的變量：A 與  B ，它們的值分別是 B 與  C 。
若變量被重復定義的話，則原有舊值將被新值所取代。(這不正是"可變的量"嗎？  ^_^)
當我們在設定變量的時侯，請記著這點：
        * 用一個名稱儲存一個數值
僅此而已。

此外，我們也可利用命令行的變量替換能力來"擴充"(append)變量值：
        A=B:C:D
        A=$A:E
這樣，第一行我們設定 A 的值為 "B:C:D"，然後，第二行再將值擴充為 "B:C:D:E" 。
上面的擴充範例，我們使用區隔符號( : )來達到擴充目的，
要是沒有區隔符號的話，如下是有問題的：
        A=BCD
        A=$AE
因為第二次是將 A 的值繼承 $AE 的提換結果，而非 $A 再加 E ﹗
要解決此問題，我們可用更嚴謹的替換處理：
        A=BCD
        A=${A}E
上例中，我們使用 {} 將變量名稱的範圍給明確定義出來，
如此一來，我們就可以將 A 的變量值從 BCD 給擴充為 BCDE 。

(提示：關於 ${name} 事實上還可做到更多的變量處理能力，這些均屬於比較進階的變量處理，
現階段暫時不介紹了，請大家自行參考資料。如 CU 的貼子：
[url]http://www.chinaunix.net/forum/viewtopic.php?t=201843[/url]
)

* export *

嚴格來說，我們在當前 shell 中所定義的變量，均屬於"本地變量"(local variable)，
只有經過 export 命令的"輸出"處理，才能成為環境變量(environment variable)：
[code]        $ A=B
        $ export A[/code]
或：
[code]        $ export A=B[/code]
經過 export 輸出處理之後，變量 A 就能成為一個環境變量供其後的命令使用。
在使用 export  的時侯，請別忘記 shell 在命令行對變量的"替換"(substitution)處理，
比方說：
[code]        $ A=B
        $ B=C
        $ export $A[/code]
上面的命令並未將 A 輸出為環境變量，而是將 B 作輸出，
這是因為在這個命令行中，$A 會首先被替換為 B， 然後再"塞回"作 export 的參數。

要理解這個 export ，事實上需要從 process 的角度來理解才能透徹。
我將於下一章為大家說明 process 的觀念，敬請留意。

*取消變量*

要取消一個變量，在 bash 中可使用 unset 命令來處理：
[code]        unset A[/code]
與 export 一樣，unset 命令行也同樣會作變量替換(這其實就是 shell 的功能之一)，
因此：
[code]        $ A=B
        $ B=C
        $ unset $A[/code]
事實上所取消的變量是 B 而不是 A 。

此外，變量一旦經過 unset 取消之後，其結果是將整個變量拿掉，而不僅是取消其變量值。
如下兩行其實是很不一樣的：
[code]        $ A=
        $ unset A[/code]
第一行只是將變量 A 設定為"空值"(null  value)，但第二行則讓變量 A 不在存在。
雖然用眼睛來看，這兩種變量狀態在如下命令結果中都是一樣的：
[code]        $ A=
        $ echo $A

        $ unset A
        $ echo $A
        [/code]
請學員務必能識別 null value 與 unset 的本質區別，這在一些進階的變量處理上是很嚴格的。
比方說：
[code]        $ str=                # 設為 null
        $ var=${str=expr}        # 定義 var
        $ echo $var
       
        $ echo $str
       
        $ unset str        # 取消
        $ var=${str=expr}        # 定義 var
        $ echo $var
        expr
        $ echo $str
        expr[/code]
聰明的讀者(yes, you!)，稍加思考的話，
應該不難發現為何同樣的 var=${str=expr} 在 null 與 unset 之下的不同吧？
若你看不出來，那可能是如下原因之一：
a. 你太笨了
b. 不了解  var=${str=expr}        這個進階處理
c. 對本篇說明還沒來得及消化吸收
e. 我講得不好
不知，你選哪個呢？....  ^_^

[[i] 本帖最后由 網中人 于 2008-10-30 02:12 编辑 [/i]]

shell 十三問?

support好文章

shell 十三問?

$ var=${str=expr}   # 定義 var

这个是啥用法,只见过${str:=expr}

麻烦网中人解释一下,man bash没说你这个用法

shell 十三問?

嗯... 好吧，我就解釋一下 var=${str=expr} ：

首先，var=$str 這個大家都可理解吧。
而接下來的思考方向是，究竟 $str 這個變量是如下哪一種情況呢：
1) unset
2) null
3) not null

1) 假如是 unset ，那麼 var=${str=expr} 的結果將是：
var=expr
str=expr

2) 假如是 null ，那 var=${str=expr} 的結果是：
var=
str=

3) 假如是 not null (比方為 xyz )，那 var=${str=expr} 之結果是：
var=xyz
str=xyz

shell 十三問?

${str=expr}还是不大懂.他是先判断str的值?然后把expr付给str?

还是其他的方式?

他是${str:=expr}的变种嘛?

shell 十三問?

嗯？不是抓著 ${str} 是 not set, null, not null 這三種狀態來理解就行了嗎？
不用急，你先自己逐一試試嘛：

[code]showvar() {
    var=${str=expr}
    echo \$var is $var
    echo \$str is $str
}
unset str
showvar
str=
showvar
str=xyz
showvar[/code]

接下來，再來看看 var=${str:=expr} 好了：
1) $str 為 not set ：
var=expr
str=expr

2) $str 為 null ：
var=expr
str=expr

3) $str 為 not null (str=xyz)：
var=xyz
str=xyz

最後比教一下 ${str=expr} 與 ${str:=expr} ：
* 兩者在 not set 與 not null 都一至
* 但當 null 值時，前者會將 $var 與 $str 都設為 null ，但後者則設為 expr

從這個再延伸出其他類比，不防請大家"實作"觀查一下有何不同？
var=${str-expr} vs var=${str:-expr}
var=${str+expr} vs var=${str:+expr}
var=${str?expr} vs var=${str:?expr}

hey you: 別偷懶﹗快做做看... hurry up!

shell 十三問?

[code]showvar() {
    var=${str-expr}
    echo \$var is $var
    echo \$str is $str
}

_____________________________
${str=expr}的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
$var is expr
$str is expr
[root@iamok -->root]# str=
[root@iamok -->root]# showvar
$var is
$str is
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is 999
$str is 999


${str:=expr}的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
$var is expr
$str is expr
[root@iamok -->root]# str=   
[root@iamok -->root]# showvar
$var is expr
$str is expr
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is 999
$str is 999



${str-expr}的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
$var is expr  
$str is
[root@iamok -->root]# str=
[root@iamok -->root]# showvar
$var is
$str is
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is 999
$str is 999


${str:-expr}的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
$var is expr
$str is
[root@iamok -->root]# str=
[root@iamok -->root]# showvar
$var is expr
$str is
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is 999
$str is 999


${str+expr}的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
$var is
$str is
[root@iamok -->root]# str=
[root@iamok -->root]# showvar
$var is expr
$str is
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is expr
$str is 999



var=${str:+expr} 的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
$var is
$str is
[root@iamok -->root]# str=
[root@iamok -->root]# showvar
$var is
$str is
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is expr
$str is 999


var=${str?expr} 的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
-bash: str: expr
[root@iamok -->root]# str=
[root@iamok -->root]# showvar
$var is
$str is
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is 999
$str is 999


var=${str:?expr} 的结果
[root@iamok -->root]# unset str
[root@iamok -->root]# showvar
-bash: str: expr
[root@iamok -->root]# str=
[root@iamok -->root]# showvar
-bash: str: expr
[root@iamok -->root]# str=999
[root@iamok -->root]# showvar
$var is 999
$str is 999
[/code]

做了.看来${str-expr}就是${str:-expr}的变种了,没有:在str是null或者noset的时候都是不一样的结果.有:的都是一样的结果.

shell 十三問?

我倒覺得沒甚麼變種不變種的....
反過來，我是否說帶 : 是沒 : 的變種呢？
總之，仔細區分每一種不同的情況及替換運用，這才是重要的....

p.s.
再囉唆一下：
下次做練習，請不要用 root 帳號﹗慎記慎記~~~

shell 十三問?

这么多好东西,真想一口吃完,又怕消化不了.呵呵~~
网中人老师,可真辛苦您了!

shell 十三問?

A=B
B=$A
這樣，B 的變量值就可繼承 A 變量"當時"的變量值了
这段文字我看不太懂,,网中人可不可以再详解一下,特别是"当时"指的是什么

shell 十三問?

B=$A 是在 command line 中完成的。
請別忘了我一再強調的如下文字：
[quote]若從技術細節來看，shell 會依據 IFS(Internal Field Seperator) 將 command line 所輸入的文字給拆解為"字段"(word)。
然後再針對特殊字符(meta)先作處理，最後再重組整行 command line 。 [/quote]

也就是 command line 碰到 $A 時，會先提換出 $A 的值(當時的值)，也就是 B 。
於是，B=$A 就是 B=B 了...

shell 十三問?

原来这么简单啊!谢谢网中人的指点了.

shell 十三問?

6) exec 跟 source 差在哪？

這次先讓我們從 CU Shell 版的一個實例貼子來談起吧：
(論壇改版後原連結已經失效 )

例中的提問原文如下：
[quote]
cd /etc/aa/bb/cc可以執行
但是把這條命令寫入shell時shell不執行！
這是什么原因呀！
[/quote]
（意思是：運行腳本後并沒有移到 /etc/aa/bb/cc 目錄）

我當時如何回答暫時別去深究，先讓我們了解一下行程(process)的觀念好了。
首先，我們所執行的任何程式，都是由父行程(parent process)所產生出來的一個子行程(child process)，
子行程在結束後，將返回到父行程去。此一現像在 Linux 系統中被稱為  fork 。
(為何要程為 fork 呢？嗯，畫一下圖或許比較好理解...  ^_^ )
當子行程被產生的時候，將會從父行程那裡獲得一定的資源分配、及(更重要的是)繼承父行程的環境﹗
讓我們回到上一章所談到的"環境變量"吧：
* 所謂環境變量其實就是那些會傳給子行程的變量。
簡單而言，"遺傳性"就是區分本地變量與環境變量的決定性指標。
然而，從遺傳的角度來看，我們也不難發現環境變量的另一個重要特徵：
* 環境變量只能從父行程到子行程單向繼承。換句話說：在子行程中的環境如何變更，均不會影響父行程的環境。

接下來，再讓我們了解一下命令腳本(shell script)的概念。
所謂的 shell script 講起來很簡單，就是將你平時在 shell prompt 後所輸入的多行 command line 依序寫入一個文件去而已。
其中再加上一些條件判斷、互動界面、參數運用、函數調用等等技巧，得以讓 script 更加"聰明"的執行，
但若撇開這些技巧不談，我們真的可以簡單的看成 script 只不過依次執行預先寫好的命令行而已。

再結合以上兩個概念(process + script)，那應該就不難理解如下這句話的意思了：
* 正常來說，當我們執行一個 shell script 時，其實是先產生一個 sub-shell 的子行程，然後 sub-shell 再去產生命令行的子行程。
然則，那讓我們回到本章開始時所提到的例子再從新思考：
[quote]
cd /etc/aa/bb/cc可以執行
但是把這條命令寫入shell時shell不執行！
這是什么原因呀！
[/quote]

我當時的答案是這樣的：
[quote]
因為，一般我們跑的 shell script 是用 subshell 去執行的。
從 process 的觀念來看，是 parent process 產生一個 child process 去執行，
當 child 結束後，會返回 parent ，但 parent 的環境是不會因 child 的改變而改變的。
所謂的環境元數很多，凡舉 effective id, variable, workding dir 等等...
其中的 workding dir ($PWD) 正是樓主的疑問所在：
當用 subshell 來跑 script 的話，sub shell 的 $PWD 會因為 cd 而變更，
但當返回 primary shell 時，$PWD 是不會變更的。 [/quote]

能夠了解問題的原因及其原理是很好的，但是？如何解決問題恐怕是我們更感興趣的﹗是吧？^_^
那好，接下來，再讓我們了解一下 source 命令好了。
當你有了 fork 的概念之後，要理解 source 就不難：
* 所謂 source 就是讓 script 在當前 shell 內執行、而不是產生一個 sub-shell 來執行。
由於所有執行結果均於當前 shell 內完成，若 script 的環境有所改變，當然也會改變當前環境了﹗
因此，只要我們將原本單獨輸入的 script 命令行變成 source 命令的參數，就可輕易解決前例提到的問題了。
比方說，原本我們是如此執行  script 的：
[code]./my.script[/code]
現在改成這樣即可：
[code]source ./my.script
或：
. ./my.script[/code]

說到這裡，我想，各位有興趣看看 /etc 底下的眾多設定文件，
應該不難理解它們被定議後，如何讓其他 script 讀取並繼承了吧？
若然，日後你有機會寫自己的 script ，應也不難專門指定一個設定文件以供不同的 script 一起"共用"了...  ^_^

okay，到這裡，若你搞得懂 fork 與 source 的不同，那接下來再接受一個挑戰：
---- 那 exec 又與 source/fork 有何不同呢？
哦... 要了解 exec 或許較為複雜，尤其扯上 File Descriptor 的話...
不過，簡單來說：
* exec 也是讓 script 在同一個行程上執行，但是原有行程則被結束了。
也就是簡而言之：原有行程會否終止，就是 exec 與 source/fork 的最大差異了。

嗯，光是從理論去理解，或許沒那麼好消化，不如動手"實作+思考"來的印象深刻哦。
下面讓我們寫兩個簡單的 script ，分別命名為 1.sh 及 2.sh ：

1.sh
[code]
#!/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"
[/code]

2.sh
[code]
#!/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"
[/code]

然後，分別跑如下參數來觀察結果：
[code]
$ ./1.sh fork
$ ./1.sh source
$ ./1.sh exec
[/code]

或是，你也可以參考 CU 上的另一貼子：
[url]http://www.chinaunix.net/forum/viewtopic.php?t=191051[/url]

好了，別忘了仔細比較輸出結果的不同及背後的原因哦...
若有疑問，歡迎提出來一起討論討論~~~

happy scripting! ^_^

[[i] 本帖最后由 網中人 于 2008-10-30 02:17 编辑 [/i]]

shell 十三問?

纲中人版主可不可以说说var=${str=expr}怎么理解啊!
对于
str=
var=${str=expr}
我的理解是先赋给str空值,然后再用str=expr这个语句来把空值用expr替代!所以我认为
echo $str和echo $var也都应该是expr.

shell 十三問?

[quote][i]原帖由 "lzblzb" 发表：[/i]
纲中人版主可不可以说说var=${str=expr}怎么理解啊!
对于
str=
var=${str=expr}
我的理解是先赋给str空值,然后再用str=expr这个语句来把空值用expr替代!所以我认为
echo $str和echo $var也都应该是expr.[/quote]
嗯，這個前面已經討論過了，我不再重複了...

shell 十三問?

7) ( ) 與 { } 差在哪？

嗯，這次輕鬆一下，不講太多...  ^_^

先說一下，為何要用 ( ) 或 { } 好了。
許多時候，我們在 shell 操作上，需要在一定條件下一次執行多個命令，
也就是說，要麼不執行，要麼就全執行，而不是每次依序的判斷是否要執行下一個命令。
或是，需要從一些命令執行優先次順中得到豁免，如算術的 2*(3+4) 那樣...
這時候，我們就可引入"命令群組"(command group)的概念：將多個命令集中處理。

在 shell command line 中，一般人或許不太計較 ( ) 與 { } 這兩對符號的差異，
雖然兩者都可將多個命令作群組化處理，但若從技術細節上，卻是很不一樣的：
( ) 將 command group 置於 sub-shell 去執行，也稱 nested sub-shell。
{ } 則是在同一個 shell 內完成，也稱為 non-named command group。
若，你對上一章的 fork 與 source 的概念還記得了的話，那就不難理解兩者的差異了。
要是在 command group 中扯上變量及其他環境的修改，我們可以根據不同的需求來使用 ( ) 或 { } 。
通常而言，若所作的修改是臨時的，且不想影響原有或以後的設定，那我們就 nested sub-shell ，
反之，則用 non-named command group 。

是的，光從 command line 來看，( ) 與 { } 的差別就講完了，夠輕鬆吧~~~  ^_^
然而，若這兩個 meta 用在其他 command meta 或領域中(如 Regular Expression)，還是有很多差別的。
只是，我不打算再去說明了，留給讀者自己慢慢發掘好了...
我這裡只想補充一個概念，就是 function 。
所謂的 function ，就是用一個名字去命名一個  command group ，然後再調用這個名字去執行 command group 。
從 non-named command group 來推斷，大概你也可以猜到我要說的是 { } 了吧？(yes! 你真聰明﹗  ^_^ )

在 bash 中，function 的定義方式有兩種：
方式一：
[code]function function_name {
    command1
    command2
    command3
    ....
}[/code]
方式二：
[code]fuction_name () {
    command1
    command2
    command3
    ....
}[/code]
用哪一種方式無所謂，只是若碰到所定意的名稱與現有的命令或別名(Alias)衝突的話，方式二或許會失敗。
但方式二起碼可以少打 function 這一串英文字母，對懶人來說(如我)，又何樂不為呢？...  ^_^

function 在某一程度來說，也可稱為"函式"，但請不要與傳統編程所使用的函式(library)搞混了，畢竟兩者差異很大。
惟一相同的是，我們都可以隨時用"已定義的名稱"來調用它們...
若我們在 shell 操作中，需要不斷的重覆質行某些命令，我們首先想到的，或許是將命令寫成命令稿(shell script)。
不過，我們也可以寫成 function ，然後在 command line 中打上 function_name 就可當一舨的 script 來使用了。
只是若你在 shell 中定義的 function ，除了可用 unset function_name 取消外，一旦退出 shell ，function 也跟著取消。
然而，在 script 中使用 function 卻有許多好處，除了可以提高整體 script 的執行效能外(因為已被載入)，
還可以節省許多重覆的代碼...

簡單而言，若你會將多個命令寫成 script 以供調用的話，那，你可以將 function 看成是 script 中的 script ...  ^_^
而且，透過上一章介紹的 source 命令，我們可以自行定義許許多多好用的 function ，再集中寫在特定文件中，
然後，在其他的 script 中用 source 將它們載入並反覆執行。
若你是 RedHat Linux 的使用者，或許，已經猜得出 /etc/rc.d/init.d/functions 這個文件是作啥用的了~~~  ^_^

okay，說要輕鬆點的嘛，那這次就暫時寫到這吧。祝大家學習愉快﹗  ^_^

shell 十三問?

真是不错！！
够我咀嚼好几天的了。