[Bash Shell] Shell學習筆記

時間  2019-11-20
標籤 bash shell 學習 筆記 欄目 Unix 简体版
原文   原文鏈接

1. Shell簡介

　　Shell自己是一個用C語言編寫的程序，它是用戶使用Unix/Linux的橋樑，用戶的大部分工做都是經過Shell完成的。Shell既是一種命令語言，又是一種程序設計語言。做爲命令語言，它交互式地解釋和執行用戶輸入的命令；做爲程序設計語言，它定義了各類變量和參數，並提供了許多在高級語言中才具備的控制結構，包括循環和分支。php

　　它雖然不是Unix/Linux系統內核的一部分，但它調用了系統核心的大部分功能來執行程序、創建文件並以並行的方式協調各個程序的運行。所以，對於用戶來講，shell是最重要的實用程序，深刻了解和熟練掌握shell的特性極其使用方法，是用好Unix/Linux系統的關鍵。html

　　能夠說，shell使用的熟練程度反映了用戶對Unix/Linux使用的熟練程度。linux

　　注意：單獨地學習 Shell 是沒有意義的，請先參考Unix/Linux入門教程，瞭解 Unix/Linux 基礎。ios

　　Shell有兩種執行命令的方式：git

　　交互式（Interactive）：解釋執行用戶的命令，用戶輸入一條命令，Shell就解釋執行一條。github

　　批處理（Batch）：用戶事先寫一個Shell腳本(Script)，其中有不少條命令，讓Shell一次把這些命令執行完，而沒必要一條一條地敲命令。web

　　Shell腳本和編程語言很類似，也有變量和流程控制語句，但Shell腳本是解釋執行的，不須要編譯，Shell程序從腳本中一行一行讀取並執行這些命令，至關於一個用戶把腳本中的命令一行一行敲到Shell提示符下執行。shell

　　Shell初學者請注意，在日常應用中，建議不要用 root 賬號運行 Shell 。做爲普通用戶，無論您有意仍是無心，都沒法破壞系統；但若是是 root，那就不一樣了，只要敲幾個字母，就可能致使災難性後果。express

2. 幾種常見的Shell

　　上面提到過，Shell是一種腳本語言，那麼，就必須有解釋器來執行這些腳本。

　　Unix/Linux上常見的Shell腳本解釋器有bash、sh、csh、ksh等，習慣上把它們稱做一種Shell。咱們常說有多少種Shell，其實說的是Shell腳本解釋器。

　　bash：bash是Linux標準默認的shell，本教程也基於bash講解。bash由Brian Fox和Chet Ramey共同完成，是BourneAgain Shell的縮寫，內部命令一共有40個。編程

　　Linux使用它做爲默認的shell是由於它有諸如如下的特點：

  • 可使用相似DOS下面的doskey的功能，用方向鍵查閱和快速輸入並修改命令。

  • 自動經過查找匹配的方式給出以某字符串開頭的命令。

  • 包含了自身的幫助功能，你只要在提示符下面鍵入help就能夠獲得相關的幫助。

　　sh：sh 由Steve Bourne開發，是Bourne Shell的縮寫，sh 是Unix 標準默認的shell。

　　ash：ash shell 是由Kenneth Almquist編寫的，Linux中佔用系統資源最少的一個小shell，它只包含24個內部命令，於是使用起來很不方便。

　　csh：csh 是Linux比較大的內核，它由以William Joy爲表明的共計47位做者編成，共有52個內部命令。該shell實際上是指向/bin/tcsh這樣的一個shell，也就是說，csh其實就是tcsh。

　　ksh：ksh 是Korn shell的縮寫，由Eric Gisin編寫，共有42條內部命令。該shell最大的優勢是幾乎和商業發行版的ksh徹底兼容，這樣就能夠在不用花錢購買商業版本的狀況下嘗試商業版本的性能了。

　　注意：bash是 Bourne Again Shell 的縮寫，是linux標準的默認shell ，它基於Bourne shell，吸取了C shell和Korn shell的一些特性。bash徹底兼容sh，也就是說，用sh寫的腳本能夠不加修改的在bash中執行。

3. 編譯型語言和解釋型語言的區別 

　　大致上，能夠將程序設計語言能夠分爲兩類：編譯型語言和解釋型語言。

　　編譯型語言

　　不少傳統的程序設計語言，例如Fortran、Ada、Pascal、C、C++和Java，都是編譯型語言。這類語言須要預先將咱們寫好的源代碼(source code)轉換成目標代碼(object code)，這個過程被稱做「編譯」。
　　運行程序時，直接讀取目標代碼(object code)。因爲編譯後的目標代碼(object code)很是接近計算機底層，所以執行效率很高，這是編譯型語言的優勢。
　　可是，因爲編譯型語言多半運做於底層，所處理的是字節、整數、浮點數或是其餘機器層級的對象，每每實現一個簡單的功能須要大量複雜的代碼。例如，在C++裏，就很難進行「將一個目錄裏全部的文件複製到另外一個目錄中」之類的簡單操做。

　　解釋型語言

　　解釋型語言也被稱做「腳本語言」。執行這類程序時，解釋器(interpreter)須要讀取咱們編寫的源代碼(source code)，並將其轉換成目標代碼(object code)，再由計算機運行。由於每次執行程序都多了編譯的過程，所以效率有所降低。

　　使用腳本編程語言的好處是，它們多半運行在比編譯型語言還高的層級，可以輕易處理文件與目錄之類的對象；缺點是它們的效率一般不如編譯型語言。不過權衡之下，一般使用腳本編程仍是值得的：花一個小時寫成的簡單腳本，一樣的功能用C或C++來編寫實現，可能須要兩天，並且通常來講，腳本執行的速度已經夠快了，快到足以讓人忽略它性能上的問題。腳本編程語言的例子有awk、Perl、Python、Ruby與Shell。

4. 何時使用Shell？

　　由於Shell彷佛是各UNIX系統之間通用的功能，而且通過了POSIX的標準化。所以，Shell腳本只要「用心寫」一次，便可應用到不少系統上。所以，之因此要使用Shell腳本是基於：
  • 簡單性：Shell是一個高級語言；經過它，你能夠簡潔地表達複雜的操做。
  • 可移植性：使用POSIX所定義的功能，能夠作到腳本無須修改就可在不一樣的系統上執行。
  • 開發容易：能夠在短期內完成一個功能強大又妤用的腳本。
　　可是，考慮到Shell腳本的命令限制和效率問題，下列狀況通常不使用Shell：
  1. 資源密集型的任務，尤爲在須要考慮效率時（好比，排序，hash等等）。
  2. 須要處理大任務的數學操做，尤爲是浮點運算，精確運算，或者複雜的算術運算（這種狀況通常使用C++或FORTRAN 來處理）。
  3. 有跨平臺（操做系統）移植需求（通常使用C 或Java）。
  4. 複雜的應用，在必須使用結構化編程的時候（須要變量的類型檢查，函數原型，等等）。
  5. 對於影響系統全局性的關鍵任務應用。
  6. 對於安全有很高要求的任務，好比你須要一個健壯的系統來防止入侵、破解、惡意破壞等等。
  7. 項目由連串的依賴的各個部分組成。
  8. 須要大規模的文件操做。
  9. 須要多維數組的支持。
  10. 須要數據結構的支持，好比鏈表或數等數據結構。
  11. 須要產生或操做圖形化界面 GUI。
  12. 須要直接操做系統硬件。
  13. 須要 I/O 或socket 接口。
  14. 須要使用庫或者遺留下來的老代碼的接口。
  15. 私人的、閉源的應用（shell 腳本把代碼就放在文本文件中，全世界都能看到）。

　　若是你的應用符合上邊的任意一條，那麼就考慮一下更強大的語言吧——或許是Perl、Tcl、Python、Ruby——或者是更高層次的編譯語言好比C/C++，或者是Java。即便如此，你會發現，使用shell來原型開發你的應用，在開發步驟中也是很是有用的。

