玩轉Linux – shell 程式設計基礎

AlphaGooo發表於2016-06-05
Linux程式設計

簡述

使用 linux 就離不開 shell，那麼也就是說也離不開 shell 程式設計。很多時候伺服器都需要編寫一些計劃任務來定時執行的，所以掌握一些基本的 shell 程式設計基礎很有必要。

本文是我在網上收集的一些資料，主要目的是幫助自己更好的瞭解掌握 shell 程式設計的一些基礎知識。

什麼是Shell指令碼

示例看個例子吧：

#!/bin/sh
cd ~
mkdir shell_tut
cd shell_tut

for ((i=0; i<10; i++)); do
    touch test_$i.txt
done

示例解釋：

  • 第1行：指定指令碼直譯器，這裡是用/bin/sh做直譯器的

  • 第2行：切換到當前使用者的home目錄

  • 第3行：建立一個目錄shell_tut

  • 第4行：切換到shell_tut目錄

  • 第5行：迴圈條件，一共迴圈10次

  • 第6行：建立一個test_1…10.txt檔案

  • 第7行：迴圈體結束

cd, mkdir, touch 都是系統自帶的程式，一般在/bin或者/usr/bin目錄下。
for, do, done 是sh指令碼語言的關鍵字。

shell和shell指令碼的概念

shell是指一種應用程式，這個應用程式提供了一個介面，使用者通過這個介面訪問作業系統核心的服務。

Ken Thompson的sh是第一種Unix Shell，Windows Explorer是一個典型的圖形介面Shell。
shell指令碼（shell script），是一種為shell編寫的指令碼程式。

業界所說的shell通常都是指shell指令碼，但讀者朋友要知道，shell和shell script是兩個不同的概念。

由於習慣的原因，簡潔起見，本文出現的“shell程式設計”都是指shell指令碼程式設計，不是指開發shell自身（如Windows Explorer擴充套件開發）。

環境shell程式設計跟java、php程式設計一樣，只要有一個能編寫程式碼的文字編輯器和一個能解釋執行的指令碼直譯器就可以了。

OS當前主流的作業系統都支援shell程式設計，本文件所述的shell程式設計是指Linux下的shell，講的基本都是POSIX標準下的功能，所以，也適用於Unix及BSD（如Mac OS）。

LinuxLinux預設安裝就帶了shell直譯器。

Mac OSMac OS不僅帶了sh、bash這兩個最基礎的直譯器，還內建了ksh、csh、zsh等不常用的直譯器。

Windows上的模擬器windows出廠時沒有內建shell直譯器，需要自行安裝，為了同時能用grep, awk, curl等工具，最好裝一個cygwin或者mingw來模擬linux環境。

  • cygwin

  • mingw

指令碼直譯器 sh

即Bourne shell，POSIX（Portable Operating System Interface）標準的shell直譯器，它的二進位制檔案路徑通常是/bin/sh，由Bell Labs開發。

bashBash是Bourne shell的替代品，屬GNU Project，二進位制檔案路徑通常是/bin/bash。業界通常混用bash、sh、和shell，比如你會經常在招聘運維工程師的文案中見到：熟悉Linux Bash程式設計，精通Shell程式設計。

在CentOS裡，/bin/sh是一個指向/bin/bash的符號連結:

[root@centosraw ~]# ls -l /bin/*sh
-rwxr-xr-x. 1 root root 903272 Feb 22 05:09 /bin/bash
-rwxr-xr-x. 1 root root 106216 Oct 17  2012 /bin/dash
lrwxrwxrwx. 1 root root      4 Mar 22 10:22 /bin/sh -> bash

但在Mac OS上不是，/bin/sh和/bin/bash是兩個不同的檔案，儘管它們的大小隻相差100位元組左右:

