shell編程例子

A. shell編程，輸入一個字元串，判斷是否是數字。

read a

if [[ $a =~ /-?[0-9][0-9.]+/]] ; then

echo 「$a is num」

fi

或：

|read -p "請輸入一個字元串" str

if echo "$str"|shugrep "[a-zA-Z]" >/dev/null &&echo "$str"|grep "[0-9]" >/dev/null

then

echo "yes"

else

echo "no"

fi

(1)shell編程例子擴展閱讀：

字元串在存儲上類似字元數組，它每一位單個元素都是能提取的，字元串的零位是它的長度，如s[0]=10，這提供給我們很多方便，例如高精度運算時每一位都能轉化為數字存入數組。

通常以串的整體作為操作對象，如：在串中查找某個子串、求取一個子串、在串的某個位置上插入一個子串以及刪除一個子串等。兩個字元串相等的充要條件是：長度相等，並且各個對應位置上的字元都相等。設p、q是兩個串，求q在p中首次出現的位置的運算叫做模式匹配。串的兩種最基本的存儲方式是順序存儲方式和鏈接存儲方式。

B. SHELL編程幾個小例子

列印參數好像是倒著列印出來吧，
我不喜歡這種風格
有點類似於c++的引用吧
類似於echo
$*
吧未測試
$#
是參數的個數
echo
是命令的名字
循環
然後cmd變數等於
echo
$n
n是參數的個數
然後然後循環迭代每個一參數
cmd最後就是
echo
$2
echo
$1
然後在把上面的變數裡面的內容當作命令執行而已
=====================================
1
你的所有引號
單引號等標點都是中文符號，
當然不行了
2
while後面[和[後面的條件之間要有空格
#!/bin/bash
count=$#
cmd=echo
while
[
$count
-gt
0
]
do
cmd="$cmd
\$$count"
count=`expr
$count
-
1`
done
eval
$cmd

C. 簡單的SHELL編程

NUMBER1=`expr $NUMBER1 + 1`這樣的句子改成
: $((NUMBER1 = $NUMBER1 + 1))
試一下，注意最開頭是：號

因為要迅雷看看，現在在WIN下，無法調試。你自己試一下吧

另外，SCORE1=`「$SCORE1/$NUMBER1"|bc`的寫法也有問題

為什麼要帶``符號呢

D. 幾個Shell編程例子

根據我以前的 SHELL 編程經驗，關於 UNIX/linux SHELL 編程的詳細例子，這個必須要參考專門的 SHELL 編程指南、以及 awk 等操作才行。因為不同版本的 SHELL 編程（bash、C-Shell、ksh等），其語句也不是完全相同的，它們是有差別的。SHELL 編程中的細節實在是太細了，哪怕思路是正確的，但是在 SHELL 語句中缺少一個符號都不行。

E. 什麼是shell編程啊，求簡單實例

剛剛學習了新書<<實用Linux Shell編程>>，書寫的容易懂，第一章就回答了什麼是shell編程的問題。下面簡單回答，僅供參考，謝謝！

1）linux 命令，你可以一條一條執行，例如，顯示日期時間命令是date，顯示當前目錄的命令是pwd，列印一句話的命令可以是echo "good morning"

2)一個腳本是包含多條命令的文本文件，命令將按照順序依次運行。例如z.sh包含4行，如下:
$ cat z.sh
#!/bin/bash
date
pwd
echo "good morning"
第一行為腳本解釋程序的位置/bin/bash, 其他行, 是命令的「堆放」

3)增加腳本執行許可權：
$ chmod +x z.sh

4)運行腳本：
$ z.sh (或者./z.sh)
Mon Jan 12 15:20:32 CST 2015
/home/user
good morning
輸出有3行，分別是命令date的結果，命令pwd的結果，命令echo "good morning"的運行結果。

5)一般地，腳本不單單是幾個簡單命令的「堆放」，有判斷、分支選擇命令，循環命令，參數輸入，函數定義等等。
但是最簡單的shell腳本可以就一條命令，或者就幾個簡單命令的「堆放」。

僅供參考，謝謝！

F. 如何編寫一個shell腳本

如何編寫一個shell腳本

本文結合大量實例闡述如何編寫一個shell腳本。

為什麼要進行shell編程

在Linux系統中，雖然有各種各樣的圖形化介面工具，但是sell仍然是一個非常靈活的工具。Shell不僅僅是命令的收集，而且是一門非常棒的編程語言。您可以通過使用shell使大量的任務自動化，shell特別擅長系統管理任務，尤其適合那些易用性、可維護性和便攜性比效率更重要的任務。
下面，讓我們一起來看看shell是如何工作的：

建立一個腳本

Linux中有好多中不同的shell，但是通常我們使用bash (bourne again shell) 進行shell編程，因為bash是免費的並且很容易使用。所以在本文中筆者所提供的腳本都是使用bash（但是在大多數情況下，這些腳本同樣可以在bash的大姐，bourne shell中運行）。

如同其他語言一樣，通過我們使用任意一種文字編輯器，比如nedit、kedit、emacs、vi
等來編寫我們的shell程序。
程序必須以下面的行開始（必須方在文件的第一行）：
#!/bin/sh

符號#!用來告訴系統它後面的參數是用來執行該文件的程序。在這個例子中我們使用/bin/sh來執行程序。
當編輯好腳本時，如果要執行該腳本，還必須使其可執行。
要使腳本可執行：
chmod +x filename
然後，您可以通過輸入： ./filename 來執行您的腳本。

注釋

在進行shell編程時，以#開頭的句子表示注釋，直到這一行的結束。我們真誠地建議您在程序中使用注釋。如果您使用了注釋，那麼即使相當長的時間內沒有使用該腳本，您也能在很短的時間內明白該腳本的作用及工作原理。

變數

在其他編程語言中您必須使用變數。在shell編程中，所有的變數都由字元串組成，並且您不需要對變數進行聲明。要賦值給一個變數，您可以這樣寫：

變數名=值

取出變數值可以加一個美元符號（$）在變數前面：

#!/bin/sh
#對變數賦值：
a="hello world"
# 現在列印變數a的內容：
echo "A is:"
echo $a