5. 第一個Shell腳本

　　打開文本編輯器，新建一個文件，擴展名爲sh（sh表明shell），擴展名並不影響腳本執行，見名知意就好，若是你用php寫shell 腳本，擴展名就用php好了。

　　輸入一些代碼： 
#!/bin/bash
echo "Hello World !"
　　「#!」 是一個約定的標記，它告訴系統這個腳本須要什麼解釋器來執行，即便用哪種Shell。echo命令用於向窗口輸出文本。
　　運行Shell腳本有兩種方法。

　　5.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告訴系統說，就在當前目錄找。
　　經過這種方式運行bash腳本，第一行必定要寫對，好讓系統查找到正確的解釋器。
　　這裏的"系統"，其實就是shell這個應用程序（想象一下Windows Explorer），但我故意寫成系統，是方便理解，既然這個系統就是指shell，那麼一個使用/bin/sh做爲解釋器的腳本是否是能夠省去第一行呢？是的。

　　5.2 做爲解釋器參數

　　這種運行方式是，直接運行解釋器，其參數就是shell腳本的文件名，如： 
/bin/sh test.sh
/bin/php test.php
　　這種方式運行的腳本，不須要在第一行指定解釋器信息，寫了也沒用。
　　再看一個例子。下面的腳本使用 read 命令從 stdin 獲取輸入並賦值給 PERSON 變量，最後在 stdout 上輸出： 
#!/bin/bash
# Author : mozhiyan
# Copyright (c) http://see.xidian.edu.cn/cpp/linux/
# Script follows here:
echo "What is your name?"
read PERSON
echo "Hello, $PERSON"
　　運行腳本： 
chmod +x ./test.sh
$./test.sh
What is your name?
mozhiyan
Hello, mozhiyan

6. Shell變量

　　Shell支持自定義變量。

　　6.1 定義變量

　　定義變量時，變量名不加美圓符號（$），如： 
variableName="value"
　　注意，變量名和等號之間不能有空格，這可能和你熟悉的全部編程語言都不同。同時，變量名的命名須遵循以下規則：
  • 首個字符必須爲字母（a-z，A-Z）。
  • 中間不能有空格，可使用下劃線（_）。
  • 不能使用標點符號。
  • 不能使用bash裏的關鍵字（可用help命令查看保留關鍵字）。
　　變量定義舉例： 
myUrl="http://see.xidian.edu.cn/cpp/linux/"
myNum=100

　　6.2 使用變量

　　使用一個定義過的變量，只要在變量名前面加美圓符號（$）便可，如： 
your_name="mozhiyan"
echo $your_name
echo ${your_name}
　　變量名外面的花括號是可選的，加不加都行，加花括號是爲了幫助解釋器識別變量的邊界，好比下面這種狀況： 
for skill in Ada Coffe Action Java
do
echo "I am good at ${skill}Script"
done
　　若是不給skill變量加花括號，寫成echo "I am good at $skillScript"，解釋器就會把$skillScript當成一個變量（其值爲空），代碼執行結果就不是咱們指望的樣子了。
推薦給全部變量加上花括號，這是個好的編程習慣。

　　6.3 從新定義變量

　　已定義的變量，能夠被從新定義，如： 
myUrl="http://see.xidian.edu.cn/cpp/linux/"
echo ${myUrl}
myUrl="http://see.xidian.edu.cn/cpp/shell/"
echo ${myUrl}
　　這樣寫是合法的，但注意，第二次賦值的時候不能寫 $myUrl="http://see.xidian.edu.cn/cpp/shell/"，使用變量的時候才加美圓符（$）。

　　6.4 只讀變量

　　使用 readonly 命令能夠將變量定義爲只讀變量，只讀變量的值不能被改變。
　　下面的例子嘗試更改只讀變量，結果報錯： 
#!/bin/bash
myUrl="http://see.xidian.edu.cn/cpp/shell/"
readonly myUrl
myUrl="http://see.xidian.edu.cn/cpp/danpianji/"
　　運行腳本，結果以下： 
/bin/sh: NAME: This variable is read only.

　　6.5 刪除變量

　　使用 unset 命令能夠刪除變量。語法： 
unset variable_name
　　變量被刪除後不能再次使用；unset 命令不能刪除只讀變量。
　　舉個例子： 
#!/bin/sh
myUrl="http://see.xidian.edu.cn/cpp/u/xitong/"
unset myUrl
echo $myUrl
　　上面的腳本沒有任何輸出。

　　6.6 變量類型

　　運行shell時，會同時存在三種變量：

　　1) 局部變量

　　局部變量在腳本或命令中定義，僅在當前shell實例中有效，其餘shell啓動的程序不能訪問局部變量。

　　2) 環境變量

　　全部的程序，包括shell啓動的程序，都能訪問環境變量，有些程序須要環境變量來保證其正常運行。必要的時候shell腳本也能夠定義環境變量。

　　3) shell變量

　　shell變量是由shell程序設置的特殊變量。shell變量中有一部分是環境變量，有一部分是局部變量，這些變量保證了shell的正常運行

7.Shell特殊變量

　　前面已經講到，變量名只能包含數字、字母和下劃線，由於某些包含其餘字符的變量有特殊含義，這樣的變量被稱爲特殊變量。
　　例如，$ 表示當前Shell進程的ID，即pid，看下面的代碼： 
$echo $$
　　運行結果:  29949

特殊變量列表
變量 含義
$0 當前腳本的文件名
$n 傳遞給腳本或函數的參數。n 是一個數字，表示第幾個參數。例如，第一個參數是$1，第二個參數是$2。
$# 傳遞給腳本或函數的參數個數。
$* 傳遞給腳本或函數的全部參數。
$@ 傳遞給腳本或函數的全部參數。被雙引號(" ")包含時，與 $* 稍有不一樣，下面將會講到。
$? 上個命令的退出狀態，或函數的返回值。
$$ 當前Shell進程ID。對於 Shell 腳本，就是這些腳本所在的進程ID。

　　命令行參數

　　運行腳本時傳遞給腳本的參數稱爲命令行參數。命令行參數用 $n 表示，例如，$1 表示第一個參數，$2 表示第二個參數，依次類推。

　　請看下面的腳本： 
#!/bin/bash
echo "File Name: $0"
echo "First Parameter : $1"
echo "First Parameter : $2"
echo "Quoted Values: $@"
echo "Quoted Values: $*"
echo "Total Number of Parameters : $#"
　　運行結果： 
$./test.sh Zara Ali
File Name : ./test.sh
First Parameter : Zara
Second Parameter : Ali
Quoted Values: Zara Ali
Quoted Values: Zara Ali
Total Number of Parameters : 2

　　$* 和 $@ 的區別

　　$* 和 $@ 都表示傳遞給函數或腳本的全部參數，不被雙引號(" ")包含時，都以"$1" "$2" … "$n" 的形式輸出全部參數。
　　可是當它們被雙引號(" ")包含時，"$*" 會將全部的參數做爲一個總體，以"$1 $2 … $n"的形式輸出全部參數；"$@" 會將各個參數分開，以"$1" "$2" … "$n" 的形式輸出全部參數。
　　下面的例子能夠清楚的看到 $* 和 $@ 的區別： 
#!/bin/bash
echo "\$*=" $*
echo "\"\$*\"=" "$*"
echo "\$@=" $@
echo "\"\$@\"=" "$@"
echo "print each param from \$*"
for var in $*
do
echo "$var"
done
echo "print each param from \$@"
for var in $@
do
echo "$var"
done
echo "print each param from \"\$*\""
for var in "$*"
do
echo "$var"
done
echo "print each param from \"\$@\""
for var in "$@"
do
echo "$var"
  1. done
　　執行 ./test.sh "a" "b" "c" "d"，看到下面的結果： 
$*=  a b c d
"$*"= a b c d
$@=  a b c d
"$@"= a b c d
print each param from $*
a
b
c
d
print each param from $@
a
b
c
d
print each param from "$*"
a b c d
print each param from "$@"
a
b
c
d

