Shell腳本的學習

編寫腳本文件

定義以開頭：#!/bin/bash

#!用來聲明腳本由什么shell解釋，否則使用默認shel

第一步：編寫腳本文件

#!/bin/bash
#注釋
echo "這是輸出"

第二步：加上執行權限：chmod +x 腳本文件名.sh

第三步：運行程序

./xxx.sh :先按照文件中#!指定的解析器解析,如果#！指定指定的解析器不存在才會使用系統默認的解析器

bash xxx.sh:指明先用bash解析器解析,如果bash不存在才會使用默認解析器

. xxx.sh 直接使用默認解析器解析（不會執行第一行的#！指定的解析器）但是第一行還是要寫的

shell學習

變量

定義變量：變量名=變量值

如：num=10? ? ? #等號兩側避免使用空格

引用變量：$變量名

echo $num? ? ? ? ?#輸出10??
echo?${num}? ? ? ? #推薦給所有變量加上花括號

unset ：清除變量值

unset?$num? ? ? ?#unset 命令不能刪除只讀變量
echo $num? ? ? ? ?#輸出空

read：從鍵盤獲取輸入

read? num
echo "num=$num"

在一行上顯示和添加提示需要加上-p

read -p? “請輸入Num的值:" num
echo "num=$num"

readonly:只讀變量，只讀變量的值不能被改變

環境變量?：

這些是由操作系統或用戶設置的特殊變量，用于配置 Shell 的行為和影響其執行環境。

例如，PATH 變量包含了操作系統搜索可執行文件的路徑：

echo $PATH

特殊變量：?

$0?表示腳本的名稱
$1,?$2, 等表示腳本的參數
$#表示傳遞給腳本的參數數量
$??表示上一個命令的退出狀態等。

整數變量：

在一些Shell中，你可以使用?declare?或?typeset?命令來聲明整數變量。

declare -i my_integer=42

這樣的聲明告訴 Shell 將 my_integer 視為整數，如果嘗試將非整數值賦給它，Shell會嘗試將其轉換為整數。

數組變量：

數組可以是整數索引數組或關聯數組

bash支持一維數組（不支持多維數組），并且沒有限定數組的大小。

類似于 C 語言，數組元素的下標由 0 開始編號。獲取數組中的元素要利用下標，下標可以是整數或算術表達式，其值應大于或等于 0。

定義數組:

在 Shell 中，用括號來表示數組，數組元素用"空格"符號分割開。定義數組的一般形式為：

數組名=(值1 值2 ... 值n)

array_name=(value0 value1 value2 value3)

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

#整數索引數組
my_array=(1 2 3 4 5)
#關聯數組
declare -A associative_array
associative_array["name"]="John"
associative_array["age"]=30

讀取數組:

讀取數組元素值的一般格式是：

${數組名[下標]}
valuen=${array_name[n]}
#使用?@?符號可以獲取數組中的所有元素，例如：
echo ${array_name[@]}

獲取數組的長度:

獲取數組長度的方法與獲取字符串長度的方法相同，例如：

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

關聯數組:

Bash 支持關聯數組，可以使用任意的字符串、或者整數作為下標來訪問數組元素。

關聯數組使用?declare?命令來聲明，語法格式如下：

declare -A array_name

-A?選項就是用于聲明一個關聯數組。關聯數組的鍵是唯一的。

declare?-A?site=(["google"]="www.google.com"?["runoob"]="www.runoob.com"?["taobao"]="www.taobao.com")

declare?-A?site
site["google"]="www.google.com"
site["runoob"]="www.runoob.com"
site["taobao"]="www.taobao.com"

通過鍵來訪問關聯數組的元素：

declare?-A?site
site["google"]="www.google.com"
site["runoob"]="www.runoob.com"
site["taobao"]="www.taobao.com"

echo?${site["runoob"]}

執行腳本，輸出結果如下所示：
www.runoob.com

獲取數組中的所有元素:

使用?@?或?*?可以獲取數組中的所有元素，例如：

#!/bin/bash
my_array[0]=A
my_array[1]=B
my_array[2]=C
my_array[3]=D
echo?"數組的元素為:?${my_array[*]}"
echo?"數組的元素為:?${my_array[@]}"