在您的編輯器中輸入以上內容，然後將其保存為一個文件first。之後執行chmod +x first
使其可執行，最後輸入./first執行該腳本。
這個腳本將會輸出：
A is:
hello world

有時候變數名很容易與其他文字混淆，比如：
num=2
echo "this is the $numnd"
這並不會列印出"this is the 2nd"，而僅僅列印"this is the "，因為shell會去搜索變數numnd的值，但是這個變數時沒有值的。可以使用花括弧來告訴shell我們要列印的是num變數：
num=2
echo "this is the ${num}nd"
這將列印： this is the 2nd

有許多變數是系統自動設定的，這將在後面使用這些變數時進行討論。

如果您需要處理數學表達式，那麼您需要使用諸如expr等程序（見下面）。
除了一般的僅在程序內有效的shell變數以外，還有環境變數。由export關鍵字處理過的變數叫做環境變數。我們不對環境變數進行討論，因為通常情況下僅僅在登錄腳本中使用環境變數。

Shell命令和流程式控制制

在shell腳本中可以使用三類命令：

1)Unix 命令:

雖然在shell腳本中可以使用任意的unix命令，但是還是由一些相對更常用的命令。這些命令通常是用來進行文件和文字操作的。

常用命令語法及功能

echo "some text": 將文字內容列印在屏幕上

ls: 文件列表

wc –l filewc -w filewc -c file: 計算文件行數計算文件中的單詞數計算文件中的字元數

cp sourcefile destfile: 文件拷貝

mv oldname newname : 重命名文件或移動文件

rm file: 刪除文件

grep 'pattern' file: 在文件內搜索字元串比如：grep 'searchstring' file.txt

cut -b colnum file: 指定欲顯示的文件內容範圍，並將它們輸出到標准輸出設備比如：輸出每行第5個到第9個字元cut -b5-9 file.txt千萬不要和cat命令混淆，這是兩個完全不同的命令

cat file.txt: 輸出文件內容到標准輸出設備（屏幕）上

file somefile: 得到文件類型

read var: 提示用戶輸入，並將輸入賦值給變數

sort file.txt: 對file.txt文件中的行進行排序

uniq: 刪除文本文件中出現的行列比如： sort file.txt | uniq

expr: 進行數學運算Example: add 2 and 3expr 2 "+" 3

find: 搜索文件比如：根據文件名搜索find . -name filename -print

tee: 將數據輸出到標准輸出設備(屏幕) 和文件比如：somecommand | tee outfile

basename file: 返回不包含路徑的文件名比如： basename /bin/tux將返回 tux

dirname file: 返迴文件所在路徑比如：dirname /bin/tux將返回 /bin

head file: 列印文本文件開頭幾行

tail file : 列印文本文件末尾幾行

sed: Sed是一個基本的查找替換程序。可以從標准輸入（比如命令管道）讀入文本，並將結果輸出到標准輸出（屏幕）。該命令採用正則表達式（見參考）進行搜索。不要和shell中的通配符相混淆。比如：將linuxfocus 替換為 LinuxFocus ：cat text.file | sed 's/linuxfocus/LinuxFocus/' > newtext.file

awk: awk 用來從文本文件中提取欄位。預設地，欄位分割符是空格，可以使用-F指定其他分割符。cat file.txt | awk -F, '{print $1 "," $3 }'這里我們使用，作為欄位分割符，同時列印第一個和第三個欄位。如果該文件內容如下： Adam Bor, 34, IndiaKerry Miller, 22, USA命令輸出結果為：Adam Bor, IndiaKerry Miller, USA

2) 概念: 管道, 重定向和 backtick

這些不是系統命令，但是他們真的很重要。

管道 (|) 將一個命令的輸出作為另外一個命令的輸入。
grep "hello" file.txt | wc -l
在file.txt中搜索包含有地hello地的行並計算其行數。
在這里grep命令的輸出作為wc命令的輸入。當然您可以使用多個命令。

重定向：將命令的結果輸出到文件，而不是標准輸出（屏幕）。
> 寫入文件並覆蓋舊文件
>> 加到文件的尾部，保留舊文件內容。

反短斜線
使用反短斜線可以將一個命令的輸出作為另外一個命令的一個命令行參數。
命令：
find . -mtime -1 -type f -print
用來查找過去24小時（-mtime –2則表示過去48小時）內修改過的文件。如果您想將所有查找到的文件打一個包，則可以使用以下腳本：
#!/bin/sh
# The ticks are backticks (`) not normal quotes ('):
tar -zcvf lastmod.tar.gz `find . -mtime -1 -type f -print`

3) 流程式控制制

"if" 表達式 如果條件為真則執行then後面的部分：
if ....; then
....
elif ....; then
....
else
....
fi
大多數情況下，可以使用測試命令來對條件進行測試。比如可以比較字元串、判斷文件是否存在及是否可讀等等…
通常用" [ ] "來表示條件測試。注意這里的空格很重要。要確保方括弧的空格。
[ -f "somefile" ] ：判斷是否是一個文件
[ -x "/bin/ls" ] ：判斷/bin/ls是否存在並有可執行許可權
[ -n "$var" ] ：判斷$var變數是否有值
[ "$a" = "$b" ] ：判斷$a和$b是否相等

執行man test可以查看所有測試表達式可以比較和判斷的類型。
直接執行以下腳本：
#!/bin/sh
if [ "$SHELL" = "/bin/bash" ]; then
echo "your login shell is the bash (bourne again shell)"
else
echo "your login shell is not bash but $SHELL"
fi
變數$SHELL包含了登錄shell的名稱，我們和/bin/bash進行了比較。

快捷操作符

熟悉C語言的朋友可能會很喜歡下面的表達式：
[ -f "/etc/shadow" ] && echo "This computer uses shadow passwors"
這里 && 就是一個快捷操作符，如果左邊的表達式為真則執行右邊的語句。您也可以認為是邏輯運算中的與操作。上例中表示如果/etc/shadow文件存在則列印地 This computer uses shadow passwors地。同樣或操作(||)在shell編程中也是可用的。這里有個例子：
#!/bin/sh
mailfolder=/var/spool/mail/james
[ -r "$mailfolder" ]' '{ echo "Can not read $mailfolder" ; exit 1; }
echo "$mailfolder has mail from:"
grep "^From " $mailfolder
該腳本首先判斷mailfolder是否可讀。如果可讀則列印該文件中的"From" 一行。如果不可讀則或操作生效，列印錯誤信息後腳本退出。這里有個問題，那就是我們必須有兩個命令：
-列印錯誤信息
-退出程序
我們使用花括弧以匿名函數的形式將兩個命令放到一起作為一個命令使用。一般函數將在下文提及。
不用與和或操作符，我們也可以用if表達式作任何事情，但是使用與或操作符會更便利很多。