　　退出狀態

　　$? 能夠獲取上一個命令的退出狀態。所謂退出狀態，就是上一個命令執行後的返回結果。

　　退出狀態是一個數字，通常狀況下，大部分命令執行成功會返回 0，失敗返回 1。

　　不過，也有一些命令返回其餘值，表示不一樣類型的錯誤。

　　下面例子中，命令成功執行： 
 
  
 
   
$./test.sh Zara Ali
File Name : ./test.sh
First Parameter : Zara
Second Parameter : Ali
Quoted Values: Zara Ali
Quoted Values: Zara Ali
Total Number of Parameters : 2
$echo $?
0
$
 
  
 
  　　$? 也能夠表示函數的返回值，後續將會講解。 
 
 
 
8. Shell替換
 
 
 
  　　若是表達式中包含特殊字符，Shell 將會進行替換。例如，在雙引號中使用變量就是一種替換，轉義字符也是一種替換。 
  
 
  　　舉個例子： 
  
 
   
 
    
#!/bin/bash
a=10
echo -e "Value of a is $a \n"
 
   
 
  
 
  　　運行結果： 
  
 
   
Value of a is 10
 
  
 
  　　這裏 -e 表示對轉義字符進行替換。若是不使用 -e 選項，將會原樣輸出： 
  
 
   
Value of a is 10\n
 
  
 
  　　下面的轉義字符均可以用在 echo 中： 
  
 
  
 
    
    
 
     轉義字符 
     含義 
    
 
    
 
     \\ 
     反斜槓 
    
 
    
 
     \a 
     警報，響鈴 
    
 
    
 
     \b 
     退格（刪除鍵） 
    
 
    
 
     \f 
     換頁(FF)，將當前位置移到下頁開頭 
    
 
    
 
     \n 
     換行 
    
 
    
 
     \r 
     回車 
    
 
    
 
     \t 
     水平製表符（tab鍵）  
    
 
    
 
     \v 
     垂直製表符 
    
 
    
  
 
   　　可使用 echo 命令的 -E 選項禁止轉義，默認也是不轉義的；使用 -n 選項能夠禁止插入換行符。 
  
　　命令替換
 
   　　命令替換是指Shell能夠先執行命令，將輸出結果暫時保存，在適當的地方輸出。 
  
 
  　　命令替換的語法： 
 
 
 
 
  
 
   
`command`
 
  
 
  　　注意是反引號，不是單引號，這個鍵位於 Esc 鍵下方。 
  
 
  　　下面的例子中，將命令執行結果保存在變量中： 
  
 
   
 
    
#!/bin/bash
DATE=`date`
echo "Date is $DATE"
USERS=`who | wc -l`
echo "Logged in user are $USERS"
UP=`date ; uptime`
echo "Uptime is $UP"
 
   
 
  
 
  　　運行結果： 
 
 
 
 
  
 
   
Date is Thu Jul  2 03:59:57 MST 2009
Logged in user are 1
Uptime is Thu Jul  2 03:59:57 MST 2009
03:59:57 up 20 days, 14:03,  1 user,  load avg: 0.13, 0.07, 0.15
 
  
 
 
 
 
 
  
　　變量替換
 
  　　變量替換能夠根據變量的狀態（是否爲空、是否認義等）來改變它的值。 
  
 
  　　可使用的變量替換形式： 
  
 
  
 
    
    
 
     形式 
     說明 
    
 
    
 
     ${var} 
     變量原本的值 
    
 
    
 
     ${var:-word} 
     若是變量 var 爲空或已被刪除(unset)，那麼返回 word，但不改變 var 的值。 
    
 
    
 
     ${var:=word} 
     若是變量 var 爲空或已被刪除(unset)，那麼返回 word，並將 var 的值設置爲 word。 
    
 
    
 
     ${var:?message} 
     若是變量 var 爲空或已被刪除(unset)，那麼將消息 message 送到標準錯誤輸出，能夠用來檢測變量 var 是否能夠被正常賦值。
 若此替換出如今Shell腳本中，那麼腳本將中止運行。		 
    
 
    
 
     ${var:+word} 
     若是變量 var 被定義，那麼返回 word，但不改變 var 的值。 
    
 
    
  
 
  
 
  　　請看下面的例子： 
  
 
  
 
   
#!/bin/bash

echo ${var:-"Variable is not set"}
echo "1 - Value of var is ${var}"

echo ${var:="Variable is not set"}
echo "2 - Value of var is ${var}"

unset var
echo ${var:+"This is default value"}
echo "3 - Value of var is $var"

var="Prefix"
echo ${var:+"This is default value"}
echo "4 - Value of var is $var"

echo ${var:?"Print this message"}
echo "5 - Value of var is ${var}"
 
  
 
  運行結果： 
 
 
 
 
  
 
   
Variable is not set
1 - Value of var is
Variable is not set
2 - Value of var is Variable is not set
3 - Value of var is
This is default value
4 - Value of var is Prefix
Prefix
5 - Value of var is Prefix
 
  
 
 
 
 
9. Shell運算符
 
 
 
  　　Bash 支持不少運算符，包括算數運算符、關係運算符、布爾運算符、字符串運算符和文件測試運算符。 
 
 
 
 
  　　原生bash不支持簡單的數學運算，可是能夠經過其餘命令來實現，例如 awk 和 expr，expr 最經常使用。 
  
 
  　　expr 是一款表達式計算工具，使用它能完成表達式的求值操做。 
  
 
  　　例如，兩個數相加： 
  
 
   
 
    
#!/bin/bash
val=`expr 2 + 2`
echo "Total value : $val"
 
   
 
  
 
  　　運行腳本輸出： 
  
 
   
Total value : 4
 
  
 
  兩點注意： 
  
     
   
  • 表達式和運算符之間要有空格，例如 2+2 是不對的，必須寫成 2 + 2，這與咱們熟悉的大多數編程語言不同。
    •  
   
  • 完整的表達式要被 ` ` 包含，注意這個字符不是經常使用的單引號，在 Esc 鍵下邊。
    •  
  
 
  
　　9.1 算術運算符
 
  　　先來看一個使用算術運算符的例子： 
  
 
   
 
    
#!/bin/sh
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 is equal to b"
fi
if [ $a != $b ]
then
echo "a is not equal to b"
fi
 
   
 
  
 
  　　運行結果： 
  
 
   