iMac:~ wuxiao$ ls -l /bin/*sh
-r-xr-xr-x  1 root  wheel  1371648  6 Nov 16:52 /bin/bash
-rwxr-xr-x  2 root  wheel   772992  6 Nov 16:52 /bin/csh
-r-xr-xr-x  1 root  wheel  2180736  6 Nov 16:52 /bin/ksh
-r-xr-xr-x  1 root  wheel  1371712  6 Nov 16:52 /bin/sh
-rwxr-xr-x  2 root  wheel   772992  6 Nov 16:52 /bin/tcsh
-rwxr-xr-x  1 root  wheel  1103984  6 Nov 16:52 /bin/zsh

如何選擇shell程式語言

熟悉 vs 陌生如果你已經掌握了一門程式語言（如PHP、Python、Java、JavaScript），建議你就直接使用這門語言編寫指令碼程式，雖然某些地方會有點囉嗦，但你能利用在這門語言領域裡的經驗（單元測試、單步除錯、IDE、第三方類庫）。

新增的學習成本很小，只要學會怎麼使用shell直譯器（Jshell、AdaScript）就可以了。

簡單 vs 高階如果你覺得自己熟悉的語言（如Java、C）寫shell指令碼實在太囉嗦，你只是想做一些備份檔案、安裝軟體、下載資料之類的事情，學著使用sh，bash會是一個好主意。

shell只定義了一個非常簡單的程式語言，所以，如果你的指令碼程式複雜度較高，或者要操作的資料結構比較複雜，那麼還是應該使用Python、Perl這樣的指令碼語言，或者是你本來就已經很擅長的高階語言。

因為sh和bash在這方面很弱，比如說：

  • 它的函式只能返回字串，無法返回陣列

  • 它不支援物件導向，你無法實現一些優雅的設計模式

  • 它是解釋型的，一邊解釋一邊執行，連PHP那種預編譯都不是，如果你的指令碼包含錯誤(例如呼叫了不存在的函式)，只要沒執行到這一行，就不會報錯

環境相容性如果你的指令碼是提供給別的使用者使用，使用sh或者bash，你的指令碼將具有最好的環境相容性，perl很早就是linux標配了，python這些年也成了一些linux發行版的標配，至於mac os，它預設安裝了perl、python、ruby、php、java等主流程式語言。

第一個shell指令碼 編寫開啟文字編輯器，新建一個檔案，副檔名為sh（sh代表shell），副檔名並不影響指令碼執行，見名知意就好，如果你用php寫shell 指令碼，副檔名就用php好了。

輸入一些程式碼，第一行一般是這樣：

#!/bin/bash
#!/usr/bin/php

“#!”是一個約定的標記，它告訴系統這個指令碼需要什麼直譯器來執行。

執行

執行Shell指令碼有兩種方法：

1、作為可執行程式

將上面的程式碼儲存為test.sh，並cd到相應目錄：

chmod +x ./test.sh  #使指令碼具有執行許可權
./test.sh  #執行指令碼

注意：

  • 一定要寫成./test.sh，而不是test.sh，執行其它二進位制的程式也一樣。

  • 直接寫test.sh，linux 系統會去PATH裡尋找有沒有叫test.sh的，只有/bin, /sbin, /usr/bin，/usr/sbin等在PATH裡。

  • 你的當前目錄通常不在PATH裡，所以寫成test.sh是會找不到命令的，要用./test.sh告訴系統說，就在當前目錄找。

2、作為直譯器引數

這種執行方式是，直接執行直譯器，其引數就是shell指令碼的檔名，如：

/bin/sh test.sh
/bin/php test.php

這種方式執行的指令碼，不需要在第一行指定直譯器資訊，寫了也沒用。

變數

定義變數定義變數時，變數名不加美元符號（$），如：

your_name="qinjx"

注意，變數名和等號之間不能有空格，這可能和你熟悉的所有程式語言都不一樣：

  • 首個字母必須為字母（a-z,A-Z）。

  • 中間不能有空格，可以使用下劃線。

  • 不能使用表單符號。

  • 不能使用bash裡的關鍵字（如果不清楚，可以用help命令檢視bash的保留關鍵字）。

除了顯式地直接賦值，還可以用語句給變數賦值，如：

for file in `ls /etc`

  • 說明：上面的命令的意思是實現將 /etc 下目錄的檔名迴圈出來。

使用變數

使用一個定義過得變數，只要在變數名之前加上美元符號 $ 即可，比如：

your_name="qinjx"
echo $your_name
echo ${your_name}

變數名外面的花括號是可選的，可加可不加，加花括號是為了幫助直譯器識別變數的邊界，比如當遇到下面的情況時：

for skill in Ada Coffe Action Java; do
    echo "I am good at ${skill}Script"
done

如果不給skill變數加上花括號，變數寫成 $skillScript，那麼直譯器就識別不出$skill了，那麼程式碼的最終結果就跟我的預期相差甚遠。

推薦給所有變數加上花括號，這是shell程式設計的好習慣。

對於已定義的變數，可以被重新定義，比如：

your_name="tom"
echo $your_name
your_name="alibaba"
echo $your_name

注意第二次賦值的時候不能寫成：

$your_name="alibaba"

只有在使用變數的時候才加美元符 $。

只讀變數

使用 readonly 命令可以將變數定義為只讀變數，只讀變數的值不能被改變。

下面的例子嘗試更改只讀變數，結果報錯：

#!/bin/bash
myUrl="http://www.w3cschool.cc"
readonly myUrl
myUrl="http://www.runoob.com"

執行指令碼，結果如下：

/bin/sh: NAME: This variable is read only.

刪除變數

使用 unset 命令可以刪除變數。語法：

unset variable_name

變數被刪除後不能再次使用。unset 命令不能刪除只讀變數。

案例：

#!/bin/sh
myUrl="http://www.runoob.com"
unset myUrl
echo $myUrl

上面的程式執行將沒有任何輸出。

變數型別

執行 shell 程式時，會同時存在三種變數：

  1. 區域性變數： 區域性變數在指令碼或命令中定義，僅在當前shell例項中有效，其他shell啟動的程式不能訪問區域性變數。

  2. 環境變數： 所有的程式，包括shell啟動的程式，都能訪問環境變數，有些程式需要環境變數來保證其正常執行。必要的時候shell指令碼也可以定義環境變數。

  3. shell變數：shell變數是由shell程式設定的特殊變數。shell變數中有一部分是環境變數，有一部分是區域性變數，這些變數保證了shell的正常執行

字串

字串是 shell 程式設計中最常用最有用的資料型別（除了數字和字串，也沒啥其它型別好用了）。

字串可以用單引號，也可以用雙引號，也可以不用引號。單雙引號的區別跟PHP類似。

單引號

str=`this is a string`

單引號字串的限制：

  • 單引號裡的任何字元都會原樣輸出，單引號字串中的變數是無效的。

  • 單引號字串中不能出現單引號（對單引號使用轉義符後也不行）。

雙引號

your_name=`qinjx`
str="Hello, I know your are "$your_name"! 
"

雙引號的優點：

  • 雙引號裡可以有變數。

  • 雙引號裡可以出現轉義字元。

拼接字串

your_name="qinjx"
greeting="hello, "$your_name" !"
greeting_1="hello, ${your_name} !"
echo $greeting $greeting_1

獲取字串長度

string="abcd"
echo ${#string} #輸出 4

提取子字串

以下例項從字串第 2 個字元開始擷取 4 個字元：

string="runoob is a great site"
echo ${string:1:4} # 輸出 unoo

查詢子字串

查詢字元 “i 或 s” 的位置：

string="runoob is a great company"
echo `expr index "$string" is`  # 輸出 8

注意： 以上指令碼中 “`” 是反引號，而不是單引號 “`”，千萬不要看錯了。

陣列

Bash Shell 只支援一維陣列（不支援多維陣列），初始化時不需要定義陣列大小（與 PHP 類似）。

獲取陣列中的元素要利用下標，下標可以是整數或算術表示式，其值應大於或等於0。

陣列中可以存放多個值，與大部分程式語言類似，陣列元素的下標由0開始。

定義陣列

在Shell中，用括號來表示陣列，陣列元素用”空格”符號分割開。

定義陣列的一般形式為：

陣列名=(值1 值2 ... 值n)

例如：

array_name=(value0 value1 value2 value3)

或者

array_name=(
value0
value1
value2
value3
)

還可以單獨定義陣列的各個分量：

array_name[0]=value0
array_name[1]=value1
array_name[n]=valuen

可以不使用連續的下標，而且下標的範圍沒有限制。

讀取陣列

讀取陣列元素值的一般格式是：

${陣列名[下標]}

例如：

valuen=${array_name[n]}

shell 程式設計實戰：

#!/bin/bash

my_array=(A B "C" D)

echo "第一個元素為: ${my_array[0]}"
echo "第二個元素為: ${my_array[1]}"
echo "第三個元素為: ${my_array[2]}"
echo "第四個元素為: ${my_array[3]}"

執行指令碼，輸出結果如下所示：

$ chmod +x test.sh 
$ ./test.sh
第一個元素為: A
第二個元素為: B
第三個元素為: C
第四個元素為: D

使用 @ 或者 * 符號可以獲取陣列中的所有元素，例如：

echo ${array_name[@]}

shell 程式設計實戰：

#!/bin/bash

my_array[0]=A
my_array[1]=B
my_array[2]=C
my_array[3]=D

echo "陣列的元素為: ${my_array[*]}"
echo "陣列的元素為: ${my_array[@]}"

執行指令碼，輸出結果如下所示：

$ chmod +x test.sh 
$ ./test.sh
陣列的元素為: A B C D
陣列的元素為: A B C D

獲取陣列的長度

獲取陣列長度的方法與獲取字串長度的方法相同，例如：

# 取得陣列元素的個數
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得陣列單個元素的長度
lengthn=${#array_name[n]}

shell 實戰程式設計：

#!/bin/bash

my_array[0]=A
my_array[1]=B
my_array[2]=C
my_array[3]=D

echo "陣列元素個數為: ${#my_array[*]}"
echo "陣列元素個數為: ${#my_array[@]}"

執行指令碼，輸出結果如下所示：

$ chmod +x test.sh 
$ ./test.sh
陣列元素個數為: 4
陣列元素個數為: 4

註釋

以”#”開頭的行就是註釋，會被直譯器忽略。

sh裡沒有多行註釋，只能每一行加一個#號。只能像這樣：

#--------------------------------------------
# 這是一個註釋
#--------------------------------------------
##### 使用者配置區 開始 #####
#
#
# 這裡可以新增指令碼描述資訊
# 
#
##### 使用者配置區 結束  #####

如果在開發過程中，遇到大段的程式碼需要臨時註釋起來，過一會兒又取消註釋，怎麼辦呢？

每一行加個#符號太費力了，可以把這一段要註釋的程式碼用一對花括號括起來，定義成一個函式，沒有地方呼叫這個函式，這塊程式碼就不會執行，達到了和註釋一樣的效果。

傳遞引數

我們可以在執行 Shell 指令碼時，向指令碼傳遞引數，指令碼內獲取引數的格式為：$n。

n 代表一個數字，1 為執行指令碼的第一個引數，2 為執行指令碼的第二個引數，以此類推……

例項
以下例項我們向指令碼傳遞三個引數，並分別輸出，其中 $0 為執行的檔名：

#!/bin/bash

echo "Shell 傳遞引數例項！";
echo "執行的檔名：$0";
echo "第一個引數為：$1";
echo "第二個引數為：$2";
echo "第三個引數為：$3";

為指令碼設定可執行許可權，並執行指令碼，輸出結果如下所示：

$ chmod +x test.sh 
$ ./test.sh 1 2 3
Shell 傳遞引數例項！
執行的檔名：test.sh
第一個引數為：1
第二個引數為：2
第三個引數為：3

另外，還有幾個特殊字元用來處理引數：

引數處理    說明
$#    傳遞到指令碼的引數個數
$*    以一個單字串顯示所有向指令碼傳遞的引數。
如"$*"用「"」括起來的情況、以"$1 $2 … $n"的形式輸出所有引數。
$$    指令碼執行的當前程式ID號
$!    後臺執行的最後一個程式的ID號
$@    與$*相同，但是使用時加引號，並在引號中返回每個引數。
如"$@"用「"」括起來的情況、以"$1" "$2" … "$n" 的形式輸出所有引數。
$-    顯示Shell使用的當前選項，與set命令功能相同。
$?    顯示最後命令的退出狀態。0表示沒有錯誤，其他任何值表明有錯誤。
#!/bin/bash

echo "Shell 傳遞引數例項！";
echo "第一個引數為：$1";

echo "引數個數為：$#";
echo "傳遞的引數作為一個字串顯示：$*";

執行指令碼，輸出結果如下所示：

$ chmod +x test.sh 
$ ./test.sh 1 2 3
Shell 傳遞引數例項！
第一個引數為：1
引數個數為：3
傳遞的引數作為一個字串顯示：1 2 3

$* 與 $@ 區別：

  • 相同點：都是引用所有引數。

  • 不同點：只有在雙引號中體現出來。

假設在指令碼執行時寫了三個引數 1、2、3，，則 " * " 等價於 "1 2 3"（傳遞了一個引數），而 "@" 等價於 "1" "2" "3"（傳遞了三個引數）。
#!/bin/bash

echo "-- $* 演示 ---"
for i in "$*"; do
    echo $i
done

echo "-- $@ 演示 ---"
for i in "$@"; do
    echo $i
done

執行指令碼，輸出結果如下所示：

$ chmod +x test.sh 
$ ./test.sh 1 2 3
-- $* 演示 ---
1 2 3
-- $@ 演示 ---
1
2
3

基本運算子

Shell 和其他程式語言一樣，支援多種運算子，包括：

  • 算數運算子

  • 關係運算子

  • 布林運算子

  • 字串運算子

  • 檔案測試運算子

原生bash不支援簡單的數學運算，但是可以通過其他命令來實現，例如 awk 和 expr，expr 最常用。

expr 是一款表示式計算工具，使用它能完成表示式的求值操作。

例如，兩個數相加(特別注意：使用的是反引號 ` 而不是單引號 `)：

#!/bin/bash

val=`expr 2 + 2`
echo "兩數之和為 : $val"

執行指令碼，輸出結果如下所示：

兩數之和為 : 4

兩點注意：

  • 表示式和運算子之間要有空格，例如 2+2 是不對的，必須寫成 2 + 2，這與我們熟悉的大多數程式語言不一樣。

  • 完整的表示式要被 包含，注意這個字元不是常用的單引號，在 Esc 鍵下邊。

算術運算子

下面列出了常用的算術運算子，假定變數 a 為 10，變數 b 為 20：

運算子    說明    舉例
 + 加法    `expr $a + $b` 結果為 30。
 + 減法    `expr $a - $b` 結果為 10。
 + 乘法    `expr $a * $b` 結果為  200。
/    除法    `expr $b / $a` 結果為 2。
%    取餘    `expr $b % $a` 結果為 0。
=    賦值    a=$b 將把變數 b 的值賦給 a。
==    相等。用於比較兩個數字，相同則返回 true。    [ $a == $b ] 返回 false。
!=    不相等。用於比較兩個數字，不相同則返回 true。    [ $a != $b ] 返回 true。

  • 注意：條件表示式要放在方括號之間，並且要有空格，例如: [$a==$b] 是錯誤的，必須寫成 [ $a == $b ]。

示例

算術運算子例項如下：

#!/bin/bash

a=10
b=20

val=`expr $a + $b`
echo "a + b : $val"

val=`expr $a - $b`
echo "a - b : $val"

val=`expr $a * $b`
echo "a * b : $val"

val=`expr $b / $a`
echo "b / a : $val"

val=`expr $b % $a`
echo "b % a : $val"

if [ $a == $b ]
then
   echo "a 等於 b"
fi
if [ $a != $b ]
then
   echo "a 不等於 b"
fi

執行指令碼，輸出結果如下所示：

a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a 不等於 b

注意：

  • 乘號(*)前邊必須加反斜槓()才能實現乘法運算。

  • if…then…fi 是條件語句，後續會有說明。

關係運算子

關係運算子只支援數字，不支援字串，除非字串的值是數字。

下面列出了常用的關係運算子，假定變數 a 為 10，變數 b 為 20：

運算子    說明    舉例
-eq    檢測兩個數是否相等，相等返回 true。    [ $a -eq $b ] 返回 false。
-ne    檢測兩個數是否相等，不相等返回 true。    [ $a -ne $b ] 返回 true。
-gt    檢測左邊的數是否大於右邊的，如果是，則返回 true。    [ $a -gt $b ] 返回 false。
-lt    檢測左邊的數是否小於右邊的，如果是，則返回 true。    [ $a -lt $b ] 返回 true。
-ge    檢測左邊的數是否大等於右邊的，如果是，則返回 true。    [ $a -ge $b ] 返回 false。
-le    檢測左邊的數是否小於等於右邊的，如果是，則返回 true。    [ $a -le $b ] 返回 true。

例項

關係運算子例項如下：

#!/bin/bash

a=10
b=20

if [ $a -eq $b ]
then
   echo "$a -eq $b : a 等於 b"
else
   echo "$a -eq $b: a 不等於 b"
fi
if [ $a -ne $b ]
then
   echo "$a -ne $b: a 不等於 b"
else
   echo "$a -ne $b : a 等於 b"
fi
if [ $a -gt $b ]
then
   echo "$a -gt $b: a 大於 b"
else
   echo "$a -gt $b: a 不大於 b"
fi
if [ $a -lt $b ]
then
   echo "$a -lt $b: a 小於 b"
else
   echo "$a -lt $b: a 不小於 b"
fi
if [ $a -ge $b ]
then
   echo "$a -ge $b: a 大於或等於 b"
else
   echo "$a -ge $b: a 小於 b"
fi
if [ $a -le $b ]
then
   echo "$a -le $b: a 小於或等於 b"
else
   echo "$a -le $b: a 大於 b"
fi

執行指令碼，輸出結果如下所示：

10 -eq 20: a 不等於 b
10 -ne 20: a 不等於 b
10 -gt 20: a 不大於 b
10 -lt 20: a 小於 b
10 -ge 20: a 小於 b
10 -le 20: a 小於或等於 b

布林運算子

下面列出了常用的布林運算子，假定變數 a 為 10，變數 b 為 20：

運算子    說明    舉例
!    非運算，表示式為 true 則返回 false，否則返回 true。    [ ! false ] 返回 true。
-o    或運算，有一個表示式為 true 則返回 true。    [ $a -lt 20 -o $b -gt 100 ] 返回 true。
-a    與運算，兩個表示式都為 true 才返回 true。    [ $a -lt 20 -a $b -gt 100 ] 返回 false。

例項

布林運算子例項如下：

#!/bin/bash

a=10
b=20

if [ $a != $b ]
then
   echo "$a != $b : a 不等於 b"
else
   echo "$a != $b: a 等於 b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
   echo "$a -lt 100 -a $b -gt 15 : 返回 true"
else
   echo "$a -lt 100 -a $b -gt 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
   echo "$a -lt 100 -o $b -gt 100 : 返回 true"
else
   echo "$a -lt 100 -o $b -gt 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
   echo "$a -lt 100 -o $b -gt 100 : 返回 true"
else
   echo "$a -lt 100 -o $b -gt 100 : 返回 false"
fi

執行指令碼，輸出結果如下所示：

10 != 20 : a 不等於 b
10 -lt 100 -a 20 -gt 15 : 返回 true
10 -lt 100 -o 20 -gt 100 : 返回 true
10 -lt 100 -o 20 -gt 100 : 返回 false

邏輯運算子

以下介紹 Shell 的邏輯運算子，假定變數 a 為 10，變數 b 為 20:

運算子    說明    舉例
&&    邏輯的 AND    [[ $a -lt 100 && $b -gt 100 ]] 返回 false
||    邏輯的 OR    [[ $a -lt 100 || $b -gt 100 ]] 返回 true

例項

邏輯運算子例項如下：

#!/bin/bash

a=10
b=20

if [[ $a -lt 100 && $b -gt 100 ]]
then
   echo "返回 true"
else
   echo "返回 false"
fi

if [[ $a -lt 100 || $b -gt 100 ]]
then
   echo "返回 true"
else
   echo "返回 false"
fi

執行指令碼，輸出結果如下所示：

返回 false
返回 true

字串運算子

下面列出了常用的字串運算子，假定變數 a 為 “abc”，變數 b 為 “efg”：

運算子    說明    舉例
=    檢測兩個字串是否相等，相等返回 true。    [ $a = $b ] 返回 false。
!=    檢測兩個字串是否相等，不相等返回 true。    [ $a != $b ] 返回 true。
-z    檢測字串長度是否為0，為0返回 true。    [ -z $a ] 返回 false。
-n    檢測字串長度是否為0，不為0返回 true。    [ -n $a ] 返回 true。
str    檢測字串是否為空，不為空返回 true。    [ $a ] 返回 true。

例項

#!/bin/bash

a="abc"
b="efg"

if [ $a = $b ]
then
   echo "$a = $b : a 等於 b"
else
   echo "$a = $b: a 不等於 b"
fi
if [ $a != $b ]
then
   echo "$a != $b : a 不等於 b"
else
   echo "$a != $b: a 等於 b"
fi
if [ -z $a ]
then
   echo "-z $a : 字串長度為 0"
else
   echo "-z $a : 字串長度不為 0"
fi
if [ -n $a ]
then
   echo "-n $a : 字串長度不為 0"
else
   echo "-n $a : 字串長度為 0"
fi
if [ $a ]
then
   echo "$a : 字串不為空"
else
   echo "$a : 字串為空"
fi

執行指令碼，輸出結果如下所示：

abc = efg: a 不等於 b
abc != efg : a 不等於 b
-z abc : 字串長度不為 0
-n abc : 字串長度不為 0
abc : 字串不為空

檔案測試運算子

檔案測試運算子用於檢測 Unix 檔案的各種屬性。

屬性檢測描述如下：

操作符    說明    舉例
-b file    檢測檔案是否是塊裝置檔案，如果是，則返回 true。    [ -b $file ] 返回 false。
-c file    檢測檔案是否是字元裝置檔案，如果是，則返回 true。    [ -c $file ] 返回 false。
-d file    檢測檔案是否是目錄，如果是，則返回 true。    [ -d $file ] 返回 false。
-f file    檢測檔案是否是普通檔案（既不是目錄，也不是裝置檔案），如果是，則返回 true。    [ -f $file ] 返回 true。
-g file    檢測檔案是否設定了 SGID 位，如果是，則返回 true。    [ -g $file ] 返回 false。
-k file    檢測檔案是否設定了粘著位(Sticky Bit)，如果是，則返回 true。    [ -k $file ] 返回 false。
-p file    檢測檔案是否是具名管道，如果是，則返回 true。    [ -p $file ] 返回 false。
-u file    檢測檔案是否設定了 SUID 位，如果是，則返回 true。    [ -u $file ] 返回 false。
-r file    檢測檔案是否可讀，如果是，則返回 true。    [ -r $file ] 返回 true。
-w file    檢測檔案是否可寫，如果是，則返回 true。    [ -w $file ] 返回 true。
-x file    檢測檔案是否可執行，如果是，則返回 true。    [ -x $file ] 返回 true。
-s file    檢測檔案是否為空（檔案大小是否大於0），不為空返回 true。    [ -s $file ] 返回 true。
-e file    檢測檔案（包括目錄）是否存在，如果是，則返回 true。    [ -e $file ] 返回 true。

例項

變數 file 表示檔案”/var/www/runoob/test.sh”，它的大小為100位元組，具有 rwx 許可權。下面的程式碼，將檢測該檔案的各種屬性：

#!/bin/bash

file="/var/www/runoob/test.sh"
if [ -r $file ]
then
   echo "檔案可讀"
else
   echo "檔案不可讀"
fi
if [ -w $file ]
then
   echo "檔案可寫"
else
   echo "檔案不可寫"
fi
if [ -x $file ]
then
   echo "檔案可執行"
else
   echo "檔案不可執行"
fi
if [ -f $file ]
then
   echo "檔案為普通檔案"
else
   echo "檔案為特殊檔案"
fi
if [ -d $file ]
then
   echo "檔案是個目錄"
else
   echo "檔案不是個目錄"
fi
if [ -s $file ]
then
   echo "檔案不為空"
else
   echo "檔案為空"
fi
if [ -e $file ]
then
   echo "檔案存在"
else
   echo "檔案不存在"
fi

執行指令碼，輸出結果如下所示：

檔案可讀
檔案可寫
檔案可執行
檔案為普通檔案
檔案不是個目錄
檔案不為空
檔案存在

echo命令

Shell 的 echo 指令與 PHP 的 echo 指令類似，都是用於字串的輸出。

命令格式：

echo string

您可以使用echo實現更復雜的輸出格式控制。

1.顯示普通字串:

echo "It is a test"

這裡的雙引號完全可以省略，以下命令與上面例項效果一致：

echo It is a test

2.顯示轉義字元

echo ""It is a test""

結果將是:

"It is a test"

同樣，雙引號也可以省略

3.顯示變數

read 命令從標準輸入中讀取一行,並把輸入行的每個欄位的值指定給 shell 變數:

#!/bin/sh
read name 
echo "$name It is a test"

以上程式碼儲存為 test.sh，name 接收標準輸入的變數，結果將是:

[root@www ~]# sh test.sh
OK                     #標準輸入
OK It is a test        #輸出

4.顯示換行

echo -e "OK! 
" # -e 開啟轉義
echo "It it a test"

輸出結果：

OK!

It it a test

5.顯示不換行

#!/bin/sh
echo -e "OK! c" # -e 開啟轉義 c 不換行
echo "It is a test"

輸出結果：

OK! It is a test

6.顯示結果定向至檔案

echo "It is a test" > myfile

7.原樣輸出字串，不進行轉義或取變數(用單引號)

echo `$name"`

輸出結果：

$name"

8.顯示命令執行結果

  echo `date`

結果將顯示當前日期

Thu Jul 24 10:08:46 CST 2014

printf 命令

printf 命令模仿 C 程式庫（library）裡的 printf() 程式。

標準所定義，因此使用printf的指令碼比使用echo移植性好。

printf 使用引用文字或空格分隔的引數，外面可以在printf中使用格式化字串，還可以制定字串的寬度、左右對齊方式等。

預設printf不會像 echo 自動新增換行符，我們可以手動新增 n。

printf 命令的語法：

printf  format-string  [arguments...]

引數說明：

  • format-string: 為格式控制字串

  • arguments: 為引數列表。

例項1

$ echo "Hello, Shell"
Hello, Shell
$ printf "Hello, Shell
"
Hello, Shell
$

接下來,我來用一個指令碼來體現printf的強大功能：

#!/bin/bash
 
printf "%-10s %-8s %-4s
" 姓名 性別 體重kg  
printf "%-10s %-8s %-4.2f
" 郭靖 男 66.1234 
printf "%-10s %-8s %-4.2f
" 楊過 男 48.6543 
printf "%-10s %-8s %-4.2f
" 郭芙 女 47.9876

執行指令碼，輸出結果如下所示：

姓名     性別   體重kg
郭靖     男      66.12
楊過     男      48.65
郭芙     女      47.99

%s %c %d %f都是格式替代符。
%-10s 指一個寬度為10個字元（-表示左對齊，沒有則表示右對齊），任何字元都會被顯示在10個字元寬的字元內，如果不足則自動以空格填充，超過也會將內容全部顯示出來。
%-4.2f 指格式化為小數，其中.2指保留2位小數。

例項2

#!/bin/bash
 
# format-string為雙引號
printf "%d %s
" 1 "abc"

# 單引號與雙引號效果一樣 
printf `%d %s
` 1 "abc" 

# 沒有引號也可以輸出
printf %s abcdef

# 格式只指定了一個引數，但多出的引數仍然會按照該格式輸出，format-string 被重用
printf %s abc def

printf "%s
" abc def

printf "%s %s %s
" a b c d e f g h i j

# 如果沒有 arguments，那麼 %s 用NULL代替，%d 用 0 代替
printf "%s and %d 
"

執行指令碼，輸出結果如下所示：

1 abc
1 abc
abcdefabcdefabc
def
a b c
d e f
g h i
j  
 and 0

printf 的轉義序列

序列    說明
a    警告字元，通常為ASCII的BEL字元
    後退
c    抑制（不顯示）輸出結果中任何結尾的換行字元（只在%b格式指示符控制下的引數字串中有效），而且，任何留在引數裡的字元、任何接下來的引數以及任何留在格式字串中的字元，都被忽略
f    換頁（formfeed）

    換行

    回車（Carriage return）
	    水平製表符
v    垂直製表符
\    一個字面上的反斜槓字元
ddd    表示1到3位數八進位制值的字元。僅在格式字串中有效
 ddd    表示1到3位的八進位制值字元

例項

$ printf "a string, no processing:<%s>
" "A
B"
a string, no processing:<A
B>

$ printf "a string, no processing:<%b>
" "A
B"
a string, no processing:<A
B>

$ printf "www.runoob.com a"
www.runoob.com $                  #不換行

test 命令

Shell中的 test 命令用於檢查某個條件是否成立，它可以進行數值、字元和檔案三個方面的測試。

數值測試

引數    說明
-eq    等於則為真
-ne    不等於則為真
-gt    大於則為真
-ge    大於等於則為真
-lt    小於則為真
-le    小於等於則為真

例項

num1=100
num2=100
if test $[num1] -eq $[num2]
then
    echo `兩個數相等！`
else
    echo `兩個數不相等！`
fi

輸出結果：

兩個數相等！

字串測試

引數    說明
=    等於則為真
!=    不相等則為真
-z 字串    字串的長度為零則為真
-n 字串    字串的長度不為零則為真

例項

num1="runoob"
num2="runoob"
if test num1=num2
then
    echo `兩個字串相等!`
else
    echo `兩個字串不相等!`
fi

輸出結果：

兩個字串相等！

檔案測試

引數    說明
-e 檔名    如果檔案存在則為真
-r 檔名    如果檔案存在且可讀則為真
-w 檔名    如果檔案存在且可寫則為真
-x 檔名    如果檔案存在且可執行則為真
-s 檔名    如果檔案存在且至少有一個字元則為真
-d 檔名    如果檔案存在且為目錄則為真
-f 檔名    如果檔案存在且為普通檔案則為真
-c 檔名    如果檔案存在且為字元型特殊檔案則為真
-b 檔名    如果檔案存在且為塊特殊檔案則為真

例項

cd /bin
if test -e ./bash
then
    echo `檔案已存在!`
else
    echo `檔案不存在!`
fi

輸出結果：

檔案已存在!
另外，Shell還提供了與( -a )、或( -o )、非( ! )三個邏輯操作符用於將測試條件連線起來，其優先順序為："!"最高，"-a"次之，"-o"最低。

例如：

cd /bin
if test -e ./notFile -o -e ./bash
then
    echo `有一個檔案存在!`
else
    echo `兩個檔案都不存在`
fi

輸出結果：

有一個檔案存在!

流程控制

和Java、PHP等語言不一樣，sh的流程控制不可為空，如(以下為PHP流程控制寫法)：

<?php
if (isset($_GET["q"])) {
    search(q);
}
else {
    // 不做任何事情
}

在sh/bash裡可不能這麼寫，如果else分支沒有語句執行，就不要寫這個else。

if else

if

if 語句語法格式：

if condition
then
    command1 
    command2
    ...
    commandN 
fi

寫成一行（適用於終端命令提示符）：

if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi

末尾的fi就是if倒過來拼寫，後面還會遇到類似的。

if else

if else 語法格式：

if condition
then
    command1 
    command2
    ...
    commandN
else
    command
fi

if else-if else

if else-if else 語法格式：

if condition1
then
    command1
elif condition2 
then 
    command2
else
    commandN
fi

以下例項判斷兩個變數是否相等：

a=10
b=20
if [ $a == $b ]
then
   echo "a 等於 b"
elif [ $a -gt $b ]
then
   echo "a 大於 b"
elif [ $a -lt $b ]
then
   echo "a 小於 b"
else
   echo "沒有符合的條件"
fi

輸出結果：

a 小於 b

if else語句經常與test命令結合使用，如下所示：

num1=$[2*3]
num2=$[1+5]
if test $[num1] -eq $[num2]
then
    echo `兩個數字相等!`
else
    echo `兩個數字不相等!`
fi

輸出結果：

兩個數字相等!

for 迴圈

與其他程式語言類似，Shell支援for迴圈。

for迴圈一般格式為：

for var in item1 item2 ... itemN
do
    command1
    command2
    ...
    commandN
done

寫成一行：

for var in item1 item2 ... itemN; do command1; command2… done;

當變數值在列表裡，for迴圈即執行一次所有命令，使用變數名獲取列表中的當前取值。

命令可為任何有效的shell命令和語句。

in列表可以包含替換、字串和檔名。

in列表是可選的，如果不用它，for迴圈使用命令列的位置引數。

例如，順序輸出當前列表中的數字：

for loop in 1 2 3 4 5
do
    echo "The value is: $loop"
done

輸出結果：

The value is: 1
The value is: 2
The value is: 3
The value is: 4
The value is: 5

順序輸出字串中的字元：

for str in `This is a string`
do
    echo $str
done

輸出結果：

This is a string

while 語句

while迴圈用於不斷執行一系列命令，也用於從輸入檔案中讀取資料，命令通常為測試條件。

其格式為：

while condition
do
    command
done

以下是一個基本的while迴圈，測試條件是：如果int小於等於5，那麼條件返回真。

int從0開始，每次迴圈處理時，int加1。

執行上述指令碼，返回數字1到5，然後終止。

#!/bin/sh
int=1
while(( $int<=5 ))
do
        echo $int
        let "int++"
done

執行指令碼，輸出：

1
2
3
4
5

指令碼中使用了 let 命令，它用於執行一個或多個表示式，變數計算中不需要加上 $ 來表示變數。

while迴圈可用於讀取鍵盤資訊。

下面的例子中，輸入資訊被設定為變數FILM，按<Ctrl-D>結束迴圈。

echo `按下 <CTRL-D> 退出`
echo -n `輸入你最喜歡的電影名: `
while read FILM
do
    echo "是的！$FILM 是一部好電影"
done

執行指令碼，輸出類似下面：

按下 <CTRL-D> 退出
輸入你最喜歡的電影名: w3cschool菜鳥教程
是的！w3cschool菜鳥教程 是一部好電影

無限迴圈

無限迴圈語法格式：

while :
do
    command
done

或者

while true
do
    command
done

或者

for (( ; ; ))

until 迴圈

until迴圈執行一系列命令直至條件為真時停止。

until迴圈與while迴圈在處理方式上剛好相反。

一般while迴圈優於until迴圈，但在某些時候—也只是極少數情況下，until迴圈更加有用。

until 語法格式:

until condition
do
    command
done

條件可為任意測試條件，測試發生在迴圈末尾，因此迴圈至少執行一次—請注意這一點。

case

Shell case語句為多選擇語句。

可以用case語句匹配一個值與一個模式，如果匹配成功，執行相匹配的命令。

case語句格式如下：

case 值 in
模式1)
    command1
    command2
    ...
    commandN
    ;;
模式2）
    command1
    command2
    ...
    commandN
    ;;
esac

case工作方式如上所示。

取值後面必須為單詞in，每一模式必須以右括號結束。

取值可以為變數或常數。

匹配發現取值符合某一模式後，其間所有命令開始執行直至 ;;。

取值將檢測匹配的每一個模式。

一旦模式匹配，則執行完匹配模式相應命令後不再繼續其他模式。

如果無一匹配模式，使用星號 * 捕獲該值，再執行後面的命令。

下面的指令碼提示輸入1到4，與每一種模式進行匹配：

echo `輸入 1 到 4 之間的數字:`
echo `你輸入的數字為:`
read aNum
case $aNum in
    1)  echo `你選擇了 1`
    ;;
    2)  echo `你選擇了 2`
    ;;
    3)  echo `你選擇了 3`
    ;;
    4)  echo `你選擇了 4`
    ;;
    *)  echo `你沒有輸入 1 到 4 之間的數字`
    ;;
esac

輸入不同的內容，會有不同的結果，例如：

輸入 1 到 4 之間的數字:
你輸入的數字為:
3
你選擇了 3

esac

case的語法和C family語言差別很大，它需要一個esac（就是case反過來）作為結束標記，每個case分支用右圓括號，用兩個分號表示break。

跳出迴圈

在迴圈過程中，有時候需要在未達到迴圈結束條件時強制跳出迴圈，Shell使用兩個命令來實現該功能：break和continue。

break命令

break命令允許跳出所有迴圈（終止執行後面的所有迴圈）。

下面的例子中，指令碼進入死迴圈直至使用者輸入數字大於5。

要跳出這個迴圈，返回到shell提示符下，需要使用break命令。

#!/bin/bash
while :
do
    echo -n "輸入 1 到 5 之間的數字:"
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你輸入的數字為 $aNum!"
        ;;
        *) echo "你輸入的數字不是 1 到 5 之間的! 遊戲結束"
            break
        ;;
    esac
done

執行以上程式碼，輸出結果為：

輸入 1 到 5 之間的數字:3
你輸入的數字為 3!
輸入 1 到 5 之間的數字:7
你輸入的數字不是 1 到 5 之間的! 遊戲結束

continue

continue命令與break命令類似，只有一點差別，它不會跳出所有迴圈，僅僅跳出當前迴圈。

對上面的例子進行修改：

#!/bin/bash
while :
do
    echo -n "輸入 1 到 5 之間的數字: "
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你輸入的數字為 $aNum!"
        ;;
        *) echo "你輸入的數字不是 1 到 5 之間的!"
            continue
            echo "遊戲結束"
        ;;
    esac
done

執行程式碼發現，當輸入大於5的數字時，該例中的迴圈不會結束，語句 echo “Game is over!” 永遠不會被執行。

函式

linux shell 可以使用者定義函式，然後在shell指令碼中可以隨便呼叫。

shell中函式的定義格式如下：

[ function ] funname [()]

{

    action;

    [return int;]

}

說明：

  1. 可以帶function fun() 定義，也可以直接fun() 定義,不帶任何引數。

  2. 引數返回，可以顯示加：return 返回，如果不加，將以最後一條命令執行結果，作為返回值。 return後跟數值n(0-255

下面的例子定義了一個函式並進行呼叫：

#!/bin/bash

demoFun(){
    echo "這是我的第一個 shell 函式!"
}
echo "-----函式開始執行-----"
demoFun
echo "-----函式執行完畢-----"

輸出結果：

-----函式開始執行-----
這是我的第一個 shell 函式!
-----函式執行完畢-----

下面定義一個帶有return語句的函式：

#!/bin/bash

funWithReturn(){
    echo "這個函式會對輸入的兩個數字進行相加運算..."
    echo "輸入第一個數字: "
    read aNum
    echo "輸入第二個數字: "
    read anotherNum
    echo "兩個數字分別為 $aNum 和 $anotherNum !"
    return $(($aNum+$anotherNum))
}
funWithReturn
echo "輸入的兩個數字之和為 $? !"

輸出類似下面：

這個函式會對輸入的兩個數字進行相加運算...
輸入第一個數字: 
1
輸入第二個數字: 
2
兩個數字分別為 1 和 2 !
輸入的兩個數字之和為 3 !

函式返回值在呼叫該函式後通過 $? 來獲得。

注意：

  • 所有函式在使用前必須定義。

  • 這意味著必須將函式放在指令碼開始部分，直至shell直譯器首次發現它時，才可以使用。

  • 呼叫函式僅使用其函式名即可。

函式引數

在Shell中，呼叫函式時可以向其傳遞引數。

在函式體內部，通過 $n 的形式來獲取引數的值，例如，$1表示第一個引數，$2表示第二個引數…

帶引數的函式示例：

#!/bin/bash

funWithParam(){
    echo "第一個引數為 $1 !"
    echo "第二個引數為 $2 !"
    echo "第十個引數為 $10 !"
    echo "第十個引數為 ${10} !"
    echo "第十一個引數為 ${11} !"
    echo "引數總數有 $# 個!"
    echo "作為一個字串輸出所有引數 $* !"
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73

輸出結果：

第一個引數為 1 !
第二個引數為 2 !
第十個引數為 10 !
第十個引數為 34 !
第十一個引數為 73 !
引數總數有 11 個!
作為一個字串輸出所有引數 1 2 3 4 5 6 7 8 9 34 73 !

注意，$10 不能獲取第十個引數，獲取第十個引數需要${10}。當n>=10時，需要使用${n}來獲取引數。

另外，還有幾個特殊字元用來處理引數：

引數處理    說明
$#    傳遞到指令碼的引數個數
$*    以一個單字串顯示所有向指令碼傳遞的引數
$$    指令碼執行的當前程式ID號
$!    後臺執行的最後一個程式的ID號
$@    與$*相同，但是使用時加引號，並在引號中返回每個引數。
$-    顯示Shell使用的當前選項，與set命令功能相同。
$?    顯示最後命令的退出狀態。0表示沒有錯誤，其他任何值表明有錯誤。

輸入/輸出重定向

大多數 UNIX 系統命令從你的終端接受輸入並將所產生的輸出傳送回​​到您的終端。

一個命令通常從一個叫標準輸入的地方讀取輸入，預設情況下，這恰好是你的終端。

同樣，一個命令通常將其輸出寫入到標準輸出，預設情況下，這也是你的終端。

重定向命令如下：

命令    說明
command > file    將輸出重定向到 file。
command < file    將輸入重定向到 file。
command >> file    將輸出以追加的方式重定向到 file。
n > file    將檔案描述符為 n 的檔案重定向到 file。
n >> file    將檔案描述符為 n 的檔案以追加的方式重定向到 file。
n >& m    將輸出檔案 m 和 n 合併。
n <& m    將輸入檔案 m 和 n 合併。
<< tag    將開始標記 tag 和結束標記 tag 之間的內容作為輸入。
需要注意的是檔案描述符 0 通常是標準輸入（STDIN），1 是標準輸出（STDOUT），2 是標準錯誤輸出（STDERR）。

輸出重定向

重定向一般通過在命令間插入特定的符號來實現。特別的，這些符號的語法如下所示:

command1 > file1

上面這個命令執行command1然後將輸出的內容存入file1。

注意：任何file1內的已經存在的內容將被新內容替代。如果要將新內容新增在檔案末尾，請使用>>操作符。

例項

執行下面的 who 命令，它將命令的完整的輸出重定向在使用者檔案中(users):

$ who > users

執行後，並沒有在終端輸出資訊，這是因為輸出已被從預設的標準輸出裝置（終端）重定向到指定的檔案。

你可以使用 cat 命令檢視檔案內容：

$ cat users
_mbsetupuser console  Oct 31 17:35 
tianqixin    console  Oct 31 17:35 
tianqixin    ttys000  Dec  1 11:33

輸出重定向會覆蓋檔案內容，請看下面的例子：

$ echo "測試測試：www.runoob.com" > users
$ cat users
測試測試：www.runoob.com
$

如果不希望檔案內容被覆蓋，可以使用 >> 追加到檔案末尾，例如：

$ echo "測試測試：www.runoob.com" >> users
$ cat users
測試測試：www.runoob.com
測試測試：www.runoob.com
$

輸入重定向

和輸出重定向一樣，Unix 命令也可以從檔案獲取輸入，語法為：

command1 < file1

這樣，本來需要從鍵盤獲取輸入的命令會轉移到檔案讀取內容。

注意：輸出重定向是大於號(>)，輸入重定向是小於號(<)。

例項

接著以上例項，我們需要統計 users 檔案的行數,執行以下命令：

$ wc -l users
       2 users

也可以將輸入重定向到 users 檔案：

$  wc -l < users
       2

注意：上面兩個例子的結果不同：

  • 第一個例子，會輸出檔名。

  • 第二個不會，因為它僅僅知道從標準輸入讀取內容。

    command1 < infile > outfile

同時替換輸入和輸出，執行command1，從檔案infile讀取內容，然後將輸出寫入到outfile中。

重定向深入理解

一般情況下，每個 Unix/Linux 命令執行時都會開啟三個檔案：

  • 標準輸入檔案(stdin)：stdin的檔案描述符為0，Unix程式預設從stdin讀取資料。

  • 標準輸出檔案(stdout)：stdout 的檔案描述符為1，Unix程式預設向stdout輸出資料。

  • 標準錯誤檔案(stderr)：stderr的檔案描述符為2，Unix程式會向stderr流中寫入錯誤資訊。

預設情況下，command > file 將 stdout 重定向到 file，command < file 將stdin 重定向到 file。

如果希望 stderr 重定向到 file，可以這樣寫：

$ command 2 > file

如果希望 stderr 追加到 file 檔案末尾，可以這樣寫：

$ command 2 >> file

2 表示標準錯誤檔案(stderr)。

如果希望將 stdout 和 stderr 合併後重定向到 file，可以這樣寫：

$ command > file 2>&1

或者

$ command >> file 2>&1

如果希望對 stdin 和 stdout 都重定向，可以這樣寫：

$ command < file1 >file2

command 命令將 stdin 重定向到 file1，將 stdout 重定向到 file2。

Here Document

Here Document 是 Shell 中的一種特殊的重定向方式，用來將輸入重定向到一個互動式 Shell 指令碼或程式。

它的基本的形式如下：

command << delimiter
    document
delimiter

它的作用是將兩個 delimiter 之間的內容(document) 作為輸入傳遞給 command。

注意：

  • 結尾的delimiter 一定要頂格寫，前面不能有任何字元，後面也不能有任何字元，包括空格和 tab 縮排。

  • 開始的delimiter前後的空格會被忽略掉。

例項

在命令列中通過 wc -l 命令計算 Here Document 的行數：

$ wc -l << EOF
    測試
    測試測試
    www.runoob.com
EOF
3          # 輸出結果為 3 行
$

我們也可以將 Here Document 用在指令碼中，例如：

#!/bin/bash

cat << EOF
廁所
測試
www.runoob.com
EOF

執行以上指令碼，輸出結果：

廁所
測試
www.runoob.com

/dev/null 檔案

如果希望執行某個命令，但又不希望在螢幕上顯示輸出結果，那麼可以將輸出重定向到 /dev/null：

$ command > /dev/null

/dev/null 是一個特殊的檔案，寫入到它的內容都會被丟棄。

如果嘗試從該檔案讀取內容，那麼什麼也讀不到。

但是 /dev/null 檔案非常有用，將命令的輸出重定向到它，會起到”禁止輸出”的效果。

如果希望遮蔽 stdout 和 stderr，可以這樣寫：

$ command > /dev/null 2>&1

注意：0 是標準輸入（STDIN），1 是標準輸出（STDOUT），2 是標準錯誤輸出（STDERR）。

檔案包含

和其他語言一樣，Shell 也可以包含外部指令碼。

這樣可以很方便的封裝一些公用的程式碼作為一個獨立的檔案。

Shell 檔案包含的語法格式如下：

. filename   # 注意點號(.)和檔名中間有一空格

或

source filename

例項

建立兩個 shell 指令碼檔案。

test1.sh 程式碼如下：

#!/bin/bash

url="http://www.runoob.com"

test2.sh 程式碼如下：

#!/bin/bash

#使用 . 號來引用test1.sh 檔案
. ./test1.sh

# 或者使用以下包含檔案程式碼
# source ./test1.sh
echo "測試地址：$url"

接下來，我們為 test2.sh 新增可執行許可權並執行：

$ chmod +x test2.sh 
$ ./test2.sh 
測試地址：http://www.runoob.com

注：被包含的檔案 test1.sh 不需要可執行許可權。

相關文章