case表達式可以用來匹配一個給定的字元串，而不是數字。
case ... in
...) do something here ;;
esac
讓我們看一個例子。 file命令可以辨別出一個給定文件的文件類型，比如：
file lf.gz
這將返回：
lf.gz: gzip compressed data, deflated, original filename,
last modified: Mon Aug 27 23:09:18 2001, os: Unix
我們利用這一點寫了一個叫做smartzip的腳本，該腳本可以自動解壓bzip2, gzip 和zip 類型的壓縮文件：
#!/bin/sh
ftype=`file "$1"`
case "$ftype" in
"$1: Zip archive"*)
unzip "$1" ;;
"$1: gzip compressed"*)
gunzip "$1" ;;
"$1: bzip2 compressed"*)
bunzip2 "$1" ;;
*) error "File $1 can not be uncompressed with smartzip";;
esac

您可能注意到我們在這里使用了一個特殊的變數$1。該變數包含了傳遞給該程序的第一個參數值。也就是說，當我們運行：
smartzip articles.zip
$1 就是字元串 articles.zip

select 表達式是一種bash的擴展應用，尤其擅長於互動式使用。用戶可以從一組不同的值中進行選擇。
select var in ... ; do
break
done
.... now $var can be used ....
下面是一個例子：
#!/bin/sh
echo "What is your favourite OS?"
select var in "Linux" "Gnu Hurd" "Free BSD" "Other"; do
break
done
echo "You have selected $var"
下面是該腳本運行的結果：
What is your favourite OS?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Other
#? 1
You have selected Linux

您也可以在shell中使用如下的loop表達式：
while ...; do
....
done

while-loop 將運行直到表達式測試為真。will run while the expression that we test for is true. 關鍵字"break" 用來跳出循環。而關鍵字地continue地用來不執行餘下的部分而直接跳到下一個循環。

for-loop表達式查看一個字元串列表 (字元串用空格分隔) 然後將其賦給一個變數：
for var in ....; do
....
done

在下面的例子中，將分別列印ABC到屏幕上：
#!/bin/sh
for var in A B C ; do
echo "var is $var"
done

下面是一個更為有用的腳本showrpm，其功能是列印一些RPM包的統計信息：
#!/bin/sh
# list a content summary of a number of RPM packages
# USAGE: showrpm rpmfile1 rpmfile2 ...
# EXAMPLE: showrpm /cdrom/RedHat/RPMS/*.rpm
for rpmpackage in $*; do
if [ -r "$rpmpackage" ];then
echo "=============== $rpmpackage =============="
rpm -qi -p $rpmpackage
else
echo "ERROR: cannot read file $rpmpackage"
fi
done

這里出現了第二個特殊的變數$*，該變數包含了所有輸入的命令行參數值。如果您運行showrpm openssh.rpm w3m.rpm webgrep.rpm
此時 $* 包含了 3 個字元串，即openssh.rpm, w3m.rpm and webgrep.rpm.

引號
在向程序傳遞任何參數之前，程序會擴展通配符和變數。這里所謂擴展的意思是程序會把通配符（比如*）替換成合適的文件名，它變數替換成變數值。為了防止程序作這種替換，您可以使用引號：讓我們來看一個例子，假設在當前目錄下有一些文件，兩個jpg文件， mail.jpg 和tux.jpg。

#!/bin/sh
echo *.jpg
這將列印出"mail.jpg tux.jpg"的結果。
引號 (單引號和雙引號) 將防止這種通配符擴展：
#!/bin/sh
echo "*.jpg"
echo '*.jpg'
這將列印"*.jpg" 兩次。
單引號更嚴格一些。它可以防止任何變數擴展。雙引號可以防止通配符擴展但允許變數擴展。
#!/bin/sh
echo $SHELL
echo "$SHELL"
echo '$SHELL'

運行結果為：
/bin/bash
/bin/bash
$SHELL

最後，還有一種防止這種擴展的方法，那就是使用轉義字元——反斜桿：
echo *.jpg
echo $SHELL
這將輸出：
*.jpg
$SHELL
Here documents

當要將幾行文字傳遞給一個命令時，here documents（譯者註：目前還沒有見到過對該詞適合的翻譯）一種不錯的方法。對每個腳本寫一段幫助性的文字是很有用的，此時如果我們四有那個here documents就不必用echo函數一行行輸出。 一個 "Here document" 以 << 開頭，後面接上一個字元串，這個字元串還必須出現在here document的末尾。下面是一個例子，在該例子中，我們對多個文件進行重命名，並且使用here documents列印幫助：