在數組前加一個感嘆號?!?可以獲取數組的所有鍵，例如：

declare?-A?site
site["google"]="www.google.com"
site["runoob"]="www.runoob.com"
site["taobao"]="www.taobao.com"

echo?"數組的鍵為:?${!site[*]}"
echo?"數組的鍵為:?${!site[@]}"

#執行腳本，輸出結果如下所示：
數組的鍵為: google runoob taobao
數組的鍵為: google runoob taobao

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"!

雙引號的優點：

雙引號里可以有變量
雙引號里可以出現轉義字符

your_name="runoob"
# 使用雙引號拼接
greeting="hello, "$your_name" !"
greeting_1="hello,?${your_name}?!"
echo?$greeting??$greeting_1

# 使用單引號拼接
greeting_2='hello, '$your_name' !'
greeting_3='hello, ${your_name} !'
echo?$greeting_2??$greeting_3

輸出結果為：
hello, runoob ! hello, runoob !
hello, runoob ! hello, ${your_name} !

獲取字符串長度

變量為字符串時，${#string}?等價于?${#string[0]}:

string="abcd"
echo?${#string}???# 輸出 4
echo?${#string[0]}???# 輸出 4

提取子字符串

從字符串索引值為 1字符開始截取?4?個字符：

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

查找子字符串

查找字符?i?或?o?的位置(哪個字母先出現就計算哪個)：腳本中?`?是反引號，而不是單引號?'

string="runoob is a great site"
echo?`expr?index?"$string"?io`??# 輸出 4（第四個不是下標）

Shell 注釋

以?#?開頭的行就是注釋，會被解釋器忽略。

通過每一行加一個?#?號設置多行注釋

多行注釋

使用 Here 文檔

多行注釋還可以使用以下格式：

:<<EOF
注釋內容...
注釋內容...
注釋內容...
EOF

: <<'COMMENT'
這是注釋的部分。
可以有多行內容。
COMMENT

:<<'
注釋內容...
注釋內容...
注釋內容...
'

:<<!
注釋內容...
注釋內容...
注釋內容...
!

Shell 傳遞參數

向腳本傳遞三個參數，并分別輸出，其中?$0?為執行的文件名（包含文件路徑），$1?表示第一個參數，$2?表示第二個參數，依此類推：

#!/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

特殊字符用來處理參數：

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"（傳遞了三個參數）。

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：

注意：條件表達式要放在方括號之間，并且要有空格，例如:?[$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 是條件語句。
在 MAC 中 shell 的 expr 語法是：$((表達式))，此處表達式中的 "*" 不需要轉義符號 "\" 。

關系運算符只支持數字，不支持字符串，除非字符串的值是數字。

關系運算符

假定變量 a 為 10，變量 b 為 20：

#!/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：

#!/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 小于 100 且 $b 大于 15 : 返回 true"
else
? ?echo "$a 小于 100 且 $b 大于 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
? ?echo "$a 小于 100 或 $b 大于 100 : 返回 true"
else
? ?echo "$a 小于 100 或 $b 大于 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
? ?echo "$a 小于 5 或 $b 大于 100 : 返回 true"
else
? ?echo "$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

邏輯運算符

假定變量 a 為 10，變量 b 為 20:

#!/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"：

#!/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 : 字符串不為空

文件測試運算符

其他檢查符：

-S: 判斷某文件是否 socket。
-L: 檢測文件是否存在并且是一個符號鏈接。

變量 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

#執行腳本，輸出結果如下所示：
文件可讀
文件可寫
文件可執行
文件為普通文件
文件不是個目錄
文件不為空
文件存在

自增和自減操作符

盡管 Shell 本身沒有像 C、C++ 或 Java 那樣的 ++ 和 -- 操作符，但可以通過其他方式實現相同的功能。以下是一些常見的方法：

使用 let 命令

let?命令允許對整數進行算術運算。

#!/bin/bash
# 初始化變量
num=5
# 自增
let?num++
# 自減
let?num--
echo?$num

使用 $(( )) 進行算術運算

$(( ))?語法也是進行算術運算的一種方式。

#!/bin/bash
# 初始化變量
num=5
# 自增
num=$((num +?1))
# 自減
num=$((num -?1))
echo?$num

使用 expr 命令

expr?命令可以用于算術運算，但在現代腳本中不如?let?和?$(( ))?常用。

#!/bin/bash
# 初始化變量
num=5
# 自增
num=$(expr?$num?+?1)
# 自減
num=$(expr?$num?-?1)
echo?$num

使用 (( )) 進行算術運算

與 $(( )) 類似，(( )) 語法也可以用于算術運算。

#!/bin/bash
# 初始化變量
num=5
# 自增
((num++))
# 自減
((num--))
echo?$num

Shell 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! \n" # -e 開啟轉義
echo "It is a test"

#輸出結果：

OK!It is 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

注意：?這里使用的是反引號?`, 而不是單引號?'。

Shell printf 命令

默認的 printf 不會像?echo?自動添加換行符，我們可以手動添加?\n。

printf 命令的語法：

printf  format-string  [arguments...]

參數說明：

format-string:?一個格式字符串，它包含普通文本和格式說明符。
arguments:?用于填充格式說明符的參數列表。。

格式說明符由?%?字符開始，后跟一個或多個字符，用于指定輸出的格式。常用的格式說明符包括：

%s：字符串
%d：十進制整數
%f：浮點數
%c：字符
%x：十六進制數
%o：八進制數
%b：二進制數
%e：科學計數法表示的浮點數

%s %c %d %f?都是格式替代符，％s?輸出一個字符串，％d?整型輸出，％c?輸出一個字符，％f?輸出實數，以小數形式輸出。

%-10s?指一個寬度為 10 個字符（-?表示左對齊，沒有則表示右對齊），任何字符都會被顯示在 10 個字符寬的字符內，如果不足則自動以空格填充，超過也會將內容全部顯示出來。

%-4.2f?指格式化為小數，其中?.2?指保留 2 位小數。

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
# format-string為雙引號
printf?"%d %s\n"?1?"abc"

# 單引號與雙引號效果一樣
printf?'%d %s\n'?1?"abc"

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

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

printf?"%s\n"?abc def

printf?"%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
abcdefabcdefabc
def
a b c
d e f
g h i
j  and 0

printf 的轉義序列

$ 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 $ ? ? ? ? ? ? ? ? ?#不換行

Shell test 命令

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

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

輸出結果：
兩個數相等！

代碼中的?[]?執行基本的算數運算，如：

#!/bin/bash
a=5
b=6
result=$[a+b]?# 注意等號兩邊不能有空格
echo?"result 為：?$result"

結果為:
result 為： 11

num1="ru1noob"
num2="runoob"
if?test?$num1?=?$num2
then
? ??echo?'兩個字符串相等!'
else
? ??echo?'兩個字符串不相等!'
fi

#輸出結果：
兩個字符串不相等!

cd?/bin
if?test?-e?./bash
then
? ??echo?'文件已存在!'
else
? ??echo?'文件不存在!'
fi

輸出結果：
文件已存在!

Shell 流程控制

if else-if else

if condition1
then
? ? command1
elif condition2?
then?
? ? command2
else
? ? commandN
fi
?

if else 的?[...]?判斷語句中大于使用?-gt，小于使用?-lt。

if [ "$a" -gt "$b" ]; then...
fi

如果使用?((...))?作為判斷語句，大于和小于可以直接使用?>?和?<。

if (( a > b )); then...
fi

for 循環

for var in item1 item2 ... itemN
do
? ? command1
? ? command2
? ? ...
? ? commandN
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
順序輸出字符串中的字符：
#!/bin/bashfor str in This is a string
doecho $str
done
#輸出結果：
This
is
a
string

while 語句

while condition
do
? ? command
done

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

#運行腳本，輸出：
1
2
3
4
5

echo?'按下 <CTRL-D> 退出'
echo?-n?'輸入你最喜歡的網站名: '
while?read?FILM
do
? ??echo?"是的！$FILM?是一個好網站"
done

#運行腳本，輸出類似下面：
按下 <CTRL-D> 退出
輸入你最喜歡的網站名:菜鳥教程
是的！菜鳥教程 是一個好網站

無限循環

無限循環語法格式：

while :
docommand
done

#或者

while true
docommand
done

#或者

for (( ; ; ))

until 循環

condition 一般為條件表達式，如果返回值為 false，則繼續執行循環體內的語句，否則跳出循環。

以下實例我們使用 until 命令來輸出 0 ~ 9 的數字：

#!/bin/bash
a=0
until?[?!?$a?-lt?10?]
do
? ?echo?$a
? ?a=`expr?$a?+?1`
done

case ... esac

多選擇語句，語法格式如下：

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

取值將檢測匹配的每一個模式。一旦模式匹配，則執行完匹配模式相應命令后不再繼續其他模式。如果無一匹配模式，使用星號 * 捕獲該值，再執行后面的命令。

下面的腳本提示輸入 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

跳出循環

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 命令類似，只有一點差別，它不會跳出所有循環，僅僅跳出當前循環。

Shell 函數

[ function ] funname [()]

{

? ? action;

? ? [return int;]

}

說明：

1、可以帶?function fun()?定義，也可以直接?fun()?定義,不帶任何參數。
2、參數返回，可以顯示加：return?返回，如果不加，將以最后一條命令運行結果，作為返回值。?return?后跟數值?n(0-255).

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

#輸出類似下面：

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

函數返回值在調用該函數后通過?$??來獲得。

注意：所有函數在使用前必須定義。這意味著必須將函數放在腳本開始部分，直至shell解釋器首次發現它時，才可以使用。調用函數僅使用其函數名即可。

注意：?return?語句只能返回一個介于 0 到 255 之間的整數，而兩個輸入數字的和可能超過這個范圍。

要解決這個問題，可以修改 return 語句，直接使用 echo 輸出和而不是使用 return：

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

函數參數

#!/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}來獲取參數。

Shell 輸入/輸出重定向

文件描述符 0 通常是標準輸入（STDIN），1 是標準輸出（STDOUT），2 是標準錯誤輸出（STDERR）。

>：以覆蓋的方式寫入，>>：以追加的方式寫入

輸出重定向

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

command1 > file1

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

注意任何file1內的已經存在的內容將被新內容替代。如果要將新內容添加在文件末尾，請使用>>操作符。

$ echo "菜鳥教程：www.runoob.com" > users
$ cat users
菜鳥教程：www.runoob.com

輸入重定向

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

command1 < file1

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

接著以上實例，我們需要統計 users 文件的行數,執行以下命令：

$ wc -l users?#wc:用于統計文件的行數、單詞數或字節數。-l：選項（lines），表示統計行數。
2 users?????? #2：表示文件?users中共有?2 行內容。users：被統計的文件名。

#也可以將輸入重定向到 users 文件：

$  wc -l < users
2  ????????#2：表示文件?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流中寫入錯誤信息。

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

$ command 2>file
$ command 2>>file

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

$ command > file 2>&1#或者$ command >> file 2>&1
其中 2>&1

2>?表示重定向標準錯誤（stderr，文件描述符2）。

&1?表示將標準錯誤指向標準輸出當前的位置（即?file）。

最終效果是：標準錯誤也被寫入?file，且和標準輸出混合在一起。

等效寫法

以下兩種寫法與?command > file 2>&1?完全等價：

command &> file
（Bash 等現代 Shell 支持的簡潔寫法，直接重定向所有輸出）

command >> file 2>&1
（>>?表示追加到文件末尾，而非覆蓋）

Here Document

command << delimiterdocument
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）。

這里的?2?和?>?之間不可以有空格，2>?是一體的時候才表示錯誤輸出。

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.shecho "菜鳥教程官網地址：$url"

接下來，我們為 test2.sh 添加可執行權限并執行：

$ chmod +x test2.sh 
$ ./test2.sh 
菜鳥教程官網地址：http://www.runoob.com

注：被包含的文件 test1.sh 不需要可執行權限。