個人博客 ：https://www.siyuan.run
CSDN：https://blog.csdn.net/siyuan
微信小程序：思遠Y
概述
Shell 是一個用 C 語言編寫的程序，它是用戶使用 Linux 的橋梁。Shell 既是一種命令語言，又是一種程序設計語言。
Shell 是指一種應用程序，這個應用程序提供了一個界面，用戶通過這個界面訪問操作系統內核的服務。
Ken Thompson 的 sh 是第一種 Unix Shell，Windows Explorer 是一個典型的圖形界面 Shell。
Shell 腳本
Shell 腳本（shell script），是一種為 shell 編寫的腳本程序。
業界所說的 shell 通常都是指 shell 腳本，但讀者朋友要知道，shell 和 shell script 是兩個不同的概念。
由于習慣的原因，簡潔起見，本文出現的 “shell編程” 都是指 shell 腳本編程，不是指開發 shell 自身。
Shell 環境
Shell 編程跟 JavaScript、php 編程一樣，只要有一個能編寫代碼的文本編輯器和一個能解釋執行的腳本解釋器就可以了。
Linux 的 Shell 種類眾多，常見的有：
- Bourne Shell（/usr/bin/sh或/bin/sh）
- Bourne Again Shell（/bin/bash）
- C Shell（/usr/bin/csh）
- K Shell（/usr/bin/ksh）
- Shell for Root（/sbin/sh）
第一個shell腳本
打開文本編輯器(可以使用 vi/vim 命令來創建文件)，新建一個文件 test.sh，擴展名為 sh（sh代表shell），擴展名并不影響腳本執行，見名知意就好，如果你用 php 寫 shell 腳本，擴展名就用 php 好了。
輸入一些代碼，第一行一般是這樣：
#!/bin/bash
echo "Hello World !"
#! 是一個約定的標記，它告訴系統這個腳本需要什么解釋器來執行，即使用哪一種 Shell。
echo 命令用于向窗口輸出文本。
執行腳本
./test.sh- 指定解釋器執行腳本
/bin/bash test.sh、/bin/php test.php
變量
變量命名
定義變量時，變量名不加美元符號（$，PHP語言中變量需要），如：
your_name="runoob.com"
變量名的命名規則：
- 命名可以使用英文字母、數字、下劃線，數字不能開頭。
- 不能使用其他字符，包括空格，標點符號。
- 不能使用 bash 關鍵字。
# 有效命名
username
USERNAME
username2
USERNAME2
user_name
USER_name
_username
_USERNAME
# 無效命名
?username
user name
user*name
user,name
使用語句給變量賦值：
for file in `ls /etc`
doecho ${file}
done
使用變量
使用定義過的變量，只需要在變量名前面加美元符號$即可：
username="siyuan"
echo $username
echo ${username}
變量名外面的花括號是可選的，加花括號是為了幫助解釋器識別變量的邊界。
已定義的變量，可被重新定義：
user_name="siyuan"
echo ${user_name}
user_name="sy"
echo ${user_name}
這樣寫是合法的，但注意，第二次賦值的時候不能寫yourname="alibaba"，使用變量的時候才加美元符（your_name="alibaba"，使用變量的時候才加美元符（yourn?ame="alibaba"，使用變量的時候才加美元符（）。
只讀變量
使用 readonly 命令可以將變量定義為只讀變量，只讀變量的值不能被改變。
baiduUrl="https://www.baidu.com"
readonly baiduUrl
baiduUrl="www.baidu.com"
運行結果顯示：
script.sh: line 24: baiduUrl: readonly variableExited with error status 1
刪除變量
使用 unset 命令可以刪除變量，語法：
unset variable_name
變量被刪除后不能再次使用。unset 命令不能刪除只讀命令。
username="siyuan"
echo ${username}
unset username
echo "username=" ${username}
name="sy"
readonly name
echo ${name}
unset name
echo ${name}
運行結果顯示：
siyuan
username=
sy
sy
script.sh: line 33: unset: name: cannot unset: readonly variable
變量類型
運行shell時，會同時存在三種變量：
- 1) 局部變量 局部變量在腳本或命令中定義，僅在當前shell實例中有效，其他shell啟動的程序不能訪問局部變量。
- 2) 環境變量 所有的程序，包括shell啟動的程序，都能訪問環境變量，有些程序需要環境變量來保證其正常運行。必要的時候shell腳本也可以定義環境變量。
- 3) shell變量 shell變量是由shell程序設置的特殊變量。shell變量中有一部分是環境變量，有一部分是局部變量，這些變量保證了shell的正常運行
字符串
字符串是shell編程中最常用最有用的數據類型（除了數字和字符串，也沒啥其它類型好用了），字符串可以用單引號，也可以用雙引號，也可以不用引號。
單引號
str='this is a string'
單引號字符串的限制：
- 單引號里的任何字符都會原樣輸出，單引號字符串中的變量是無效的；
- 單引號字串中不能出現單獨一個的單引號（對單引號使用轉義符后也不行），但可成對出現，作為字符串拼接使用。
雙引號
your_name='runoob'
str="Hello, I know you are \"$your_name\"! \n"
echo -e $str
輸出結果為：
Hello, I know you are "runoob"!
雙引號的優點：
- 雙引號里可以有變量
- 雙引號里可以出現轉義字符
拼接字符串
echo "雙引號字符串"
str1="siyuan"
joint1="joint1 hello ${str1}!"
echo ${joint1}
joint2="joint2 hello \"${str1}\"!"
echo ${joint2}
joint3="joint3 hello "${str1}" !"
echo ${joint3}
echo "單引號字符串"
str1='sy'
joint1='joint1 hello ${str1}!'
echo ${joint1}
# 不允許有轉移字符
#joint2='joint2 hello \'${str1}\'!'
#echo ${joint2}
joint3='joint3 hello '${str1}' !'
echo ${joint3}
打印結果：
雙引號字符串
joint1 hello siyuan!
joint2 hello "siyuan"!
joint3 hello siyuan !
單引號字符串
joint1 hello ${str1}!
joint3 hello sy !
獲取字符串長度
string="abcd"
echo ${#string} #輸出 4
截取字符串
從索引位置1開始，截取四個字符。
username="siyuan"
echo ${username:1:4}
注意：字符索引位置從0號開始。
查找子字符串
查找字符串i或o的位置，那個字母先出現就先計算那個。
str="runoob is a great site"
echo `expr index "${str}" 'io'`
注意： 以上腳本中 ` 是反引號，而不是單引號 '，不要看錯了哦。
數組
bash支持一維數組（不支持多維數組），并且沒有限定數組的大小。
類似于 C 語言，數組元素的下標由 0 開始編號。獲取數組中的元素要利用下標，下標可以是整數或算術表達式，其值應大于或等于 0。
定義數組
在 Shell 中，用括號來表示數組，數組元素用"空格"符號分割開。定義數組的一般形式為：
數組名=(值1 值2 ... 值n)
列如：
# 1.
usernames=(name0 name1 name2 name3)
# 2.
usernames=(
user0
user1
user2
user3
)
# 3.
usernames[0]=username0
usernames[1]=username1
usernames[2]=username2
usernames[3]=username3
可以不使用連續的下標，而且下標的范圍沒有限制。
讀取數組
讀取數組元素值的一般格式是：
${數組名[下標]}
例如：
valuen=${array_name[n]}
使用 @ 符號可以獲取數組中的所有元素，例如：
echo ${array_name[@]}
獲取數組的長度
獲取數組長度的方法與獲取字符串長度的方法相同，例如：
# 取得數組元素的個數
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得數組單個元素的長度,對比下字符串長度${string}
lengthn=${#array_name[n]}
注釋
單行注釋
以 # 開頭的行就是注釋，會被解釋器忽略。
# 我是單行注釋
多行注釋
# 方式一
:<<EOF
注釋內容...
注釋內容...
注釋內容...
EOF
# 方式二
:<<!
注釋內容...
注釋內容...
注釋內容...
!
傳遞參數
我們可以在執行 Shell 腳本時，向腳本傳遞參數，腳本內獲取參數的格式為：$n。n 代表一個數字，1 為執行腳本的第一個參數，2 為執行腳本的第二個參數，以此類推……
實例
以下實例我們向腳本傳遞三個參數，并分別輸出，其中 $0 為執行的文件名（包含文件路徑）：
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號 |
| $@ | 與?相同，但是使用時加引號，并在引號中返回每個參數。<br/>如"*相同，但是使用時加引號，并在引號中返回每個參數。<br/>如"?相同，但是使用時加引號，并在引號中返回每個參數。<br/>如"@“用「”」括起來的情況、以"$1" “2"…"2" … "2"…"n” 的形式輸出所有參數。 |
| $- | 顯示Shell使用的當前選項，與set命令功能相同。 |
| $? | 顯示最后命令的退出狀態。0表示沒有錯誤，其他任何值表明有錯誤。 |
#!/bin/bash
echo "shell 傳遞參數實例！"
echo "執行的文件名：$0"
echo "第一個參數為：$1"
echo "第二個參數為：$2"
echo "第三個參數為：$3"echo "參數的個數：$#"
echo "參數作為一個字符串顯示：$*"
echo "參數作為每個字符顯示：$@"
結果顯示如下：
$ chmod +x param.sh
$ ./param.sh hello word shell param
shell 傳遞參數實例！
執行的文件名：./param.sh
第一個參數為：hello
第二個參數為：word
第三個參數為：shell
參數的個數：4
參數作為一個字符串顯示：hello word shell param
參數作為每個字符顯示：hello word shell param
$* 與 $@ 區別：
- 相同點：都是引用所有參數。
- 不同點：只有在雙引號中體現出來。假設在腳本運行時寫了三個參數 1、2、3，，則 " * " 等價于 “1 2 3”（傳遞了一個參數），而 “@” 等價于 “1” “2” “3”（傳遞了三個參數）。
echo '演示 $* 與 $@ 區別：'
for s in "$*"
doecho $s
done
for s in "$@"
do echo $s
done
執行腳本，輸出結果如下所示：
演示 $* 與 $@ 區別：
hello word shell param
hello
word
shell
param
基本運算符
Shell 和其他編程語言一樣，支持多種運算符，包括：
- 算數運算符
- 關系運算符
- 布爾運算符
- 字符串運算符
- 文件測試運算符
原生bash不支持簡單的數學運算，但是可以通過其他命令來實現，例如 awk 和 expr，expr 最常用。
expr 是一款表達式計算工具，使用它能完成表達式的求值操作。
例如，兩個數相加(注意使用的是反引號 *`* 而不是單引號 *’*)：
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 ]。
實例
算術運算符實例如下：
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 ${a} % ${b}`
echo "a % b = ${val}"val=`expr ${b} % ${a}`
echo "b % a = ${val}"if [ ${a} == ${b} ]
thenecho "a 等于 b"
fiif [ ${a} != ${b} ]
thenecho "a 不等于 b"
fi
執行腳本，輸出結果如下所示：
a + b = 30
a - b = -10
a * b = 200
b / a = 2
a % b = 10
b % a = 0
a 不等于 b
注意：
- 乘號(*)前邊必須加反斜杠()才能實現乘法運算；
- if…then…fi 是條件語句，后續將會講解。
- 在 MAC 中 shell 的 expr 語法是：$((表達式))，此處表達式中的 “*” 不需要轉義符號 “” 。
關系運算符
關系運算符只支持數字，不支持字符串，除非字符串的值是數字。
下表列出了常用的關系運算符，假定變量 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。 |
實例
關系運算符實例如下：
a=10
b=20if [ $a -eq $b ]
thenecho "$a -eq $b : a 等于 b"
elseecho "$a -eq $b: a 不等于 b"
fi
if [ $a -ne $b ]
thenecho "$a -ne $b: a 不等于 b"
elseecho "$a -ne $b : a 等于 b"
fi
if [ $a -gt $b ]
thenecho "$a -gt $b: a 大于 b"
elseecho "$a -gt $b: a 不大于 b"
fi
if [ $a -lt $b ]
thenecho "$a -lt $b: a 小于 b"
elseecho "$a -lt $b: a 不小于 b"
fi
if [ $a -ge $b ]
thenecho "$a -ge $b: a 大于或等于 b"
elseecho "$a -ge $b: a 小于 b"
fi
if [ $a -le $b ]
thenecho "$a -le $b: a 小于或等于 b"
elseecho "$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 | 或運算（or），有一個表達式為 true 則返回 true。 | [ $a -lt 20 -o $b -gt 100 ] 返回 true。 |
| -a | 與運算（and），兩個表達式都為 true 才返回 true。 | [ $a -lt 20 -a $b -gt 100 ] 返回 false。 |
布爾運算符實例如下：
實例
a=10
b=20if [ $a != $b ]
thenecho "$a != $b : a 不等于 b"
elseecho "$a == $b: a 等于 b"
fiif [ $a -lt 100 -a $b -gt 15 ]
thenecho "$a 小于 100 且 $b 大于 15 : 返回 true"
elseecho "$a 小于 100 且 $b 大于 15 : 返回 false"
fiif [ $a -lt 100 -o $b -gt 100 ]
thenecho "$a 小于 100 或 $b 大于 100 : 返回 true"
elseecho "$a 小于 100 或 $b 大于 100 : 返回 false"
fiif [ $a -lt 5 -o $b -gt 100 ]
thenecho "$a 小于 5 或 $b 大于 100 : 返回 true"
elseecho "$a 小于 5 或 $b 大于 100 : 返回 false"
fi
執行腳本，輸出結果如下所示：
10 != 20 : a 不等于 b
10 小于 100 且 20 大于 15 : 返回 true
10 小于 100 或 20 大于 100 : 返回 true
10 小于 5 或 20 大于 100 : 返回 false
邏輯運算符
以下介紹 Shell 的邏輯運算符，假定變量 a 為 10，變量 b 為 20:
| 運算符 | 說明 | 舉例 |
|---|---|---|
| && | 邏輯的 AND | [[ $a -lt 100 && $b -gt 100 ]] 返回 false |
| || | 邏輯的 OR | [[ $a -lt 100 || $b -gt 100 ]] 返回 true |
實例
a=10
b=20if [[ $a -lt 100 && $b -gt 100 ]]
thenecho "返回 true"
elseecho "返回 false"
fiif [[ $a -lt 100 || $b -gt 100 ]]
thenecho "返回 true"
elseecho "返回 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。 |
| $ | 檢測字符串是否為空，不為空返回 true。 | [ $a ] 返回 true。 |
實例
字符串運算符實例如下：
a="abc"
b="efg"if [ $a = $b ]
thenecho "$a = $b : a 等于 b"
elseecho "$a = $b: a 不等于 b"
fiif [ $a != $b ]
thenecho "$a != $b : a 不等于 b"
elseecho "$a != $b: a 等于 b"
fiif [ -z $a ]
thenecho "-z $a : 字符串長度為 0"
elseecho "-z $a : 字符串長度不為 0"
fiif [ -n "$a" ]
thenecho "-n $a : 字符串長度不為 0"
elseecho "-n $a : 字符串長度為 0"
fiif [ $a ]
thenecho "$a : 字符串不為空"
elseecho "$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。 |
其他檢查符：
- -S: 判斷某文件是否 socket。
- -L: 檢測文件是否存在并且是一個符號鏈接。
實例
變量 file 表示文件 /siyuan/shell/param.sh，它的大小為 100 字節，具有 rwx 權限。下面的代碼，將檢測該文件的各種屬性：
file="/siyuan/shell/param.sh"
if [ -r $file ]
thenecho "文件可讀"
elseecho "文件不可讀"
fi
if [ -w $file ]
thenecho "文件可寫"
elseecho "文件不可寫"
fi
if [ -x $file ]
thenecho "文件可執行"
elseecho "文件不可執行"
fi
if [ -f $file ]
thenecho "文件為普通文件"
elseecho "文件為特殊文件"
fi
if [ -d $file ]
thenecho "文件是個目錄"
elseecho "文件不是個目錄"
fi
if [ -s $file ]
thenecho "文件不為空"
elseecho "文件為空"
fi
if [ -e $file ]
thenecho "文件存在"
elseecho "文件不存在"
fi
執行腳本，輸出結果如下所示：
文件可讀
文件可寫
文件可執行
文件為普通文件
文件不是個目錄
文件不為空
文件存在
echo命令
用于字符串的輸出。命令格式：
echo string
您可以使用echo實現更復雜的輸出格式控制。
輸出普通字符串:
echo "It is a test"
這里的雙引號完全可以省略，以下命令與上面實例效果一致：
echo It is a test
輸出轉義字符
echo "\"It is a test\""
結果將是:
"It is a test"
同樣，雙引號也可以省略。
顯示變量
read 命令從標準輸入中讀取一行,并把輸入行的每個字段的值指定給 shell 變量
read name
echo "$name It is a test"
以上代碼保存為 test.sh，name 接收標準輸入的變量，結果將是:
OK #標準輸入
OK It is a test #輸出
輸出換行
echo -e "OK! \n" # -e 開啟轉義
echo "It is a test"
輸出結果：
OK!It is a test
輸出不換行
echo -e "OK! \c" # -e 開啟轉義 \c 不換行
echo "It is a test"
輸出結果：
OK! It is a test
顯示結果定向至文件
echo "It is a test" > myfile
原樣輸出字符串，不進行轉義或取變量(用單引號)
echo '$name\"'
輸出結果：
$name\"
顯示命令執行結果
echo `date`
注意： 這里使用的是反引號 `, 而不是單引號 '。
結果將顯示當前日期
Thu Jul 24 10:08:46 CST 2014
printf 命令
另一個輸出命令。
printf 使用引用文本或空格分隔的參數，外面可以在 printf 中使用格式化字符串，還可以制定字符串的寬度、左右對齊方式等。默認 printf 不會像 echo 自動添加換行符，我們可以手動添加 \n。
printf 命令的語法：
printf format-string [arguments...]
參數說明：
- format-string: 為格式控制字符串
- arguments: 為參數列表。
printf "hello shell printf "
printf "hi shell printf"
printf "\nhello shell printf\n"
printf "hi shell printf"
輸出結果：
hello shell printf hi shell printf
hello shell printf
hi shell printf
實例
printf "%-10s %-8s %-4s\n" 姓名 性別 體重kg
printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234
printf "%-10s %-8s %-4.2f\n" 楊過 男 48.6543
printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876
執行腳本，輸出結果如下所示：
姓名 性別 體重kg
郭靖 男 66.12
楊過 男 48.65
郭芙 女 47.99
%s %c %d %f 都是格式替代符，％s 輸出一個字符串，％d 整型輸出，％c 輸出一個字符，％f 輸出實數，以小數形式輸出。
%-10s 指一個寬度為 10 個字符（- 表示左對齊，沒有則表示右對齊），任何字符都會被顯示在 10 個字符寬的字符內，如果不足則自動以空格填充，超過也會將內容全部顯示出來。
%-4.2f 指格式化為小數，其中 .2 指保留2位小數。
實例
# format-string為雙引號
printf "%d %s\n" 1 "abc"# 單引號與雙引號效果一樣
printf '%d %s\n' 1 "abc"# 沒有引號也可以輸出
printf %s abcdefprintf "\n"# 格式只指定了一個參數，但多出的參數仍然會按照該格式輸出，format-string 被重用
printf %s abc defprintf "\n"printf "%s\n" abc defprintf "%s %s %s\n" a b c d e f g h i j# 如果沒有 arguments，那么 %s 用NULL代替，%d 用 0 代替
printf "%s and %d \n"
執行腳本，輸出結果如下所示：
1 abc
1 abc
abcdef
abcdef
abc
def
a b c
d e f
g h i
j and 0
printf 的轉義序列
| 序列 | 說明 |
|---|---|
| \a | 警告字符，通常為ASCII的BEL字符 |
| \b | 后退 |
| \c | 抑制（不顯示）輸出結果中任何結尾的換行字符（只在%b格式指示符控制下的參數字符串中有效），而且，任何留在參數里的字符、任何接下來的參數以及任何留在格式字符串中的字符，都被忽略 |
| \f | 換頁（formfeed） |
| \n | 換行 |
| \r | 回車（Carriage return） |
| \t | 水平制表符 |
| \v | 垂直制表符 |
| \ | 一個字面上的反斜杠字符 |
| \ddd | 表示1到3位數八進制值的字符。僅在格式字符串中有效 |
| \0ddd | 表示1到3位的八進制值字符 |
實例
$ printf "a string, no processing:<%s>\n" "A\nB"
a string, no processing:<A\nB>$ printf "a string, no processing:<%b>\n" "A\nB"
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]
thenecho '兩個數相等！'
elseecho '兩個數不相等！'
fi
輸出結果：
兩個數相等！
代碼中的 [] 執行基本的算數運算，如：
a=5
b=6result=$[a+b] # 注意等號兩邊不能有空格
echo "result 為： $result"
結果為:
result 為： 11
字符串測試
| 參數 | 說明 |
|---|---|
| = | 等于則為真 |
| != | 不相等則為真 |
| -z 字符串 | 字符串的長度為零則為真 |
| -n 字符串 | 字符串的長度不為零則為真 |
實例
num1="ru1noob"
num2="runoob"
if test $num1 = $num2
thenecho '兩個字符串相等!'
elseecho '兩個字符串不相等!'
fi
輸出結果：
兩個字符串不相等!
文件測試
| 參數 | 說明 |
|---|---|
| -e 文件名 | 如果文件存在則為真 |
| -r 文件名 | 如果文件存在且可讀則為真 |
| -w 文件名 | 如果文件存在且可寫則為真 |
| -x 文件名 | 如果文件存在且可執行則為真 |
| -s 文件名 | 如果文件存在且至少有一個字符則為真 |
| -d 文件名 | 如果文件存在且為目錄則為真 |
| -f 文件名 | 如果文件存在且為普通文件則為真 |
| -c 文件名 | 如果文件存在且為字符型特殊文件則為真 |
| -b 文件名 | 如果文件存在且為塊特殊文件則為真 |
實例
cd /bin
if test -e ./bash
thenecho '文件已存在!'
elseecho '文件不存在!'
fi
輸出結果：
文件已存在!
另外，Shell 還提供了與( -a )、或( -o )、非( ! )三個邏輯操作符用于將測試條件連接起來，其優先級為： ! 最高， -a 次之， -o 最低。
例如：
cd /bin
if test -e ./notFile -o -e ./bash
thenecho '至少有一個文件存在!'
elseecho '兩個文件都不存在'
fi
輸出結果：
至少有一個文件存在!
流程控制
和Java、PHP等語言不一樣，sh的流程控制不可為空。
<?php
if (isset($_GET["q"])) {search(q);
}
else {// 不做任何事情
}
在sh/bash里可不能這么寫，如果else分支沒有語句執行，就不要寫這個else。
if else
if else 語法格式：
if condition
thencommand1 command2...commandN
elsecommand
fi
if else-if else
if else-if else 語法格式：
if condition1
thencommand1
elif condition2
then command2
elsecommandN
fi
實例
a=10
b=20
if [ $a == $b ]
thenecho "a 等于 b"
elif [ $a -gt $b ]
thenecho "a 大于 b"
elif [ $a -lt $b ]
thenecho "a 小于 b"
elseecho "沒有符合的條件"
fi
輸出結果：
a 小于 b
if else 語句經常與 test 命令結合使用，如下所示：
num1=$[2*3]
num2=$[1+5]
if test $[num1] -eq $[num2]
thenecho '兩個數字相等!'
elseecho '兩個數字不相等!'
fi
輸出結果：
兩個數字相等!
for 循環
與其他編程語言類似，Shell支持for循環。
for循環一般格式為：
for var in item1 item2 ... itemN
docommand1command2...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
doecho "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'
doecho $str
done
輸出結果：
This is a string
while 語句
while循環用于不斷執行一系列命令，也用于從輸入文件中讀取數據；命令通常為測試條件。其格式為：
while condition
docommand
done
以下是一個基本的while循環，測試條件是：如果int小于等于5，那么條件返回真。int從0開始，每次循環處理時，int加1。運行上述腳本，返回數字1到5，然后終止。
實例
int=1
while(( $int<=5 ))
doecho $intlet "int++"
done
運行腳本，輸出：
1
2
3
4
5
以上實例使用了 Bash let 命令，它用于執行一個或多個表達式，變量計算中不需要加上 $ 來表示變量。
while循環可用于讀取鍵盤信息。下面的例子中，輸入信息被設置為變量FILM，按結束循環。
實例
echo '按下 <CTRL-D> 退出'
echo -n '輸入你最喜歡的網站名: '
while read FILM
doecho "是的！$FILM 是一個好網站"
done
運行腳本，輸出類似下面：
按下 <CTRL-D> 退出
輸入你最喜歡的網站名:siyuan
是的！siyuan 是一個好網站
無限循環
無限循環語法格式：
while :
docommand
done
或者
while true
docommand
done
或者
for (( ; ; ))
until 循環
until 循環執行一系列命令直至條件為 true 時停止。
until 循環與 while 循環在處理方式上剛好相反。
一般 while 循環優于 until 循環，但在某些時候—也只是極少數情況下，until 循環更加有用。
until 語法格式:
until condition
docommand
done
condition 一般為條件表達式，如果返回值為 false，則繼續執行循環體內的語句，否則跳出循環。
以下實例我們使用 until 命令來輸出 0 ~ 9 的數字：
a=0until [ ! $a -lt 10 ]
doecho $aa=`expr $a + 1`
done
輸出結果為：
0
1
2
3
4
5
6
7
8
9
case
Shell case語句為多選擇語句。可以用case語句匹配一個值與一個模式，如果匹配成功，執行相匹配的命令。case語句格式如下：
case 值 in
模式1)command1command2...commandN;;
模式2）command1command2...commandN;;
esac
case工作方式如上所示。取值后面必須為單詞in，每一模式必須以右括號結束。取值可以為變量或常數。匹配發現取值符合某一模式后，其間所有命令開始執行直至 ;;。
取值將檢測匹配的每一個模式。一旦模式匹配，則執行完匹配模式相應命令后不再繼續其他模式。如果無一匹配模式，使用星號 * 捕獲該值，再執行后面的命令。
下面的腳本提示輸入1到4，與每一種模式進行匹配：
echo '輸入 1 到 4 之間的數字:'
echo '你輸入的數字為:'
read aNum
case $aNum in1) echo '你選擇了 1';;2) echo '你選擇了 2';;3) echo '你選擇了 3';;4) echo '你選擇了 4';;*) echo '你沒有輸入 1 到 4 之間的數字';;
esac
輸入不同的內容，會有不同的結果，例如：
輸入 1 到 4 之間的數字:
你輸入的數字為:
3
你選擇了 3
跳出循環
在循環過程中，有時候需要在未達到循環結束條件時強制跳出循環，Shell使用兩個命令來實現該功能：break和continue。
break命令
break命令允許跳出所有循環（終止執行后面的所有循環）。
下面的例子中，腳本進入死循環直至用戶輸入數字大于5。要跳出這個循環，返回到shell提示符下，需要使用break命令。
while :
doecho -n "輸入 1 到 5 之間的數字:"read aNumcase $aNum in1|2|3|4|5) echo "你輸入的數字為 $aNum!";;*) echo "你輸入的數字不是 1 到 5 之間的! 游戲結束"break;;esac
done
執行以上代碼，輸出結果為：
輸入 1 到 5 之間的數字:3
你輸入的數字為 3!
輸入 1 到 5 之間的數字:7
你輸入的數字不是 1 到 5 之間的! 游戲結束
continue
continue命令與break命令類似，只有一點差別，它不會跳出所有循環，僅僅跳出當前循環。
對上面的例子進行修改：
while :
doecho -n "輸入 1 到 5 之間的數字: "read aNumcase $aNum in1|2|3|4|5) echo "你輸入的數字為 $aNum!";;*) echo "你輸入的數字不是 1 到 5 之間的!"continueecho "游戲結束";;esac
done
運行代碼發現，當輸入大于5的數字時，該例中的循環不會結束，語句 echo “游戲結束” 永遠不會被執行。
case … esac
case … esac 與其他語言中的 switch … case 語句類似，是一種多分枝選擇結構，每個 case 分支用右圓括號開始，用兩個分號 ;; 表示 break，即執行結束，跳出整個 case … esac 語句，esac（就是 case 反過來）作為結束標記。
case … esac 語法格式如下：
case 值 in
模式1)command1command2command3;;
模式2）command1command2command3;;
*)command1command2command3;;
esac
case 后為取值，值可以為變量或常數。
值后為關鍵字 in，接下來是匹配的各種模式，每一模式最后必須以右括號結束，模式支持正則表達式。
site="runoob"case "$site" in"siyuan") echo "思遠";;"google") echo "Google 搜索";;"taobao") echo "淘寶網";;
esac
輸出結果為：
思遠
函數
linux shell 可以用戶定義函數，然后在shell腳本中可以隨便調用。
shell中函數的定義格式如下：
[ function ] funname [()]
{action;[return int;]
}
說明：
- 1、可以帶function fun() 定義，也可以直接fun() 定義,不帶任何參數。
- 2、參數返回，可以顯示加：return 返回，如果不加，將以最后一條命令運行結果，作為返回值。 return后跟數值n(0-255
下面的例子定義了一個函數并進行調用：
demoFun(){echo "這是我的第一個 shell 函數!"
}
echo "-----函數開始執行-----"
demoFun
echo "-----函數執行完畢-----"
輸出結果：
-----函數開始執行-----
這是我的第一個 shell 函數!
-----函數執行完畢-----
下面定義一個帶有return語句的函數：
funWithReturn(){echo "這個函數會對輸入的兩個數字進行相加運算..."echo "輸入第一個數字: "read aNumecho "輸入第二個數字: "read anotherNumecho "兩個數字分別為 $aNum 和 $anotherNum !"return $(($aNum+$anotherNum))
}
funWithReturn
echo "輸入的兩個數字之和為 $? !"
輸出類似下面：
這個函數會對輸入的兩個數字進行相加運算...
輸入第一個數字:
1
輸入第二個數字:
2
兩個數字分別為 1 和 2 !
輸入的兩個數字之和為 3 !
函數返回值在調用該函數后通過 $? 來獲得。
注意：所有函數在使用前必須定義。這意味著必須將函數放在腳本開始部分，直至shell解釋器首次發現它時，才可以使用。調用函數僅使用其函數名即可。
函數參數
在Shell中，調用函數時可以向其傳遞參數。在函數體內部，通過 $n 的形式來獲取參數的值，例如，$1表示第一個參數，$2表示第二個參數…
帶參數的函數示例：
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 不能獲取第十個參數，獲取第十個參數需要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 "siyuan：https://www.siyuan.run" > users
$ cat users
siyuan：https://www.siyuan.run
$
如果不希望文件內容被覆蓋，可以使用 >> 追加到文件末尾，例如：
$ echo "siyuan：https://www.siyuan.run" >> users
$ cat users
siyuan：https://www.siyuan.run
siyuan：https://www.siyuan.run
$
輸入重定向
和輸出重定向一樣，Unix 命令也可以從文件獲取輸入，語法為：
command1 < file1
這樣，本來需要從鍵盤獲取輸入的命令會轉移到文件讀取內容。
注意：輸出重定向是大于號(>)，輸入重定向是小于號(<)。
實例
接著以上實例，我們需要統計 users 文件的行數,執行以下命令：
$ wc -l users2 users
也可以將輸入重定向到 users 文件：
$ wc -l < users2
注意：上面兩個例子的結果不同：第一個例子，會輸出文件名；第二個不會，因為它僅僅知道從標準輸入讀取內容。
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 << delimiterdocument
delimiter
它的作用是將兩個 delimiter 之間的內容(document) 作為輸入傳遞給 command。
注意：
- 結尾的delimiter 一定要頂格寫，前面不能有任何字符，后面也不能有任何字符，包括空格和 tab 縮進。
- 開始的delimiter前后的空格會被忽略掉。
實例
在命令行中通過 wc -l 命令計算 Here Document 的行數：
$ wc -l << EOF歡迎來到siyuanhttps://www.siyuan.run
EOF
3 # 輸出結果為 3 行
$
我們也可以將 Here Document 用在腳本中，例如：
#!/bin/bash
# author:菜鳥教程
# url:www.runoob.comcat << EOF歡迎來到siyuanhttps://www.siyuan.run
EOF
執行以上腳本，輸出結果：
歡迎來到
siyuan
https://www.siyuan.run
/dev/null 文件
如果希望執行某個命令，但又不希望在屏幕上顯示輸出結果，那么可以將輸出重定向到 /dev/null：
$ command > /dev/null
/dev/null 是一個特殊的文件，寫入到它的內容都會被丟棄；如果嘗試從該文件讀取內容，那么什么也讀不到。但是 /dev/null 文件非常有用，將命令的輸出重定向到它，會起到"禁止輸出"的效果。
如果希望屏蔽 stdout 和 stderr，可以這樣寫：
$ command > /dev/null 2>&1
**注意：**0 是標準輸入（STDIN），1 是標準輸出（STDOUT），2 是標準錯誤輸出（STDERR）。
這里的 2 和 > 之間不可以有空格，2> 是一體的時候才表示錯誤輸出。
文件包含
和其他語言一樣，Shell 也可以包含外部腳本。這樣可以很方便的封裝一些公用的代碼作為一個獨立的文件。
Shell 文件包含的語法格式如下：
. filename # 注意點號(.)和文件名中間有一空格或source filename
實例
創建兩個 shell 腳本文件。
test1.sh 代碼如下：
url="https://www.siyuan.run"
test2.sh 代碼如下：
#使用 . 號來引用test1.sh 文件
. ./test1.sh# 或者使用以下包含文件代碼
# source ./test1.shecho "siyuan 網址：$url"
接下來，我們為 test2.sh 添加可執行權限并執行：
$ chmod +x test2.sh
$ ./test2.sh
siyuan 網址：https://www.siyuan.run
**注：**被包含的文件 test1.sh 不需要可執行權限。
--JNI分析API)