#!/bin/sh
# we have less than 3 arguments. Print the help text:
if [ $# -lt 3 ] ; then
cat <<HELP
ren -- renames a number of files using sed regular expressions

USAGE: ren 'regexp' 'replacement' files...

EXAMPLE: rename all *.HTM files in *.html:
ren 'HTM$' 'html' *.HTM

HELP
exit 0
fi
OLD="$1"
NEW="$2"
# The shift command removes one argument from the list of
# command line arguments.
shift
shift
# $* contains now all the files:
for file in $*; do
if [ -f "$file" ] ; then
newfile=`echo "$file" | sed "s/${OLD}/${NEW}/g"`
if [ -f "$newfile" ]; then
echo "ERROR: $newfile exists already"
else
echo "renaming $file to $newfile ..."
mv "$file" "$newfile"
fi
fi
done

這是一個復雜一些的例子。讓我們詳細討論一下。第一個if表達式判斷輸入命令行參數是否小於3個 (特殊變數$# 表示包含參數的個數) 。如果輸入參數小於3個，則將幫助文字傳遞給cat命令，然後由cat命令將其列印在屏幕上。列印幫助文字後程序退出。 如果輸入參數等於或大於3個，我們就將第一個參數賦值給變數OLD，第二個參數賦值給變數NEW。下一步，我們使用shift命令將第一個和第二個參數從參數列表中刪除，這樣原來的第三個參數就成為參數列表$*的第一個參數。然後我們開始循環，命令行參數列表被一個接一個地被賦值給變數$file。接著我們判斷該文件是否存在，如果存在則通過sed命令搜索和替換來產生新的文件名。然後將反短斜線內命令結果賦值給newfile。這樣我們就達到了我們的目的：得到了舊文件名和新文件名。然後使用mv命令進行重命名。

函數

如果您寫了一些稍微復雜一些的程序，您就會發現在程序中可能在幾個地方使用了相同的代碼，並且您也會發現，如果我們使用了函數，會方便很多。一個函數是這個樣子的：
functionname()
{
# inside the body $1 is the first argument given to the function
# $2 the second ...
body
}
您需要在每個程序的開始對函數進行聲明。

下面是一個叫做xtitlebar的腳本，使用這個腳本您可以改變終端窗口的名稱。這里使用了一個叫做help的函數。正如您可以看到的那樣，這個定義的函數被使用了兩次。
#!/bin/sh
# vim: set sw=4 ts=4 et:

help()
{
cat <<HELP
xtitlebar -- change the name of an xterm, gnome-terminal or kde konsole

USAGE: xtitlebar [-h] "string_for_titelbar"

OPTIONS: -h help text

EXAMPLE: xtitlebar "cvs"

HELP
exit 0
}

# in case of error or if -h is given we call the function help:
[ -z "$1" ] && help
[ "$1" = "-h" ] && help

# send the escape sequence to change the xterm titelbar:
echo -e "33]0;$107"
#

在腳本中提供幫助是一種很好的編程習慣，這樣方便其他用戶（和您）使用和理解腳本。

命令行參數

我們已經見過$* 和 $1, $2 ... $9 等特殊變數，這些特殊變數包含了用戶從命令行輸入的參數。迄今為止，我們僅僅了解了一些簡單的命令行語法（比如一些強制性的參數和查看幫助的-h選項）。但是在編寫更復雜的程序時，您可能會發現您需要更多的自定義的選項。通常的慣例是在所有可選的參數之前加一個減號，後面再加上參數值 (比如文件名)。

有好多方法可以實現對輸入參數的分析，但是下面的使用case表達式的例子無遺是一個不錯的方法。
#!/bin/sh
help()
{
cat <<HELP
This is a generic command line parser demo.
USAGE EXAMPLE: cmdparser -l hello -f -- -somefile1 somefile2
HELP
exit 0
}

while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;; # function help is called
-f) opt_f=1;shift 1;; # variable opt_f is set
-l) opt_l=$2;shift 2;; # -l takes an argument -> shift by 2
--) shift;break;; # end of options
-*) echo "error: no such option $1. -h for help";exit 1;;
*) break;;
esac
done

echo "opt_f is $opt_f"
echo "opt_l is $opt_l"
echo "first arg is $1"
echo "2nd arg is $2"

您可以這樣運行該腳本：
cmdparser -l hello -f -- -somefile1 somefile2

返回的結果是：
opt_f is 1
opt_l is hello
first arg is -somefile1
2nd arg is somefile2

這個腳本是如何工作的呢看腳本首先在所有輸入命令行參數中進行循環，將輸入參數與case表達式進行比較，如果匹配則設置一個變數並且移除該參數。根據unix系統的慣例，首先輸入的應該是包含減號的參數。

實例

一般編程步驟

現在我們來討論編寫一個腳本的一般步驟。任何優秀的腳本都應該具有幫助和輸入參數。並且寫一個偽腳本（framework.sh），該腳本包含了大多數腳本都需要的框架結構，是一個非常不錯的主意。這時候，在寫一個新的腳本時我們只需要執行一下命令：
cp framework.sh myscript
然後再插入自己的函數。

讓我們再看兩個例子：

二進制到十進制的轉換

腳本 b2d 將二進制數 (比如 1101) 轉換為相應的十進制數。這也是一個用expr命令進行數學運算的例子：
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
cat <<HELP
b2h -- convert binary to decimal

USAGE: b2h [-h] binarynum

OPTIONS: -h help text

EXAMPLE: b2h 111010
will return 58
HELP
exit 0
}

error()
{
# print an error and exit
echo "$1"
exit 1
}

lastchar()
{
# return the last character of a string in $rval
if [ -z "$1" ]; then
# empty string
rval=""
return
fi
# wc puts some space behind the output this is why we need sed:
numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `
# now cut out the last char
rval=`echo -n "$1" | cut -b $numofchar`
}

chop()
{
# remove the last character in string and return it in $rval
if [ -z "$1" ]; then
# empty string
rval=""
return
fi
# wc puts some space behind the output this is why we need sed:
numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `
if [ "$numofchar" = "1" ]; then
# only one char in string
rval=""
return
fi
numofcharminus1=`expr $numofchar "-" 1`
# now cut all but the last char:
rval=`echo -n "$1" | cut -b 0-${numofcharminus1}`
}

while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;; # function help is called
--) shift;break;; # end of options
-*) error "error: no such option $1. -h for help";;
*) break;;
esac
done

# The main program
sum=0
weight=1
# one arg must be given:
[ -z "$1" ] && help
binnum="$1"
binnumorig="$1"

while [ -n "$binnum" ]; do
lastchar "$binnum"
if [ "$rval" = "1" ]; then
sum=`expr "$weight" "+" "$sum"`
fi
# remove the last position in $binnum
chop "$binnum"
binnum="$rval"
weight=`expr "$weight" "*" 2`
done

echo "binary $binnumorig is decimal $sum"
#
該腳本使用的演算法是利用十進制和二進制數權值 (1,2,4,8,16,..)，比如二進制"10"可以這樣轉換成十進制：
0 * 1 + 1 * 2 = 2
為了得到單個的二進制數我們是用了lastchar 函數。該函數使用wc –c計算字元個數，然後使用cut命令取出末尾一個字元。Chop函數的功能則是移除最後一個字元。