a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a is not equal to b
 
  
 
  　　注意： 
  
     
   
  • 乘號(*)前邊必須加反斜槓(\)才能實現乘法運算；
    •  
   
  • if...then...fi 是條件語句，後續將會講解。
    •  
  
 
  
 
    
    算術運算符列表 
    
    
    
 
     運算符 
     說明 
     舉例 
    
 
    
 
     + 
     加法 
     `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 ]。 
  
　　9.2 關係運算符
 
   　　關係運算符只支持數字，不支持字符串，除非字符串的值是數字。 
  
 
  　　先來看一個關係運算符的例子： 
  
 
  
 
   
 
    
#!/bin/sh
a=10
b=20
if [ $a -eq $b ]
then
echo "$a -eq $b : a is equal to b"
else
echo "$a -eq $b: a is not equal to b"
fi
if [ $a -ne $b ]
then
echo "$a -ne $b: a is not equal to b"
else
echo "$a -ne $b : a is equal to b"
fi
if [ $a -gt $b ]
then
echo "$a -gt $b: a is greater than b"
else
echo "$a -gt $b: a is not greater than b"
fi
if [ $a -lt $b ]
then
echo "$a -lt $b: a is less than b"
else
echo "$a -lt $b: a is not less than b"
fi
if [ $a -ge $b ]
then
echo "$a -ge $b: a is greater or equal to b"
else
echo "$a -ge $b: a is not greater or equal to b"
fi
if [ $a -le $b ]
then
echo "$a -le $b: a is less or equal to b"
else
echo "$a -le $b: a is not less or equal to b"
fi
 
   
 
  
 
  運行結果： 
  
 
   
10 -eq 20: a is not equal to b
10 -ne 20: a is not equal to b
10 -gt 20: a is not greater than b
10 -lt 20: a is less than b
10 -ge 20: a is not greater or equal to b
10 -le 20: a is less or  equal to b
 
  
 
  
 
    
    關係運算符列表 
    
    
    
 
     運算符 
     說明 
     舉例 
    
 
    
 
     -eq 
     檢測兩個數是否相等，相等返回 true。 
     [ $a -eq $b ] 返回 true。 
    
 
    
 
     -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。 
    
 
    
  
 
  
　　9.3 布爾運算符
 
   　　先來看一個布爾運算符的例子： 
  
 
   
 
    
#!/bin/sh
a=10
b=20
if [ $a != $b ]
then
echo "$a != $b : a is not equal to b"
else
echo "$a != $b: a is equal to b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
echo "$a -lt 100 -a $b -gt 15 : returns true"
else
echo "$a -lt 100 -a $b -gt 15 : returns false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
echo "$a -lt 100 -o $b -gt 100 : returns true"
else
echo "$a -lt 100 -o $b -gt 100 : returns false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
echo "$a -lt 100 -o $b -gt 100 : returns true"
else
echo "$a -lt 100 -o $b -gt 100 : returns false"
fi
 
   
 
  
 
  　　運行結果： 
  
 
   
10 != 20 : a is not equal to b
10 -lt 100 -a 20 -gt 15 : returns true
10 -lt 100 -o 20 -gt 100 : returns true
10 -lt 5 -o 20 -gt 100 : returns false
 
  
 
  
 
    
    布爾運算符列表 
    
    
    
 
     運算符 
     說明 
     舉例 
    
 
    
 
     ! 
     非運算，表達式爲 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。 
    
 
    
  
 
  
　　9.4 字符串運算符
 
   　　先來看一個例子： 
  
 
   
 
    
#!/bin/sh
a="abc"
b="efg"
if [ $a = $b ]
then
echo "$a = $b : a is equal to b"
else
echo "$a = $b: a is not equal to b"
fi
if [ $a != $b ]
then
echo "$a != $b : a is not equal to b"
else
echo "$a != $b: a is equal to b"
fi
if [ -z $a ]
then
echo "-z $a : string length is zero"
else
echo "-z $a : string length is not zero"
fi
if [ -n $a ]
then
echo "-n $a : string length is not zero"
else
echo "-n $a : string length is zero"
fi
if [ $a ]
then
echo "$a : string is not empty"
else
echo "$a : string is empty"
fi
 
   
 
  
 
  　　運行結果： 
  
 
   
abc = efg: a is not equal to b
abc != efg : a is not equal to b
-z abc : string length is not zero
-n abc : string length is not zero
abc : string is not empty
 
  
 
  
 
    
    字符串運算符列表 
    
    
    
 
     運算符 
     說明 
     舉例 
    
 
    
 
     = 
     檢測兩個字符串是否相等，相等返回 true。 
     [ $a = $b ] 返回 false。 
    
 
    
 
     != 
     檢測兩個字符串是否相等，不相等返回 true。 
     [ $a != $b ] 返回 true。 
    
 
    
 
     -z 
     檢測字符串長度是否爲0，爲0返回 true。 
     [ -z $a ] 返回 false。 
    
 
    
 
     -n 
     檢測字符串長度是否爲0，不爲0返回 true。 
     [ -z $a ] 返回 true。 
    
 
    
 
     str 
     檢測字符串是否爲空，不爲空返回 true。 
     [ $a ] 返回 true。 
    
 
    
  
 
  
　　9.5 文件測試運算符
 
   　　文件測試運算符用於檢測 Unix 文件的各類屬性。 
  
 
  　　例如，變量 file 表示文件「/var/www/tutorialspoint/unix/test.sh」，它的大小爲100字節，具備 rwx 權限。下面的代碼，將檢測該文件的各類屬性： 
  
 
   
 
    
#!/bin/sh
file="/var/www/tutorialspoint/unix/test.sh"
if [ -r $file ]
then
echo "File has read access"
else
echo "File does not have read access"
fi
if [ -w $file ]
then
echo "File has write permission"
else
echo "File does not have write permission"
fi
if [ -x $file ]
then
echo "File has execute permission"
else
echo "File does not have execute permission"
fi
if [ -f $file ]
then
echo "File is an ordinary file"
else
echo "This is sepcial file"
fi
if [ -d $file ]
then
echo "File is a directory"
else
echo "This is not a directory"
fi
if [ -s $file ]
then
echo "File size is zero"
else
echo "File size is not zero"
fi
if [ -e $file ]
then
echo "File exists"
else
echo "File does not exist"
fi
 
   
 
  
 
  　　運行結果： 
  
 
   
File has read access
File has write permission
File has execute permission
File is an ordinary file
This is not a directory
File size is zero
File exists
 
  
 
  
 
    
    文件測試運算符列表 
    
    
    
 
     操做符 
     說明 
     舉例 
    
 
    
 
     -b file 
     檢測文件是不是塊設備文件，若是是，則返回 true。 
     [ -b $file ] 返回 false。 
    
 
    
 
     -c file 
     檢測文件是不是字符設備文件，若是是，則返回 true。 
     [ -b $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。 
    
 
    
  
 
 
 
 
 
    
 
 
 
 
  
10. Shell註釋
 
 
 
 
 
  　　以「#」開頭的行就是註釋，會被解釋器忽略。 
 
 
 
 
  　　sh裏沒有多行註釋，只能每一行加一個#號。只能像這樣： 
  
 
   
 
    
#--------------------------------------------
# 這是一個自動打ipa的腳本，基於webfrogs的ipa-build書寫：
# https://github.com/webfrogs/xcode_shell/blob/master/ipa-build
# 功能：自動爲etao ios app打包，產出物爲14個渠道的ipa包
# 特點：全自動打包，不須要輸入任何參數
#--------------------------------------------
##### 用戶配置區 開始 #####
#
#
# 項目根目錄，推薦將此腳本放在項目的根目錄，這裏就不用改了
# 應用名，確保和Xcode裏Product下的target_name.app名字一致
#
##### 用戶配置區 結束 #####
 
   
 
  
 
  　　若是在開發過程當中，遇到大段的代碼須要臨時註釋起來，過一下子又取消註釋，怎麼辦呢？每一行加個#符號太費力了，能夠把這一段要註釋的代碼用一對花括號括起來，定義成一個函數，沒有地方調用這個函數，這塊代碼就不會執行，達到了和註釋同樣的效果。 
 
 
 
11. Shell字符串
 
 
 
  　　 
  字符串是shell編程中最經常使用最有用的數據類型（除了數字和字符串，也沒啥其它類型好用了），字符串能夠用單引號，也能夠用雙引號，也能夠不用引號。單雙引號的區別跟PHP相似。 
 
 
 
 
  
　　11.1 單引號
 
  
 
   
 
    
str='this is a string'
 
   
 
  
 
  　　單引號字符串的限制： 
  
     
   
  • 單引號裏的任何字符都會原樣輸出，單引號字符串中的變量是無效的；
    •  
   
  • 單引號字串中不能出現單引號（對單引號使用轉義符後也不行）。
    •  
  
 
  
　　11.2 雙引號
 
  
 
   
 
    
your_name='qinjx'
str="Hello, I know your are \"$your_name\"! \n"
 
   
 
  
 
  　　雙引號的優勢： 
  
     
   
  • 雙引號裏能夠有變量
    •  
   
  • 雙引號裏能夠出現轉義字符
    •  
  
 
  
　　11.3 拼接字符串
 
  
 
   
 
    
your_name="qinjx"
greeting="hello, "$your_name" !"
greeting_1="hello, ${your_name} !"
echo $greeting $greeting_1
 
   
 
  
 
  
　　11.4 獲取字符串長度
 
  
 
 
  
 
   
string="abcd"
echo ${#string} #輸出 4
 
  
 
  
　　11.5 提取子字符串
 
  
 
   
 
    
string="alibaba is a great company"
echo ${string:1:4} #輸出liba
 
   
 
  
 
  
　　11.6 查找子字符串
 
  
 
   
 
    
string="alibaba is a great company"
echo `expr index "$string" is`
 
   
 
  
 
 
 
 
12. Shell數組
 
 
 
  　　Shell在編程方面比Windows批處理強大不少，不管是在循環、運算。 
 
 
 
 
  
 
  　　bash支持一維數組（不支持多維數組），而且沒有限定數組的大小。相似與C語言，數組元素的下標由0開始編號。獲取數組中的元素要利用下標，下標能夠是整數或算術表達式，其值應大於或等於0。 
  
　　12.1 定義數組
 
   　　在Shell中，用括號來表示數組，數組元素用「空格」符號分割開。定義數組的通常形式爲： 
  
 
  　　array_name=(value1 ... valuen) 
  
 
  　　例如： 
 
 
 
 
  
 
   
array_name=(value0 value1 value2 value3)
 
  
 
  或者 
  
 
   
 
    
array_name=(
value0
value1
value2
value3
)
 
   
 
  
 
  　　還能夠單獨定義數組的各個份量： 
  
 
   
 
    
array_name[0]=value0
array_name[1]=value1
array_name[2]=value2
 
   
 
  
 
  　　能夠不使用連續的下標，並且下標的範圍沒有限制。 
  
　　12.2 讀取數組
 
  　　讀取數組元素值的通常格式是： 
  
 
  　　${array_name[index]} 
  
 
  　　例如： 
  
 
   
 
    
valuen=${array_name[2]}
 
   
 
  
 
  　　舉個例子： 
  
 
   
 
    
#!/bin/sh
NAME[0]="Zara"
NAME[1]="Qadir"
NAME[2]="Mahnaz"
NAME[3]="Ayan"
NAME[4]="Daisy"
echo "First Index: ${NAME[0]}"
echo "Second Index: ${NAME[1]}"
 
   
 
  
 
  　　運行腳本，輸出： 
  
 
  
 
   
$./test.sh
First Index: Zara
Second Index: Qadir
 
  
 
  　　使用@ 或 * 能夠獲取數組中的全部元素，例如： 
  
 
   
 
    
${array_name[*]}
${array_name[@]}
 
   
 
  
 
  　　舉個例子： 
  
 
   
 
    
#!/bin/sh
NAME[0]="Zara"
NAME[1]="Qadir"
NAME[2]="Mahnaz"
NAME[3]="Ayan"
NAME[4]="Daisy"
echo "First Method: ${NAME[*]}"
echo "Second Method: ${NAME[@]}"
 
   
 
  
 
  　　運行腳本，輸出： 
  
 
  
 
   
$./test.sh
First Method: Zara Qadir Mahnaz Ayan Daisy
Second Method: Zara Qadir Mahnaz Ayan Daisy
 
  
 
  
　　12.3 獲取數組的長度
 
  　　獲取數組長度的方法與獲取字符串長度的方法相同，例如： 
  
 
   
 
    
# 取得數組元素的個數
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得數組單個元素的長度
lengthn=${#array_name[n]}
 
   
 
  
 
 
 
 
13. echo命令
 
 
 
  　　echo是Shell的一個內部指令，用於在屏幕上打印出指定的字符串。命令格式： 
 
 
 
 
  
 
   
 
    
echo arg
 
   
 
  
 
  　　您可使用echo實現更復雜的輸出格式控制。 
  
　　13.1 顯示轉義字符
 
  
 
   
echo "\"It is a test\""
 
  
 
  　　結果將是： 
 
 
 
 
  
 
   
"It is a test"
 
  
 
  　　雙引號也能夠省略。 
  
　　13.2 顯示變量
 
  
 
   
 
    
name="OK"
echo "$name It is a test"
 
   
 
  
 
  　　結果將是： 
  
 
  
 
   
OK It is a test
 
  
 
  　　一樣雙引號也能夠省略。 
  
 
  　　若是變量與其它字符相連的話，須要使用大括號（{ }）： 
  
 
   
 
    
mouth=8
echo "${mouth}-1-2009"
 
   
 
  
 
  　　結果將是： 
  
 
  
 
   
8-1-2009
 
  
 
  
　　13.3 顯示換行
 
  
 
   
 
    
echo "OK!\n"
echo "It is a test"
 
   
 
  
 
  　　輸出： 
  
 
  
 
   
OK!
It is a test
 
  
 
  
　　13.4 顯示不換行
 
  
 
   
 
    
echo "OK!\c"
echo "It is a test"
 
   
 
  
 
  　　輸出： 
  
 
  
 
   
OK!It si a test
 
  
 
  
　　13.5 顯示結果重定向至文件
 
  
 
   
echo "It is a test" > myfile
 
  
 
  
　　13.6 原樣輸出字符串
 
  　　若須要原樣輸出字符串（不進行轉義），請使用單引號。例如： 
 
 
 
 
  
 
   
echo '$name\"'
 
  
 
  
　　13.7 顯示命令執行結果
 
  
 
   
 
    
echo `date`
 
   
 
  
 
  　　結果將顯示當前日期 
  
 
  　　從上面可看出，雙引號無關緊要，單引號主要用在原樣輸出中。 
 
 
 
14. printf命令 
 
 
 
  　　 
  printf 命令用於格式化輸出， 是echo命令的加強版。它是C語言printf()庫函數的一個有限的變形，而且在語法上有些不一樣。 
 
 
 
 
  　　注意：printf 由 POSIX 標準所定義，移植性要比 echo 好。 
  
 
  　　如同 echo 命令，printf 命令也能夠輸出簡單的字符串： 
  
 
   
 
    
$printf "Hello, Shell\n"
Hello, Shell
$
 
   
 
  
 
  　　printf 不像 echo 那樣會自動換行，必須顯式添加換行符(\n)。 
  
 
  　　printf 命令的語法： 
  
 
   
printf  format-string  [arguments...]
 
  
 
  　　format-string 爲格式控制字符串，arguments 爲參數列表。 
  
 
  　　printf()在C語言入門教程中已經講到，功能和用法與 printf 命令相似，請查看：C語言格式輸出函數printf()詳解 
  
 
  　　這裏僅說明與C語言printf()函數的不一樣： 
  
     
   
  • printf 命令不用加括號
    •  
   
  • format-string 能夠沒有引號，但最好加上，單引號雙引號都可。
    •  
   
  • 參數多於格式控制符(%)時，format-string 能夠重用，能夠將全部參數都轉換。
    •  
   
  • arguments 使用空格分隔，不用逗號。
    •  
  
 
  　　請看下面的例子： 
  
 
   
 
    
# format-string爲雙引號
$ printf "%d %s\n" 1 "abc"
1 abc
# 單引號與雙引號效果同樣
$ printf '%d %s\n' 1 "abc"
1 abc
# 沒有引號也能夠輸出
$ printf %s abcdef
abcdef
# 格式只指定了一個參數，但多出的參數仍然會按照該格式輸出，format-string 被重用
$ printf %s abc def
abcdef
$ printf "%s\n" abc def
abc
def
$ printf "%s %s %s\n" a b c d e f g h i j
a b c
d e f
g h i
j
# 若是沒有 arguments，那麼 %s 用NULL代替，%d 用 0 代替
$ printf "%s and %d \n"
and 0
# 若是以 %d 的格式來顯示字符串，那麼會有警告，提示無效的數字，此時默認置爲 0
$ printf "The first program always prints'%s,%d\n'" Hello Shell
-bash: printf: Shell: invalid number
The first program always prints 'Hello,0'
$
 
   
 
  
 
  　　注意，根據POSIX標準，浮點格式%e、%E、%f、%g與%G是「不須要被支持」。這是由於awk支持浮點預算，且有它本身的printf語句。這樣Shell程序中須要將浮點數值進行格式化的打印時，可以使用小型的awk程序實現。然而，內建於bash、ksh93和zsh中的printf命令都支持浮點格式。 
 
 
 
15. if...else語句
 
 
 
  　　 
  if 語句經過關係運算符判斷表達式的真假來決定執行哪一個分支。Shell 有三種 if ... else 語句： 
 
 
 
 
  
     
   
  • if ... fi 語句；
    •  
  
 
  
     
   
  • if ... else ... fi 語句；
    •  
  
 
  
     
   
  • if ... elif ... else ... fi 語句。
    •  
  
 
  
　　1) if ... else 語句
 
   　　if ... else 語句的語法： 
  
if [ expression ]
then
   Statement(s) to be executed if expression is true
fi

 
  　　若是 expression 返回 true，then 後邊的語句將會被執行；若是返回 false，不會執行任何語句。 
  
 
  　　最後必須以 fi 來結尾閉合 if，fi 就是 if 倒過來拼寫，後面也會碰見。 
  
 
  　　注意：expression 和方括號([ ])之間必須有空格，不然會有語法錯誤。 
  
 
  　　舉個例子： 
  
 
   
 
    
#!/bin/sh
a=10
b=20
if [ $a == $b ]
then
echo "a is equal to b"
fi
if [ $a != $b ]
then
echo "a is not equal to b"
fi
 
   
 
  
 
  　　運行結果： 
  
 
  
 
   
a is not equal to b
 
  
 
  
　　2) if ... else ... fi 語句
 
  　　if ... else ... fi 語句的語法： 
  
if [ expression ]
then
   Statement(s) to be executed if expression is true
else
   Statement(s) to be executed if expression is not true
fi

 
  　　若是 expression 返回 true，那麼 then 後邊的語句將會被執行；不然，執行 else 後邊的語句。 
  
 
  　　舉個例子： 
  
 
   
 
    
#!/bin/sh
a=10
b=20
if [ $a == $b ]
then
echo "a is equal to b"
else
echo "a is not equal to b"
fi
 
   
 
  
 
  　　執行結果： 
  
 
   
a is not equal to b
 
  
 
  
　　3) if ... elif ... fi 語句
 
  　　if ... elif ... fi 語句能夠對多個條件進行判斷，語法爲： 
  
if [ expression 1 ]
then
   Statement(s) to be executed if expression 1 is true
elif [ expression 2 ]
then
   Statement(s) to be executed if expression 2 is true
elif [ expression 3 ]
then
   Statement(s) to be executed if expression 3 is true
else
   Statement(s) to be executed if no expression is true
fi

 
  　　哪個 expression 的值爲 true，就執行哪一個 expression 後面的語句；若是都爲 false，那麼不執行任何語句。 
  
 
  　　舉個例子： 
  
 
   
 
    
#!/bin/sh
a=10
b=20
if [ $a == $b ]
then
echo "a is equal to b"
elif [ $a -gt $b ]
then
echo "a is greater than b"
elif [ $a -lt $b ]
then
echo "a is less than b"
else
echo "None of the condition met"
fi
 
   
 
  
 
  　　運行結果： 
  
a is less than b
 
  　　if ... else 語句也能夠寫成一行，以命令的方式來運行，像這樣： 
  
 
   
 
    
if test $[2*3] -eq $[1+5]; then echo 'The two numbers are equal!'; fi;
 
   
 
  
 
  　　if ... else 語句也常常與 test 命令結合使用，以下所示： 
  
 
   
 
    
num1=$[2*3]
num2=$[1+5]
if test $[num1] -eq $[num2]
then
echo 'The two numbers are equal!'
else
echo 'The two numbers are not equal!'
fi
 
   
 
  
 
  　　輸出： 
  
 
  
 
   
The two numbers are equal!
 
  
 
  　　test 命令用於檢查某個條件是否成立，與方括號([ ])相似。 
 
 
 
16. case esac命令
 
 
 
  　　case ... esac 與其餘語言中的 switch ... case 語句相似，是一種多分枝選擇結構。 
  
 
  　　case 語句匹配一個值或一個模式，若是匹配成功，執行相匹配的命令。case語句格式以下： 
 
 
 
 
  　　 
  case 值 in 
  
模式1)
    command1
    command2
    command3
    ;;
模式2）
    command1
    command2
    command3
    ;;
*)
    command1
    command2
    command3
    ;;
esac

 
  　　case工做方式如上所示。取值後面必須爲關鍵字 in，每一模式必須以右括號結束。取值能夠爲變量或常數。匹配發現取值符合某一模式後，其間全部命令開始執行直至 ;;。;; 與其餘語言中的 break 相似，意思是跳到整個 case 語句的最後。 
  
 
  　　取值將檢測匹配的每個模式。一旦模式匹配，則執行完匹配模式相應命令後再也不繼續其餘模式。若是無一匹配模式，使用星號 * 捕獲該值，再執行後面的命令。 
  
 
  　　下面的腳本提示輸入1到4，與每一種模式進行匹配： 
  
 
   
 
    
echo 'Input a number between 1 to 4'
echo 'Your number is:\c'
read aNum
case $aNum in
1) echo 'You select 1'
;;
2) echo 'You select 2'
;;
3) echo 'You select 3'
;;
4) echo 'You select 4'
;;
*) echo 'You do not select a number between 1 to 4'
;;
esac
 
   
 
  
 
  　　輸入不一樣的內容，會有不一樣的結果，例如：
 
  
 
   
Input a number between 1 to 4
Your number is:3
You select 3
 
  
 
  　　再舉一個例子： 
  
 
   
 
    
#!/bin/bash
option="${1}"
case ${option} in
-f) FILE="${2}"
echo "File name is $FILE"
;;
-d) DIR="${2}"
echo "Dir name is $DIR"
;;
*)
echo "`basename ${0}`:usage: [-f file] | [-d directory]"
exit 1 # Command to come out of the program with status 1
;;
esac
 
   
 
  
 
  　　運行結果： 
  
 
   
$./test.sh
test.sh: usage: [ -f filename ] | [ -d directory ]
$ ./test.sh -f index.htm
$ vi test.sh
$ ./test.sh -f index.htm
File name is index.htm
$ ./test.sh -d unix
Dir name is unix
$
 
  
 
 
 
 
17. for循環 
 
 
 
  　　 
  與其餘編程語言相似，Shell支持for循環。 
 
 
 
 
  
 
  　　for循環通常格式爲： 
  
for 變量 in 列表
do
    command1
    command2
    ...
    commandN
done

 
  　　列表是一組值（數字、字符串等）組成的序列，每一個值經過空格分隔。每循環一次，就將列表中的下一個值賦給變量。 
  
 
  　　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
 
  
 
  　　顯示主目錄下以 .bash 開頭的文件： 
  
 
   
 
    
#!/bin/bash
for FILE in $HOME/.bash*
do
echo $FILE
done
 
   
 
  
 
  　　運行結果： 
  
 
   
/root/.bash_history
/root/.bash_logout
/root/.bash_profile
/root/.bashrc
 
  
 
 
 
 
18. while循環
 
 
 
  　　 
  while循環用於不斷執行一系列命令，也用於從輸入文件中讀取數據；命令一般爲測試條件。其格式爲： 
 
 
 
 
  
while command
do
   Statement(s) to be executed if command is true
done

 
  　　命令執行完畢，控制返回循環頂部，從頭開始直至測試條件爲假。 
  
 
  　　如下是一個基本的while循環，測試條件是：若是COUNTER小於5，那麼返回 true。COUNTER從0開始，每次循環處理時，COUNTER加1。運行上述腳本，返回數字1到5，而後終止。 
  
 
   
 
    
COUNTER=0
while [ $COUNTER -lt 5 ]
do
COUNTER='expr $COUNTER+1'
echo $COUNTER
done
 
   
 
  
 
  運行腳本，輸出： 
  
 
  
 
   
1
2
3
4
5
 
  
 
  　　while循環可用於讀取鍵盤信息。下面的例子中，輸入信息被設置爲變量FILM，按<Ctrl-D>結束循環。 
  
 
   
 
    
echo 'type <CTRL-D> to terminate'
echo -n 'enter your most liked film: '
while read FILM
do
echo "Yeah! great film the $FILM"
done
 
   
 
  
 
  運行腳本，輸出相似下面： 
  
 
   
type <CTRL-D> to terminate
enter your most liked film: Sound of Music
Yeah! great film the Sound of Music
 
  
 
 
 
 
19. until命令 
 
 
 
  　　until 循環執行一系列命令直至條件爲 true 時中止。until 循環與 while 循環在處理方式上恰好相反。通常while循環優於until循環，但在某些時候，也只是極少數狀況下，until 循環更加有用。 
  
 
  　　until 循環格式爲： 
  
until command
do
   Statement(s) to be executed until command is true
done

 
  　　command 通常爲條件表達式，若是返回值爲 false，則繼續執行循環體內的語句，不然跳出循環。 
  
 
  　　例如，使用 until 命令輸出 0 ~ 9 的數字： 
 
 
 
 
  
 
   
#!/bin/bash
a=0
until [ ! $a -lt 10 ]
do
echo $a
a=`expr $a + 1`
done
 
  
 
  　　運行結果： 
  
 
   
0
1
2
3
4
5
6
7
8
9
 
  
 
 
 
 
20. 跳出循環
 
 
 
  　　在循環過程當中，有時候須要在未達到循環結束條件時強制跳出循環，像大多數編程語言同樣，Shell也使用 break 和 continue 來跳出循環。 
 
 
 
 
  
　　20.1 break命令
 
  　　break命令容許跳出全部循環（終止執行後面的全部循環）。 
  
 
  
 
  　　下面的例子中，腳本進入死循環直至用戶輸入數字大於5。要跳出這個循環，返回到shell提示符下，就要使用break命令。 
  
 
   
 
    
#!/bin/bash
while :
do
echo -n "Input a number between 1 to 5: "
read aNum
case $aNum in
1|2|3|4|5) echo "Your number is $aNum!"
;;
*) echo "You do not select a number between 1 to 5, game is over!"
break
;;
esac
done
 
   
 
  
 
  　　在嵌套循環中，break 命令後面還能夠跟一個整數，表示跳出第幾層循環。例如： 
  
 
   
 
    
break n
 
   
 
  
 
  　　表示跳出第 n 層循環。 
  
 
  　　下面是一個嵌套循環的例子，若是 var1 等於 2，而且 var2 等於 0，就跳出循環： 
  
 
   
 
    
#!/bin/bash
for var1 in 1 2 3
do
for var2 in 0 5
do
if [ $var1 -eq 2 -a $var2 -eq 0 ]
then
break 2
else
echo "$var1 $var2"
fi
done
done
 
   
 
  
 
  如上，break 2 表示直接跳出外層循環。運行結果： 
  
 
   
1 0
1 5
 
  
 
  
　　20.2 continue命令
 
  　　continue命令與break命令相似，只有一點差異，它不會跳出全部循環，僅僅跳出當前循環。 
  
 
  　　對上面的例子進行修改： 
  
 
   
 
    
#!/bin/bash
while :
do
echo -n "Input a number between 1 to 5: "
read aNum
case $aNum in
1|2|3|4|5) echo "Your number is $aNum!"
;;
*) echo "You do not select a number between 1 to 5!"
continue
echo "Game is over!"
;;
esac
done
 
   
 
  
 
  　　運行代碼發現，當輸入大於5的數字時，該例中的循環不會結束，語句 
  
 
   
 
    
echo "Game is over!"
 
   
 
  
 
  　　永遠不會被執行。 
  
 
  　　一樣，continue 後面也能夠跟一個數字，表示跳出第幾層循環。 
  
 
  　　再看一個 continue 的例子： 
  
 
   
 
    
#!/bin/bash
NUMS="1 2 3 4 5 6 7"
for NUM in $NUMS
do
Q=`expr $NUM % 2`
if [ $Q -eq 0 ]
then
echo "Number is an even number!!"
continue
fi
echo "Found odd number"
done
 
   
 
  
 
  　　運行結果： 
  
 
   
Found odd number
Number is an even number!!
Found odd number
Number is an even number!!
Found odd number
Number is an even number!!
Found odd number
 
  
 
 
 
 
21. Shell函數
 
 
 
  　　函數可讓咱們將一個複雜功能劃分紅若干模塊，讓程序結構更加清晰，代碼重複利用率更高。像其餘編程語言同樣，Shell 也支持函數。Shell 函數必須先定義後使用。 
 
 
 
 
  　　Shell 函數的定義格式以下： 
  
function_name () {
    list of commands
    [ return value ]
}

 
  　　若是你願意，也能夠在函數名前加上關鍵字 function： 
  
function function_name () {
    list of commands
    [ return value ]
}

 
  　　函數返回值，能夠顯式增長return語句；若是不加，會將最後一條命令運行結果做爲返回值。 
  
 
  　　Shell 函數返回值只能是整數，通常用來表示函數執行成功與否，0表示成功，其餘值表示失敗。若是 return 其餘數據，好比一個字符串，每每會獲得錯誤提示：「numeric argument required」。 
  
 
  　　若是必定要讓函數返回字符串，那麼能夠先定義一個變量，用來接收函數的計算結果，腳本在須要的時候訪問這個變量來得到函數返回值。= 
  
 
  　　先來看一個例子： 
  
 
   
 
    
#!/bin/bash
# Define your function here
Hello () {
echo "Url is http://see.xidian.edu.cn/cpp/shell/"
}
# Invoke your function
Hello
 
   
 
  
 
  　　運行結果： 
 
 
 
 
  
 
   
$./test.sh
Hello World
$
 
  
 
  　　調用函數只須要給出函數名，不須要加括號。 
  
 
  　　再來看一個帶有return語句的函數： 
  
 
   
 
    
#!/bin/bash
funWithReturn(){
echo "The function is to get the sum of two numbers..."
echo -n "Input first number: "
read aNum
echo -n "Input another number: "
read anotherNum
echo "The two numbers are $aNum and $anotherNum !"
return $(($aNum+$anotherNum))
}
funWithReturn
# Capture value returnd by last command
ret=$?
echo "The sum of two numbers is $ret !"
 
   
 
  
 
  　　運行結果： 
  
 
   
The function is to get the sum of two numbers...
Input first number: 25
Input another number: 50
The two numbers are 25 and 50 !
The sum of two numbers is 75 !
 
  
 
  　　函數返回值在調用該函數後經過 $? 來得到。 
  
 
  　　再來看一個函數嵌套的例子： 
  
 
   
 
    
#!/bin/bash
# Calling one function from another
number_one () {
echo "Url_1 is http://see.xidian.edu.cn/cpp/shell/"
number_two
}
number_two () {
echo "Url_2 is http://see.xidian.edu.cn/cpp/u/xitong/"
}
number_one
 
   
 
  
 
  　　運行結果： 
  
 
   
Url_1 is http://see.xidian.edu.cn/cpp/shell/
Url_2 is http://see.xidian.edu.cn/cpp/u/xitong/
 
  
 
  　　像刪除變量同樣，刪除函數也可使用 unset 命令，不過要加上 .f 選項，以下所示： 
  
 
   
 
    
$unset .f function_name
 
   
 
  
 
  　　若是你但願直接從終端調用函數，能夠將函數定義在主目錄下的 .profile 文件，這樣每次登陸後，在命令提示符後面輸入函數名字就能夠當即調用。 
 
 
 
22. Shell函數參數 
 
 
 
  　　 
  在Shell中，調用函數時能夠向其傳遞參數。在函數體內部，經過 $n 的形式來獲取參數的值，例如，$1表示第一個參數，$2表示第二個參數... 
 
 
 
 
  　　帶參數的函數示例： 
  
 
   
 
    
#!/bin/bash
funWithParam(){
echo "The value of the first parameter is $1 !"
echo "The value of the second parameter is $2 !"
echo "The value of the tenth parameter is $10 !"
echo "The value of the tenth parameter is ${10} !"
echo "The value of the eleventh parameter is ${11} !"
echo "The amount of the parameters is $# !" # 參數個數
echo "The string of the parameters is $* !" # 傳遞給函數的全部參數
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73
 
   
 
  
 
  　　運行腳本： 
  
 
   
The value of the first parameter is 1 !
The value of the second parameter is 2 !
The value of the tenth parameter is 10 !
The value of the tenth parameter is 34 !
The value of the eleventh parameter is 73 !
The amount of the parameters is 12 !
The string of the parameters is 1 2 3 4 5 6 7 8 9 34 73 !"
 
  
 
  　　注意，$10 不能獲取第十個參數，獲取第十個參數須要${10}。當n>=10時，須要使用${n}來獲取參數。 
  
 
  　　另外，還有幾個特殊變量用來處理參數，前面已經提到： 
  
 
  
 
    
    
 
     特殊變量 
     說明 
    
 
    
 
     $# 
     傳遞給函數的參數個數。 
    
 
    
 
     $* 
     顯示全部傳遞給函數的參數。 
    
 
    
 
     $@ 
     與$*相同，可是略有區別，請查看Shell特殊變量。 
    
 
    
 
     $? 
     函數的返回值。 
    
 
    
  
 
 
 
 
23. 輸入輸出重定向
 
 
 
  　　Unix 命令默認從標準輸入設備(stdin)獲取輸入，將結果輸出到標準輸出設備(stdout)顯示。通常狀況下，標準輸入設備就是鍵盤，標準輸出設備就是終端，即顯示器。 
 
 
 
 
  
　　23.1 輸出重定向
 
   　　命令的輸出不只能夠是顯示器，還能夠很容易的轉移向到文件，這被稱爲輸出重定向。 
  
 
  　　命令輸出重定向的語法爲： 
  
 
   
 
    
$ command > file
 
   
 
  
 
  　　這樣，輸出到顯示器的內容就能夠被重定向到文件。 
  
 
  　　例如，下面的命令在顯示器上不會看到任何輸出： 
  
 
   
 
    
$ who > users
 
   
 
  
 
  　　打開 users 文件，能夠看到下面的內容： 
  
 
   
$ cat users
oko         tty01   Sep 12 07:30
ai          tty15   Sep 12 13:32
ruth        tty21   Sep 12 10:10
pat         tty24   Sep 12 13:07
steve       tty25   Sep 12 13:03
$
 
  
 
  　　輸出重定向會覆蓋文件內容，請看下面的例子： 
  
 
   
$ echo line 1 > users
$ cat users
line 1
$
 
  
 
  　　若是不但願文件內容被覆蓋，可使用 >> 追加到文件末尾，例如： 
  
 
   
$ echo line 2 >> users
$ cat users
line 1
line 2
$
 
  
 
  
　　23.2 輸入重定向
 
  　　和輸出重定向同樣，Unix 命令也能夠從文件獲取輸入，語法爲： 
  
 
   
 
    
command < file
 
   
 
  
 
  　　這樣，原本須要從鍵盤獲取輸入的命令會轉移到文件讀取內容。 
  
 
  　　注意：輸出重定向是大於號(>)，輸入重定向是小於號(<)。 
  
 
  　　例如，計算 users 文件中的行數，可使用下面的命令： 
  
 
   
$ wc -l users
2 users
$
 
  
 
  　　也能夠將輸入重定向到 users 文件： 
  
 
   
$ wc -l < users
2
$
 
  
 
  注意：上面兩個例子的結果不一樣：第一個例子，會輸出文件名；第二個不會，由於它僅僅知道從標準輸入讀取內容。 
  
　　23.3 重定向深刻講解
 
  　　通常狀況下，每一個 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。  
  
 
  
 
    
    所有可用的重定向命令列表 
    
    
    
 
     命令 
     說明 
    
 
    
 
     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 之間的內容做爲輸入。 
    
 
    
  
 
  
　　Here Document
 
   　　Here Document 目前沒有統一的翻譯，這裏暫譯爲」嵌入文檔「。Here Document 是 Shell 中的一種特殊的重定向方式，它的基本的形式以下： 
  
 
   
 
    
     
     
  1. command << delimiter
    2.  
     
  2. document
    3.  
     
  3. delimiter
    4.  
    
 
   
 
  
 
  　　它的做用是將兩個 delimiter 之間的內容(document) 做爲輸入傳遞給 command。 
  
 
  　　注意： 
  
     
   
  • 結尾的delimiter 必定要頂格寫，前面不能有任何字符，後面也不能有任何字符，包括空格和 tab 縮進。
    •  
   
  • 開始的delimiter先後的空格會被忽略掉。
    •  
  
 
  　　下面的例子，經過 wc -l 命令計算 document 的行數： 
  
 
   
$wc -l << EOF
    This is a simple lookup program
    for good (and bad) restaurants
    in Cape Town.
EOF
3
$
 
  
 
  　　也能夠 將 Here Document 用在腳本中，例如： 
  
 
   
 
    
#!/bin/bash
cat << EOF
This is a simple lookup program
for good (and bad) restaurants
in Cape Town.
EOF
 
   
 
  
 
  　　運行結果： 
 
 
 
 
  
 
   
This is a simple lookup program
for good (and bad) restaurants
in Cape Town.
 
  
 
  　　下面的腳本經過 vi 編輯器將 document 保存到 test.txt 文件： 
  
 
   
 
    
#!/bin/sh
filename=test.txt
vi $filename <<EndOfCommands
i
This file was created automatically from
a shell script
^[
ZZ
EndOfCommands
 
   
 
  
 
  　　運行腳本： 
  
 
   
$ sh test.sh
Vim: Warning: Input is not from a terminal
$
 
  
 
  打開 test.txt，能夠看到下面的內容： 
  
 
   
$ cat test.txt
This file was created automatically from
a shell script
$
 
  
 
  
　　/dev/null 文件
 
  　　若是但願執行某個命令，但又不但願在屏幕上顯示輸出結果，那麼能夠將輸出重定向到 /dev/null： 
  
 
   
 
    
$ command > /dev/null
 
   
 
  
 
  　　/dev/null 是一個特殊的文件，寫入到它的內容都會被丟棄；若是嘗試從該文件讀取內容，那麼什麼也讀不到。可是 /dev/null 文件很是有用，將命令的輸出重定向到它，會起到」禁止輸出「的效果。 
  
 
  　　若是但願屏蔽 stdout 和 stderr，能夠這樣寫： 
 
 
 
 
  
 
   
$ command > /dev/null 2>&1
 
  
 
 
 
 
 24. 文件包含
 
 
 
  　　像其餘語言同樣，Shell 也能夠包含外部腳本，將外部腳本的內容合併到當前腳本。 
 
 
 
 
  　　Shell 中包含腳本可使用： 
  
 
   
 
    
. filename
 
   
 
  
 
  　　或 
  
 
   
 
    
source filename
 
   
 
  
 
  　　兩種方式的效果相同，簡單起見，通常使用點號(.)，可是注意點號(.)和文件名中間有一空格。 
  
 
  　　例如，建立兩個腳本，一個是被調用腳本 subscript.sh，內容以下： 
  
 
   
 
    
url="http://see.xidian.edu.cn/cpp/view/2738.html"
 
   
 
  
 
  　　一個是主文件 main.sh，內容以下： 
  
 
   
 
    
#!/bin/bash
. ./subscript.sh
echo $url
 
   
 
  
 
  　　執行腳本： 
  
 
   
$chomd +x main.sh
./main.sh
http://see.xidian.edu.cn/cpp/view/2738.html
$
 
  
 
  　　注意：被包含腳本不須要有執行權限。 
 
  



        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程