文件循環程序
或許您是想將所有發出的郵件保存到一個文件中的人們中的一員，但是在過了幾個月以後，這個文件可能會變得很大以至於使對該文件的訪問速度變慢。下面的腳本rotatefile 可以解決這個問題。這個腳本可以重命名郵件保存文件（假設為outmail）為outmail.1，而對於outmail.1就變成了outmail.2 等等等等...
#!/bin/sh
# vim: set sw=4 ts=4 et:
ver="0.1"
help()
{
cat <<HELP
rotatefile -- rotate the file name

USAGE: rotatefile [-h] filename

OPTIONS: -h help text

EXAMPLE: rotatefile out
This will e.g rename out.2 to out.3, out.1 to out.2, out to out.1
and create an empty out-file

The max number is 10

version $ver
HELP
exit 0
}

error()
{
echo "$1"
exit 1
}
while [ -n "$1" ]; do
case $1 in
-h) help;shift 1;;
--) break;;
-*) echo "error: no such option $1. -h for help";exit 1;;
*) break;;
esac
done

# input check:
if [ -z "$1" ] ; then
error "ERROR: you must specify a file, use -h for help"
fi
filen="$1"
# rename any .1 , .2 etc file:
for n in 9 8 7 6 5 4 3 2 1; do
if [ -f "$filen.$n" ]; then
p=`expr $n + 1`
echo "mv $filen.$n $filen.$p"
mv $filen.$n $filen.$p
fi
done
# rename the original file:
if [ -f "$filen" ]; then
echo "mv $filen $filen.1"
mv $filen $filen.1
fi
echo touch $filen
touch $filen

這個腳本是如何工作的呢看在檢測用戶提供了一個文件名以後，我們進行一個9到1的循環。文件9被命名為10，文件8重命名為9等等。循環完成之後，我們將原始文件命名為文件1同時建立一個與原始文件同名的空文件。
調試
最簡單的調試命令當然是使用echo命令。您可以使用echo在任何懷疑出錯的地方列印任何變數值。這也是絕大多數的shell程序員要花費80%的時間來調試程序的原因。Shell程序的好處在於不需要重新編譯，插入一個echo命令也不需要多少時間。

shell也有一個真實的調試模式。如果在腳本"strangescript" 中有錯誤，您可以這樣來進行調試：
sh -x strangescript
這將執行該腳本並顯示所有變數的值。
shell還有一個不需要執行腳本只是檢查語法的模式。可以這樣使用：
sh -n your_script
這將返回所有語法錯誤。

G. Shell腳本編程實戰

做 Java 的肯定都接觸過 Linux 系統，那麼很多時候我們在開發的過程中都是把我們項目打成一個jar包，或者是war包的形式，然後通過 XFTP 上傳到我們伺服器的指定目錄，然後運行一端啟動腳本，讓我們的項目變得可以訪問 就像 ./sh service.sh start 然後啟動我們寫好的 sh 的shell腳本。接下來我們就來學習一下關於 Shell 腳本是如何寫出來的。

Shell 腳本是什麼？Shell是一個命令解釋器，它的作用是解釋執行用戶輸入的命令及程序等，也就是說，我們用戶每輸入一條命令，Shell 就會相對應的執行一條命令。當命令或程序語句不在命令行下執行，而是通過一個程序文件來執行時，該程序文件就被稱為Shell腳本。

在我們的 Shell 腳本中，會有各種各樣的內容，賦值，計算，循環等一系列的操作，接下來我們就來看看這個 Shell 腳本怎麼寫吧

1.查看自己當前系統默認的 Shell

echo $SHELL

輸出：/bin/bash

2.查看系統支持的Shell

cat /etc/shells

輸出：

/bin/sh /bin/bash /usr/bin/sh /usr/bin/bash

也就是說，我們的雲伺服器是支持我們在這里給他安排 Shell 腳本的

我們這時候先來安排一下 sh 的文件,創建一個文件夾，然後在其中創建一個 sh 的文件。

mkdir /usr/local/shelltest

touch test.sh

創建完成我們編輯一下內容

vim test.sh

然後我們出來運行一下我們的 Shell 的第一個腳本

bash test.sh

出來的結果是 Hello World Shell

一個及其簡單的腳本出現了，接下我們就分析一波我們寫了點啥？

#!/bin/bash

#! 是一個約定的標記，它告訴系統這個腳本需要什麼解釋器來執行，即使用哪一種 Shell

我們在之前也使用了 echo $SHELL 來查看了自己系統默認的是哪一種 sh 解析器，之前看到的是/bin/bash，所以我們在寫 Shell 腳本的時候，我們在開頭默認的約定中，我們寫了這個是用 /bin/bash 來進行解釋的，

那麼我們如何像之前調用我們的當前目錄中的 Shell 腳本一樣去調用他呢？就像這個樣子的 ./sh service.sh start

1.授權，

我們先不授權試一下看看能通過 ./test.sh 進行調用么

bash: ./test.sh: Permission denied 會提示這個，也就是沒有授權定義，

授權命令：chmod +x test.sh

2.執行 ./test.sh

然後調用就能正常輸出了,就是說，在當前的目錄下執行這個腳本命令。

變數命名實際上很簡單，我們先來試一下

name=yikeji

這時候我們怎麼使用變數呢？實際上只要在前面加上一個符號就可以 $

echo $name

上面的兩種寫法都是可以的，外面的大括弧加和不加區別不大，可以省略，直接就 $name 就可以使用你定義的變數

使用括弧的意義一般在於區別某些變數，比如你寫了一串的內容，可能寫的是 echo $nameismyfriend ,如果連在一起，是不是有點尷尬，這時候就可以使用括弧區別一下， echo ${name}ismyfriend 不使用括弧的時候，他就去找nameismyfriend這個變數了，就無法出來我們要的效果。

unset name

這時候我們就把我們剛才定義的 name=yikeji 這個變數給去掉了，我們可以調用一下我們的變數看是什麼？

echo $name

這是不是就證明我們自己定義的變數已經刪除了

那麼我們需要一個關鍵字，大家肯定能想到是什麼關鍵字 readonly

我們先給name賦值，然後使用 readonly 設置只讀，然後再改變一下試試，

竟然是真的，如果不設置只讀，是不是會重新可以進行賦值，我們測試個年齡，

所以我們就可以肯定，readonly就是設置只讀的關鍵詞，記住了么？

那麼設置只讀的變數可以刪除么？畢竟總有杠精的面試官會提問這個棘手的問題，但是，阿粉試過的所有方式好像都是不行的，阿粉就直接重啟了自己的伺服器，這樣臨時的變數就不存在了！

說真的，Shell腳本的流程式控制制數一般才是yyds，為什麼這么說，因為你在寫大部分的腳本的時候，流程式控制制的地方永遠是最多的，判斷，選擇，等等一系列的函數，當時熟練使用的時候，就發現這東西確實很有意思。

我們先說最簡單的 if else 這也是我們最經常使用的判斷，在寫 Shell 腳本的時候,就不像我們的 Java 中直接寫

Xshell 中的語法就不是這個樣子的， Xshell 語法：

末尾的 fi 就是 if 倒過來拼寫,我們可以寫一個 if 的腳本試一下這個流程能否理解。

這里申明一下，

我們在上面這段腳本中寫就是內容就是，我們給腳本傳入一個值，然後比對這個值和2的大小關系，然後輸出我們指定的內容。

運行後就能看到

$1 表示我們給 Shell 腳本輸入的第一個參數, $0 就是你寫的shell腳本本身的名字,$2 是我們給 Shell 腳本傳的第二個參數

大家在部署某些項目的時候，是不是啟動命令就很簡潔，就是 sh service.sh start 類似這種的，那我們來看看一般這種是怎麼寫的，這就用到了另外一塊的內容，和 if 類似，在 Java 中也有，那就是 Case .

我們先來看看 Case 的語法，

case ... esac 實際上就和 Java 中的 Case 是非常相似的，case 語句匹配一個值與一個模式，如果匹配成功，執行相匹配的命令. esac 是一個結束的標志。

光說不練，假把式，我們來搞一下試試寫一個腳本來搞一下。就用我們剛才說的 sh servic.sh start 來進行測試。

我們來看看運行結果

那麼這段 Shell 腳本是什麼意思呢？其實很簡單，匹配我們傳入的第一個字元，和 start 還有 stop 進行比較，如果匹配上之後，輸出命令，最後退出即可。

是不是感覺沒有那麼復雜了呢？

說到流程式控制制,那麼肯定不能不說 for , 畢竟 for 循環在 Java 中那可是重頭戲。

我們先看他的格式

那麼我們有沒有說像是 Java 中那種 for 循環一樣的方式呢？比如說這個 for ((i=1; i<=j; i++))

實際上也是支持這種的，我們來寫一個試試。

執行一下看看

既然有 for 那是不是就有 while 呢？是的，沒錯，確實是有 while ，也是循環的意思，但是寫法有略微不一樣的地方

我們來舉個嘗試列印九九乘法表來看一下

是不是也挺簡單的？

其實 Shell 腳本的編寫一般都是在實際應用中提升，單純的寫測試腳本，也是可以讓自己對知識的掌握比較充分，而我們一般都是寫一些比較簡單的腳本，復雜的不是還有運維么？

H. 簡單的shell編程

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>

#define BUFFERSIZE 80

extern char *get_current_dir_name(void);
extern char *getenv(const char *name);
extern pid_t waitpid(pid_t pid, int *status, int options);

char buffer[BUFFERSIZE+1];

main()
{
char *path, *arg[10], *input;
int li_inputlen, is_bj, is_back, i, j, k, pid, status;
char lc_char;

while (1){
/* initiations */
is_bj = 0; /*redirection flag*/
is_back = 0; /*background*/

/* shell prompt */
path = get_current_dir_name();
printf("%s>$",path);

/*開始獲取輸入*/
li_inputlen = 0;
lc_char = getchar();
while (lc_char !='\n'){
if(li_inputlen < BUFFERSIZE)
buffer[li_inputlen++] = lc_char;
lc_char = getchar();
}

/*命令超長處理*/
if (li_inputlen >= BUFFERSIZE){
printf("Your command is too long! Please re-enter your command!\n");
li_inputlen = 0; /*reset */
continue;
}
else
buffer[li_inputlen] = '\0';/*加上串結束符號，形成字串*/

/*將命令從緩存拷貝到input中*/
input = (char *) malloc(sizeof(char) * (li_inputlen+1));
strcpy(input,buffer);

/* 獲取命令和參數並保存在arg中*/
for (i = 0,j = 0,k = 0;i <= li_inputlen;i++){
/*管道和重定向單獨處理*/
if (input[i] == '<' || input[i] == '>' || input[i] =='|'){
if (input[i] == '|')
pipel(input,li_inputlen);
else
redirect(input,li_inputlen);
is_bj = 1;
break;
}
/*處理空格、TAB和結束符。不用處理『\n'，大家如果仔細分析前面的獲取輸入的程序的話，
*不難發現回車符並沒有寫入buffer*/
if (input[i] == ' ' || input[i] =='\t' || input[i] == '\0'){
if (j == 0) /*這個條件可以略去連在一起的多個空格或者tab*/
continue;
else{
buffer[j++] = '\0';
arg[k] = (char *) malloc(sizeof(char)*j);
/*將指令或參數從緩存拷貝到arg中*/
strcpy(arg[k],buffer);
j = 0; /*准備取下一個參數*/
k++;
}
}
else{
/*如果字串最後是『&'，則置後台運行標記為1*/
if (input[i] == '&' && input[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = input[i];
}
}

free(input);/*釋放空間*/

/*如果輸入的指令是leave則退出while，即退出程序*/
if (strcmp(arg[0],"leave") == 0 ){
printf("bye-bye\n");
break;
}
/*如果輸入的指令是about則顯示作者信息，同時結束本條命令的解析過程*/
if (strcmp(arg[0]," about") == 0 ){
printf("right by shike，[email protected]\n");
continue;
}

if (is_bj == 0){ /*非管道、重定向指令*/
/*在使用xxec執行命令的時候，最後的參數必須是NULL指針，
*所以將最後一個參數置成空值*/
arg[k] = (char *) 0;
/*判斷指令arg[0]是否存在*/
if (is_fileexist(arg[0]) == -1 ){
printf("This command is not found?!\n");
for(i=0;i<k;i++)
free(arg[i]);
continue;
}

/* fork a sub-process to run the execution file */
if ((pid = fork()) ==0) /*子進程*/
execv(buffer,arg);
else /*父進程*/
if (is_back == 0) /*並非後台執行指令*/
waitpid(pid,&status,0);

/*釋放申請的空間*/
for (i=0;i<k;i++)
free(arg[i]);
}
}
}

int is_fileexist(char *comm)
{
char *path,*p;
int i;

i = 0;
/*使用getenv函數來獲取系統環境變數，用參數PATH表示獲取路徑*/
path = getenv("PATH");
p = path;
while (*p != '\0'){
/*路徑列表使用『:』來分隔路徑*/
if (*p != ':')
buffer[i++] = *p;
else{
buffer[i++] = '/';
buffer[i] = '\0';
/*將指令和路徑合成，形成pathname，並使用access函數來判斷該文件是否存在*/
strcat(buffer,comm);

if (access(buffer,F_OK) == 0) /*文件被找到*/
return 0;
else
/*繼續尋找其它路徑*/
i = 0;
}
p++;
}
/*搜索完所有路徑，依然沒有找到則返回-1*/
return -1;
}

int redirect(char *in,int len)
{
char *argv[30],*filename[2];
pid_t pid;
int i,j,k,fd_in,fd_out,is_in = -1,is_out = -1,num = 0;
int is_back = 0,status=0;

/*這里是重定向的命令解析過程，其中filename用於存放重定向文件，
*is_in, is_out分別是輸入重定向標記和輸出重定向標記*/
for (i = 0,j = 0,k = 0;i <= len;i++){
if (in[i]==' '||in[i]=='\t'||in[i]=='\0'||in[i] =='<'||in[i]=='>'){
if (in[i] == '>' || in[i] == '<'){
/*重定向指令最多'<'，'>'各出現一次，因此num最大為2，
*否則認為命令輸入錯誤*/
if (num < 3){
num ++;
if (in[i] == '<')
is_in = num - 1;
else
is_out = num - 1;

/*處理命令和重定向符號相連的情況，比如ls>a*/
if (j > 0 && num == 1) {
buffer[j++] = '\0';
argv[k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[k],buffer);
k++;
j = 0;
}
}
else{
printf("The format is error!\n");
return -1;
}
}
if (j == 0)
continue;
else{
buffer[j++] = '\0';
/*尚未遇到重定向符號，字元串是命令或參數*/
if (num == 0){
argv[k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[k],buffer);
k++;
}
/*是重定向後符號的字元串，是文件名*/
else{
filename[status] = (char *) malloc(sizeof(char)*j);
strcpy(filename[status++],buffer);
}
j = 0; /*initate*/
}
}
else{
if (in[i] == '&' && in[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = in[i];
}
}

argv[k] = (char *) 0;

if (is_fileexist(argv[0]) == -1 ){
printf("This command is not founded!\n");
for(i=0;i<k;i++)
free(argv[i]);
return 0;
}

if ((pid = fork()) ==0){
/*存在輸出重定向*/
if (is_out != -1)
if((fd_out=open(filename[is_out],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1){
printf("Open out %s Error\n",filename[is_out]);
return -1;
}

/*存在輸入重定向*/
if (is_in != -1)
if((fd_in=open(filename[is_in],O_RDONLY,S_IRUSR|S_IWUSR))==-1){
printf("Open in %s Error\n",filename[is_out]);
return -1;
}

if (is_out != -1)
/*使用p2函數將標准輸出重定向到fd_out上，p2(int oldfd,int newfd)實現的
*是把oldfd所指的文件描述符復制到newfd。若newfd為一已打開的文件描述詞，
*則newfd所指的文件會先被關閉，p2復制的文件描述詞與原來的文件描述詞
*共享各種文件狀態*/
if(p2(fd_out,STDOUT_FILENO)==-1){
printf("Redirect Standard Out Error\n");
exit(1);
}

if (is_in != -1)
if(p2(fd_in,STDIN_FILENO)==-1){
printf("Redirect Standard Out Error\n");
exit(1);
}
execv(buffer,argv);
}
else
if (is_back == 0) /*run on the TOP*/
waitpid(pid,&status,0);

for (i=0;i<k;i++)
free(argv[i]);

if (is_in != -1){
free(filename[is_in]);
close(fd_in);
}
if (is_out != -1){
free(filename[is_out]);
close(fd_out);
}
return 0;
}

int pipel(char *input,int len)
{
char *argv[2][30];
int i,j,k,count,is_back = 0;
int li_comm = 0,fd[2],fpip[2];
char lc_char,lc_end[1];
pid_t child1,child2;

/*管道的命令解析過程*/
for (i = 0,j = 0,k = 0;i <= len;i++){
if (input[i]== ' ' || input[i] == '\t' || input[i] == '\0' || input[i] == '|'){
if (input[i] == '|' ) /*管道符號*/
{
if (j > 0)
{
buffer[j++] = '\0';
/*因為管道連接的是兩個指令，所以用二維數組指針來存放命令和參數，
*li_comm是表示第幾個指令*/
argv[li_comm][k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[li_comm][k++],buffer);
}
argv[li_comm][k++] = (char *) 0;
/*遇到管道符，第一個指令完畢，開始准備接受第二個指令*/
li_comm++;
count = k;
k=0;j=0;
}
if (j == 0)
continue;
else
{
buffer[j++] = '\0';
argv[li_comm][k] = (char *) malloc(sizeof(char)*j);
strcpy(argv[li_comm][k],buffer);
k++;
}
j = 0; /*initate*/
}
else{
if (input[i] == '&' && input[i+1] == '\0'){
is_back = 1;
continue;
}
buffer[j++] = input[i];
}
}
argv[li_comm][k++] = (char *) 0;

if (is_fileexist(argv[0][0]) == -1 ){
printf("This first command is not found!\n");
for(i=0;i<count;i++)
free(argv[0][i]);
return 0;
}
/*指令解析結束*/

/*建立管道*/
if (pipe(fd) == -1 ){
printf("open pipe error!\n");
return -1;
}

/*創建第一個子進程執行管道符前的指令，並將輸出寫到管道*/
if ((child1 = fork()) ==0){
/*關閉讀端*/
close(fd[0]);
if (fd[1] != STDOUT_FILENO){
/*將標准輸出重定向到管道的寫入端，這樣該子進程的輸出就寫入了管道*/
if (p2(fd[1],STDOUT_FILENO) == -1){
printf("Redirect Standard Out Error\n");
return -1;
}
/*關閉寫入端*/
close(fd[1]);
}
execv(buffer,argv[0]);
}
else{ /*父進程*/
/*先要等待寫入管道的進程結束*/
waitpid(child1,&li_comm,0);
/*然後我們必須寫入一個結束標記，告訴讀管道進程數據到這里就完了*/
lc_end[0] = 0x1a;
write(fd[1],lc_end,1);
close(fd[1]);

if (is_fileexist(argv[1][0]) == -1 ){
printf("This command is not founded!\n");
for(i=0;i<k;i++)
free(argv[1][i]);
return 0;
}

/*創建第二個進程執行管道符後的指令，並從管道讀輸入流 */
if ((child2 = fork()) == 0){
if (fd[0] != STDIN_FILENO){
/*將標准輸入重定向到管道讀入端*/
if(p2(fd[0],STDIN_FILENO) == -1){
printf("Redirect Standard In Error!\n");
return -1;
}
close(fd[0]);
}
execv(buffer,argv[1]);
}
else /*父進程*/
if (is_back == 0)
waitpid(child2,NULL,0);
}
for (i=0;i<count;i++)
free(argv[0][i]);
for (i=0;i<k;i++)
free(argv[1][i]);
return 0;
}

以前寫的，好像一些細節不一樣，不明白的地方，發郵件給我，[email protected]

I. Shell的簡單編程

$cat test.sh
#!/bin/bash
if [ -c $1 ];then
echo "$1是字元設備文件"
else test -e $1 || echo "This file is not exist"
fi
if test -d $2;then
echo "$2是目錄文件"
for file in `ls $2/*.c`
do
ls -l $file
done
else test -e $2 || echo "This file is not exist"
fi
$./test.sh ddd.c test
test是目錄文件
-rw-rw-r--. 1 flycat flycat 0 1月 1 21:20 test/aaa.c
-rw-rw-r--. 1 flycat flycat 0 1月 1 21:20 test/bbb.c
-rw-rw-r--. 1 flycat flycat 0 1月 1 21:20 test/ccc.c

J. shell編程(條件判斷舉例)

shell 是操作系統的最外層。shell 合並編程語言以控制進程和文件，以及啟動和控制其它程序。shell 通過提示您輸入，向操作系統解釋該輸入，然後處理來自操作系統的任何結果輸出來管理您與操作系統之間的交互。
外文名
shell
類別
操作系統
應用
編程技術
常見
在ARM技術里有很廣的應用
快速
導航
實現方法

編程步驟

常用技巧

編程過程

課程大綱
基本概述
shell 提供了與操作系統通信的方式。此通信以交互的方式（來自鍵盤的輸入立即操作）或作為一個 shell 腳本執行。shell 腳本是 shell 和操作系統命令的序列，它存儲在文件中。
當登錄到系統中時，系統定位要執行的 shell 的名稱。在它執行之後，shell 顯示一個命令提示符。普通用戶的此提示符通常是一個 $（美元符）。當提示符下輸入命令並按下 Enter 鍵時，shell 對命令進行求值，並嘗試執行它。取決於命令說明，shell 將命令輸出寫到屏幕或重定向到輸出。然後它返回命令提示符，並等待您輸入另一個命令。
命令行是輸入所在的行。它包含 shell 提示符。每行的基本格式如下：
$ 命令參數（一個或多個）
shell 視命令行的第一個字（直到第一個空白空格）為命令，所有後繼字為自變數。
在Windows環境下，不論是使用Visual C++還是Delphi或是其他一些軟體開發工具開發的應用程序，盡管存在著差別，但有一點是相同的：都是運行於Windows操作系統之下的。在程序開發過程中也經常要在自己的應用程序中加入一些Windows系統本身就有的功能，比如文件的拷貝、刪除、查找以及運行程序等等。而這些功能在Windows操作系統下都是具備的，顯然如果能直接從系統中調用這些功能將不僅僅減少程序的大小和開發人員的工作量，而且由於是直接通過操作系統來完成這些功能，將會大大減小這部分程序出現異常錯誤的概率。Windows系統雖說也存在不少錯誤，但常用功能的錯誤還是比較少的，而且通過補丁程序可以更低限度減少系統錯誤，因此程序員可以將調試檢錯的注意力放在應用程序的其他地方，對於調用系統功能這部分代碼則可以不必投入太大的精力去調試，因為這部分調試的工作在操作系統發布的時候就已經由微軟做好了。本文通過外殼編程，實現了搜尋文件、運行程序、控制工具條、最大最小化窗口的功能。
實現方法
前面所說的直接使用Windows操作系統部分功能的編程方法就是針對Windows操作系統外殼的編程，可以通過對操作系統提供的幾個編程介面對操作系統的部分功能進行調用，甚至可以按照自己的意圖在應用程序中對部分功能進行修改、擴展。但這方面的資料介紹不是特別多，講的也大都語焉不詳，而且用通常的編程方法去進行外殼編程是非常麻煩的，動輒就要對相關的結構對象進行設置，而這樣的結構里的數據成員少則十來個多則幾十個，因此配置起來非常煩瑣，下面就以一個比較簡單的外殼操作--拷貝文件進行舉例說明：
……
SHFILEOPSTRUCT FileOp; //外殼的文件操作結構
FileOp.hwnd=m_hWnd; //設置句柄
//設置操作方式，拷貝用FO_COPY，刪除用 FO_DELETE
FileOp.wFunc=FO_COPY;
FileOp.pFrom=m_source; //源文件路徑
FileOp.pTo=m_detect; //目標文件路徑
FileOp.fFlags=FOF_ALLOWUNDO; //允許恢復
FileOp.hNameMappings=NULL;
FileOp.lpszProgressTitle=strTitle; //設置標題
SHFileOperation(&FileOp); //執行外殼拷貝
if(FileOp.fAnyOperationsAborted) //監測有無中止
TRACE("An Operation was aborted!!!\n");
……
謝謝