第十三章 总结
shellscript
shell script是利用shell的功能所写的一个“程序”(program),这个程序是使用纯文本文件,将一些shell的语法与命令(含外部命令)写在里面,搭配正则表达式,管道命令与数据流重定向等功能,以达到我们所想要的处理目的。
shell script就像早期DOS年代的批处理文件(.bat),最简单的功能就是将许多命令写在一起,让用户轻易就能够一下子处理复杂的操作(执行一个文件“shell script”,就能够一次执行多个命令)。而且shell script更提供数组、循环、条件与逻辑判断等重要功能,让用户也可以直接以shell来编写程序,而不必使用类似C程序语言等传统程序编写的语法。
shell script可以简单被看成是批处理文件,也可以被说成是一个程序语言,且这个程序语言由于都是利用shell与相关工具命令,所以不需要编译即可执行,且拥有不错的排错工具,所以它可以帮助系统管理员快速管理好主机。
学习shellscript的原因
² 自动化管理的重要依据
² 追踪与管理系统的重要工作
² 简单入侵检测功能
² 连续命令单一化
² 简易的数据处理
² 跨平台支持与学习历程较短
shellscript用在系统管理上面是很好的一项工具,但是用在处理大量数值运算上,就不够好了,因为shell script的速度较慢,且使用的CPU资源较多,造成主机资源的分配不良。
script的编写与执行
shell script是纯文本文件,可以编辑这个文件,然后让这个文件来帮我们一次执行多个命令,或者是利用一些运算与逻辑判断来帮助我们达成某些功能。故要编辑这个文件的内容时,就需要具备bash命令执行的相关知识。
在shell script的编写中,需要注意以下事项:
² 命令的执行是从上而下的、从左而右地分析与执行
² 命令的执行就如同前面提到的:命令,参数间的多个空白都会被忽略掉
² 空白行也将被忽略掉,并且[Tab]按键所得到的空白同样视为空格键
² 如果读取到一个Enter符号(CR),就尝试开始执行该行(或该串)命令
² 至于如果一行的内容太多,则可以使用”\Enter“来扩展至下一行
² “#”可作为批注。任何加在#后面的数据将全部被视为批注文件而忽略。
综上,在script内所编写的程序就会被一行一行执行。那么shell如何执行,其实很简单(以/home/dmtsai/shell.sh为例):
² 直接命令执行:shell.sh文件必须具备可读与可执行(rx)的权限,然后:
n 绝对路径:使用/home/dmtsai/shell.sh来执行命令
n 相对路径:假设工作目录在/home/dmtsai/,则使用./shell.sh来执行
n 变量PATH功能:将shell.sh放在PATH指定的目录内,如~:/bin/。
² 以bash进程来执行:通过bashshell.sh或sh shell.sh来执行
重点是让那个shell.sh内的命令可以被执行。若shell.sh在~/bin内具有rx的权限,那就直接输入shell.sh即可执行该脚本程序。
sh shell.sh可以执行原因:/bin/sh其实就是/bin/bash(连接文件),使用shshell.sh即告诉系统,要直接以bash的功能来执行shell.sh这个文件内的相关命令,故此时shell.sh只要有r的权限即可被执行。也可以利用sh的参数,如-n及-x来检查与追踪shell.sh的语法是否正确。
编写第一个script
mkdir scripts;
cd scripts
vi sh01.sh
输入内容如下:
#!/bin/bash
# Program:
# This program shows "hello world!" in your screen.
# History:
# 2016/07/03 yzhang First Release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo -e "hello world! \a \n"
exit 0
将所编写的scripts放置在主文件的~/scripts目录下,便于管理。下面对程序分段进行说明:
² 第一行#!/bin/bash声明这个script使用的shell命令
因为使用的是bash,故必须要以”#!/bin/bash”来声明这个文件内的语法使用bash的语法。当程序被执行时,他就能够加载bash的相关环境配置文件(一般来说就是non-login shell的~/.bashrc),并且执行bash来使下面的命令能够执行。这很重要(在很多情况中,如果没有设置好这一行,那么改程序很可能无法执行,因为系统可能无法判断改程序需要使用什么shell来执行)。
² 程序内容的说明
在scripts中,除了第一行的#!是用来声明shell的之外,其他的#都是批注的用途。上面程序中,第二行以下使用来说明整个程序的基本数据。一般来说,建议一定要养成说明该script的内容与功能,版本信息,作者与联系方式,建立日期,历史记录等习惯。这有助于将来程序的改写与调试。
² 主要环境变量的声明
建议务必要将一些重要的环境变量设置好。PATH与LANG是其中最重要的。如此,程序在进行时可以直接执行一些外部命令,而不必写绝对路径。
² 主要程序部分
就是主要的程序。
² 告知执行结果
可以使用$?来查看命令是否正确执行。也可以利用exit这个命令来让程序中断,并且回传一个数值给系统。在scripts中,可以使用exit回传一个数值给系统。利用exit n(n是数字)的功能,可以自定义错误信息,让程序变得更加聪明。
执行shell脚本,可以使用sh sh01.sh来实现。此外,也可以使用chmod a+x sh01.sh; ./sh01.sh来执行。
编写shellscript的良好习惯
在每个script的文件头处记录好:
² Script的功能
² Script的版本信息
² Script的作者与联系方式
² Script的版权声明方式
² Script的History(历史记录)
² Script内较特殊的命令,使用绝对路径的方式来执行
² Script执行时需要的环境变量预先声明与设置。
² 此外,建议特殊的程序代码,加上批注信息。程序编写最好使用嵌套方式,最好能以tab按键的空格缩排,这样程序代码会漂亮有条理。此外,编写script的工具最好使用vim而不是vi,因为vim会有额外的语法检查机制,能够在第一阶段编写时就发现语法方面的问题。
简单shell编写
交互式脚本:变量内容由用户决定
很多时候需要用户输入一些内容,好让程序可以顺利执行。这就体现了交互式编程。下面以read命令的用途,编写一个script,它可以让用户输入first name与last name,并且在屏幕上显示“”Your full name is:”的内容:
!#/bin/bash
# program:
# user inputs his first name and last name. Program shows his full name.
# History:
# 2016/07/03 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "please input your first name: " firstname #提示用户输入
read -p "Please input your last name: " lastname #提示用户输入
echo -e "\nYour full name is: $firstname $lastname" #结果由屏幕输出
执行上面脚本,就能够发现用户自己输入的变量可以让程序所使用,并且显示到屏幕上。
随日期变化:利用日期进行文件的创建
假设服务器内有数据库,数据库每天的数据都不太一样,备份时,希望将每天的数据都备份成不同的文件名,此时利用日期保存文件很重要。举例如下:假设想创建三个空的文件(通过touch)文件名最开头由用户输入决定,假定用户输入filename好了,那今天的日期是2016/7/3,想以前天,昨天,今天的日期来创建这些文件,即filename_20160702,filename_21-0160703,filename_2016/07/04,其实现如下:
#!/bin/bash
# Program:
# Program creates three files, which named by user's input and data commond.
# History:
# 2016/07/03 Yzhang First Release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
# 1.让用户输入文件名,并取得fileuser这个变量
echo -e "I will user 'touch' command to create 3 files." #纯粹显示信息
read -p "Please input your filename: " fileuser #提示用户输入
# 2.为了避免用户随意按Enter,利用变量功能分析文件是否由设置
filename=${fileuser:-"filename"} #开始判断有否配置文件名
# 3.开始利用date命令来取得所需要的文件名
date1=$(date --date='2 days ago' +%Y%m%d) #前两天的日期
date2=$(date --date='1 days ago' +%Y%m%d) #前一天的日期
date3=$(date +%Y%m%d) #今天的日期
file1=${filename}${date1}
file2=${filename}${date2}
file3=${filename}${date3}
# 4.创建文件名
touch "$file1"
touch "$file2"
touch "$file3"
上面的script中用到了命令$(command)取得信息、变量的设置功能,变量的累加以及利用touch命令辅助等。
数值运算:简单的减少乘除
可以使用declare来定义变量的类型。当变量定义成为整数后才能够进行加减运算。此外,可以用$((计算式))来进行数值运算。bash shell里头默认仅支持到整数的数据而已。下面,通过用户输入两个变量,然后对其进行相乘输出,实现如下:
#!/bin/bash
#program:
# User inputs 2 integer numbers; program will cross these two numbers.
# History:
# 20160703 Yzhang First Release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo -e "You should input 2 numbers, I will cross them! \n"
read -p "first number: " firstnu
read -p "second number: " secnu
total=$(($firstnu*$secnu))
echo -e "\nThe result of $firstnu * $secnu is ==> $total"
可以使用”declare–I total=$firstnu*secnu”,也可以使用上面的方式进行。不过建议使用var=$((运算内容)),原因是容易记忆,也较方便。计算13与3的余数:echo $((13%3))
Script的执行方式区别
不同的script执行方式会造成不一样的结果,脚本的执行除了上面介绍的,还可以用source或小数点( . )来执行。
利用直接执行的方式来执行script
当使用前面提到的直接命令执行(不论是绝对路径/相对路径还是$PATH内),或者是利用bash(或sh)来执行脚本时,该script都会使用一个新的bash环境来执行脚本内的命令。即使用这种执行方式时,其实script是在子进程的bash内执行的。当子进程完后,子进程内的各项变量或操作将会结束而不会传回到父进程中。
上面运行sh02.sh时,用到的变量firstname和lastname,在父进程中不能执行,如执行echo $firstname和$lastname将显示两个变量不存在。
利用source来执行脚本:在父进程中执行
如果用source执行命令,则不一样。
如source sh02.sh
此时如输入用户名,当执行完成后,在shell下执行echo $firname $lastname则有数据产生,为输入的名字值。
当不注销系统而要让某些写入~/.bashrc设置生效时,需要使用source ~/.bashrc而不能使用bash~/.bashrc。
善用判断式
可以使用S?等来进行判断,但是可以通过test进行更简单的判断。
利用test命令的测试功能
当要检测系统上面某些文件或者是相关的属性时,利用test这个命令来工作真是好用得不得了,如检查/dmtsai是否存在时,使用:test –e /dmtsai
上面的执行结果并不会显示任何信息,但最后可以通过$?或&&及||来显示整个结果。
test –e /dmtsai && echo “exist” ||echo “Not exist”
最终结果可以显示exist还是not exist。-e是测试一个东西存在不存在。常用的测试命令如下:
测试的标志 |
代表意义 |
关于某个文件名的“文件类型”判断,如test – e filename表示存在否 |
|
-e |
该文件名是否存在 |
-f |
该文件名是否存在且为文件(file) |
-d |
该文件名是否存在且为目录(directory) |
-b |
该文件名是否存在且为一个block device设备 |
-c |
该文件名是否存在且为一个character device设备 |
-S |
该文件名是否存在且为一个Socket文件 |
-p |
该文件名是否存在且为一个FIFO(pipe)文件 |
-L |
该文件名是否存在且为一个连接文件 |
关于文件的权限检测,如test –r filename表示可读否(但root权限常有例外) |
|
-r |
检测该文件名是否存在且具有“可读”的权限 |
-w |
检测该文件名是否存在且具有“可写”的权限 |
-x |
检测该文件名是否存在且具有“可执行”的权限 |
-u |
检测该文件名是否存在且具有“SUID”的属性 |
-g |
检测该文件名是否存在且具有“SGID“的属性 |
-k |
检测该文件名是否存在且具有“Sticky bit”的属性 |
-s |
检测该文件名是否存在且具有“非空白文件” |
两个文件之间的比较,如test file1 –nt file2 |
|
-nt |
(newer than)判断file1是否比file2新 |
-ot |
(older than)判断file1是否比file2旧 |
-ef |
判断file1与file2是否为同一文件,可用在判断hard link的判定上。主要意义在于判定两个文件是否均指向同一个inode |
关于两个整数之间的判定吗,如test n1 –eq n2 |
|
-eq |
两数值相等(equal) |
-ne |
两数值不等(not equal) |
-gt |
N1大于n2(greate than) |
-lt |
N1小于n2(less than) |
-ge |
N1大于等于n2(greater than or equal) |
-le |
N1小于等于n2(less than or equal) |
判定字符串的数据 |
|
test –z string |
判定字符串是否为0,若string为空字符串,则为true |
test –n string |
判定字符串是否非为0,若string为空字符串,则为false |
test str1 = str2 |
判定str1是否等于str2,若相等,则回传true |
test str1 != str2 |
判定str1是否不等于str2,若相等,则回传false |
多重条件判定,若test –r filename –a –x filename |
|
-a |
两个条件同时成立!如test –r file –a –x file,则file同时具有r与x权限时,才回传true |
-o |
任何一个条件成立!如test –r file –o –x file,则file具有r或x权限时,就可回传true |
! |
反向状态,如test ! –x file,但file不具有x时,回传true |
下面利用test编写简单例子。首先判断一下,让用户输入一个文件名,判断如下:
² 这个文件是否存在,若不存在则给予一个“Filename does not exist”的信息,并中断程序
² 若文件存在,则判断它是个文件或目录,结果输出“Filename isregular file”或“Filename is directory”
² 判断一下,执行者的身份对这个文件或目录所拥有的权限,并输出权限数据。
#!/bin/bash
# Program:
# User input a filename, program will check the following:
# 1) exist? 2) file/directory? 3) file permissions
# History:
# 2016/07/03 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
# 1.让用户输入文件名,并且判断用户是否真的输入字符串
echo -e "Please input a filename, I will check the filename's type and permission. \n\n"
read -p "Input a filename: " filename
test -z $filename && echo "You Must input a filename." && exit 0
# 2.判断文件是否存在,若不存在则显示信息并结束脚本
test ! -e $filename && echo "The filename '$filename' DO NOT exist" && exit 0
# 3.开始判断文件类型和属性
test -f $filename && filetype='regulare file'
test -d $filename && filetype='directory'
test -r $filename && perm="readable"
test -w $filename && perm="$perm writable"
test -x $filename && perm="$perm executable"
# 4.开始输出信息
echo "The filename: $filename is $filetype"
echo "And the permissions are : $perm"
注意:由于root在很多权限的限制上面都是无效的,所以使用root执行这个脚本时,常常会发现与ls –l观察到的结果并不相同。建议使用一般用户执行此脚本。
利用判断符号[]
除了利用test外,还可以使用判断符号[]来进行数据的判断。例如想知道$HOME这个变量是否为空,可以执行如下命令:
[ -z "$HOME" ] ; echo $?
使用中括号必须要特别注意,因为中括号用在很多地方,包括统配符和正则表达式等,所以如果要在bash的语法当中使用中括号作为shell的判断式时,必须要注意中括号的两端需要有空格符来分割。
在bash当中,=号与==号的结果一样。
判断两个字符串是否相等,可以使用如下命令
[ “$HOME” == “$MAIL” ] 相当于test$HOME=SMAIL。如果没有空格,则bash将会显示错误信息。故注意如下:
² 在中括号[]没的每个组件都需要有空格键来分割;
² 在中括号内的变量,最好都以双引号括起来
² 在中括号内的变量,最好都以单或双引号括起来。
中括号使用的方法与test几乎一模一样。只是中括号比较常用在条件表达式if then fi的情况中。举例如下:
² 执行一个程序时,程序让用户选择Y或N
² 如果用户输入Y或y时,显示“OK, continue”
² 如果用户输出N或n时,显示“Ok, interrupt!”
² 如果用户输入不是Y,y,N,n之内的其他字符,显示“Idon’t know“,利用中括号,&&和||实现。
#!/bin/bash
# Program:
# This programs shows the user's choice
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input (Y/N) :" yn
[ "$yn" == "Y" -o "$yn" == "y" ] && echo "OK, continue." && exit 0
[ "$yn" == "N" -o "$yn" == "n" ] && echo "Oh, interrupt!" && exit 0
echo "I don't know what your choice is" && exit 0
其中的-o(或)连接两个判断。
Shellscript的默认变量($0, $1, …)
重新启动系统注册表文件的功能,使用如下命令
file /etc/init.d/syslog 使用file来查询后,系统告知这个文件是个bash的可执行script、
/etc/init.d/syslog restart
上面中,restart是重新启动之意,可以重新启动/etc/init.d/syslog这个程序。
script针对参数设置好的一些变量名称如下:
/path/to/scriptname opt1 opt2 opt3 opt4
$0 $1 $2 $3 $4
执行的脚本名为$0这个变量,第一个参数接的就是$1。在script中善用$1,就可以简单执行某些命令的功能。此外,还有一些较为特殊的变量可以在script内使用来调用这些参数。
² $#:代表后接的参数“个数”
² $@:代表”$1” “$2” “$3” “$4”之意,每个变量是独立的(用双引号括起来)
² $*:代表“”$1c$2c$3c$4“”,其中c为分割字符,默认为空格键,所以本例代表““$1 $2 $3 $4””之意。
其中,$@与$*基本上还是有所不同。不过,一般情况下可以直接记忆$@即可。举例:假设执行一个可以携带参数的script,执行该脚本后屏幕显示如下数据:
² 程序的文件名
² 共有几个参数
² 若参数的个数小于2则告知用户参数太少
² 全部的参数内容
² 第一个参数
² 第二个参数
#!/bin/bash
# Program:
# Program shows the script name, parameters...
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo "The script name is ===> $0"
echo "Total paramter number is ===> $#"
[ "$#" -lt 2 ] && echo "The number of parameter is less than 2. Stop here." && exit 0
echo "Your whole parameter is ===> '$@'"
echo "The 1st parameter ===> $1"
echo "The 2st parameter ===> $2"
脚本执行如下:
shsh07.sh theone haha quot
shift:造成参数变量号码偏移
改上面程序如下:
#!/bin/bash
# Program:
# Program shows the script name, parameters...
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo "Total paramter number is ===> $#"
echo "Your whole parameter number is ===> '$@'"
shift #进行第一次“一个变量的shift”
echo "Total paramter number is ===> $#"
echo "Your whole parameter number is ===> '$@'"
shift 3 #进行第二次“三个变量的shift”
echo "Total paramter number is ===> $#"
echo "Your whole parameter is ===> '$@'"
程序执行如下:
shsh07.sh one two three four five six
shift会移动变量,而且shift后面可以接数字,代表拿掉最前面的几个参数。执行结果,第一次shift后,显示情况是twothree four fix six,第二次拿掉三个后,显示为five six。
条件判断式
利用if…then
这个if…then是最常见的条件判断式。简单说,就是当符合某个条件判断的时候,就进行某些工作。If…then的判断还有多层次的情况。分别如下:
单层、简单条件判断式
如果只有一个判断式要进行,则可以简单这样:
if [条件判断式]; then
当条件判断成立时,可以进行的命令功能内容
fi 结束if之意。
其中条件判断的方法与上面介绍的相同。当有多个判断时,多个条件写入一个中括号内,也可以多个中括号,括号之间则以&&或||来隔开,意义:
&&代表AND
||代表or
如[ “$yn” == ”Y” –o “$yn” == ”y”] 可以写成 [ “$yn == ”Y”]|| [ “$yn” == ”y”]
使用条件实现程序如下:
#!/bin/bash
# Program:
# This programs shows the user's choice
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input (Y/N) :" yn
if [ "$yn" == "Y" ] || [ "$yn" == "y" ]; then
echo "OK"
exit 0
fi
if [ "$yn" == "N" ] ||[ "$yn" == "n" ]; then
echo "Oh interrupt"
exit 0
fi
echo "I don't know what your choice is" && exit 0
多重、复杂条件判断式
在一个程序中,如果使用多重条件判断,可以使用如下语法:
#一个条件判断
if [ 条件判断式 ]; then
当条件判断式成立时,可以进行的命令工作内容;
else
当条件判断式不成立时,可以进行的命令工作内容;
fi
#多个条件判断(if … elif …else)分多种不同情况执行
if [条件判断式一 ]; then
当条件判断式一成立时,可以进行的命令工作内容
elif [ 条件判断式二 ] ; then
当条件判断式二成立时,可以进行的命令工作内容
else
当条件判断式一与二均不成立时,可以进行的命令工作内容;
fi
注意:elif也是个判断式,因此出现elif后面都接then来处理。但是else已经是最后的没有成立的结果了,所以else后面并没有then。
#!/bin/bash
# Program:
# This programs shows the user's choice
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input (Y/N) :" yn
if [ "$yn" == "Y" ] || [ "$yn" == "y" ]; then
echo "OK"
elif [ "$yn" == "N" ] ||[ "$yn" == "n" ]; then
echo "Oh interrupt"
else
echo "I don't know what your choice is" && exit 0
fi
上面程序变得简单,且依序判断,可以避免掉重复判断的状况,且容易设计程序。
如果不希望用户由键盘输入额外的数据时,可以使用上一节提到的参数功能($1)让用户在执行命令时就将参数代进去。现想让用户输入hello这个关键字,利用参数的方法可以这样依序设计:
1) 判断$1是否为hello,如果是的话,显示“hello”
2) 如果没有加任何参数,就提示用户必须要使用的参数;
3) 而如果加入的参数不是hello,就提醒用户仅能使用hello为参数。
整个程序的编写可以如下:
#!/bin/bash
# Program:
# Check $1 is equal to "hello"
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
if [ "$1" == "hello" ]; then
echo "hello"
elif [ "$1" == "" ]; then
echo "Your must input parameters, ex> {$0 someword}"
else
echo "The only parameter is ‘hello', ex> {$0 hello}"
fi
netstat命令,可以查询到目前主机打开的网络服务端口(service ports),可以使用netstat –tuln来取得目前主机有启动的服务。
IP地址为127.0.0.1是针对本机开放,而0.0.0.0则代表对整个Internet开发。每个端口(port)都有其特定的网络服务,常见的port现骨干网络服务关系如下:
80:www
22:ssh
21:ftp
25:mail
111:RPC(远程过程调用)
631:CUPS(打印服务功能)
编写脚本,实现检测常见的端口(21,22,80)服务开启情况。具体如下:
#!/bin/bash
# Program:
# Using netstat and grep to detect www,ssh,ftp and mail services.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
# 1. 先做一些告知的操作而已~
echo "Now, I will detect your Linux server's services"
echo -e "The www, ftp, ssh, and mail will be detect! \n"
# 2. 开始进行一些测试的工作,并且输出一些信息
testing=$(netstat -tuln | grep ":80 ")
if [ "$testing" != "" ]; then
echo "www is running"
fi
testing=$(netstat -tuln | grep ":22")
if [ "$testing" != "" ]; then
echo "ssh is running"
fi
testing=$(netstat -tunl | grep ":21")
if [ "$testing" != "" ]; then
echo "ftp is running"
fi
中国当兵时公民应尽的义务,不过,在当兵的是否总想退伍,可以编写脚本计算退伍时间.
1) 想让用户输入退伍时间
2) 在由现在日期对比退伍日期
计算所需天数。#!/bin/bash
# Program:
# You input demobilization date, I calculate how many days before you demobilize.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/urs/local/sbin:~/bin
export PATH
# 1 告知用户程序的用途,并且告知应该如何输入日期格式
echo "This program will try to calculate :"
echo "How many days before your demobilization date..."
read -p "Please input your demobolization date (YYYYMMDD ex>20160704): " date2
# 2 利用正则表达式测试一下这个输入内容是否正确
date_d=$(echo $date2 | grep '[0-9]\{8\}')
if [ "$date_d" == "" ]; then
echo "input wrong"
exit 1
fi
# 3 开始计算日期
declare -i date_dem=`date --date="$date2" +%s`
declare -i date_now=`date +%s`
declare -i date_total_s=$(($date_dem - $date_now))
declare -i date_d=$(($date_total_s/60/60/24))
if [ "$date_total_s" -lt "0" ]; then
echo "you need demobilization before $((-1*$date_d)) ageo"
else
declare -i date_h=$(($(($date_total_s-$date_d*60*60*24))/60/60))
echo "you will demobilize after $date_d days and $date_h hours."
fi
利用case…esac判断
case是针对两个变量,多种情况进行的判断,其语法如下:
case $环境名称 in < == 关键字符为case,还有变量前有$
“第一个变量内容”) < == 每个变量内容建议用双引号括起来,关键字则为小括号)
程序段
;; < == 每个类型结尾使用两个连续的分号来处理
“第二个变量内容“”)
程序段
;;
*) < == 最后一个变量内容都会用*来代表所有其他值
不包含第一个变量内容与第二个变量内容的其他程序程序执行段
exit1
;;
esac
注意:case语法中,是以case为开头的,而其结束为esac(反写)。此外,对每个变量内容的程度段最后都需要两个分号(;;)来代表该程序段落的结束。至于这个变量内容的最后使用*,是因为如果用户输入第一个或第二个变量内容时,可以告知用户相关信息。
举例如下:
#!/bin/bash
# Program:
# Show "Hello" from $1... by using case ... esac
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
case $1 in
"hello")
echo "Hello, how are you?"
;;
"")
echo "You must input parameters, ex> {$0 someword}"
;;
*)
echo "Usage $0 {hello}"
;;
esac
上面的程序编写很简单明了,系统的很多服务的启动script都是使用这种写法的。例如/etc/init.d中的syslog服务,重启这个服务使用下列命令:/etc/init.d/syslog restart,其中重点是restart,可以使用less/etc/init.d/syslog来查阅,其中就用到了case的语法,并且规定某些既定的变量内容,可以直接执行/etc/init.d/syslog,此script就会告知后续变量可以使用情况。
一般来说,使用“case $变量in”这个语法中,当中的那个”$变量”大致有两种取得的方式:
² 直接执行式:如上面的就直接使用$1这个变量的内容,这也是在/etc/init.d目录下大多数程序的设计方式。
² 交互式:通过read这个命令来让用户输入变量的内容。举例如下:
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo "This program will print your selection!"
# read -p "Input your choice:" choice
# case $choice in
case $1 in
"one")
echo "Your choice is one"
;;
"two")
echo "Your choice is two"
;;
"three")
echo "Your choice is three"
;;
*)
echo "Usage $0 {one | two | three}"
;;
esac
上面程序使用的是非交互式,要使用交互式,则把其中#取消,把下面的case $1 in进行注释,即可实现。
利用function功能
什么是函数(function)功能?简单地说,其实,函数就是可以在shell script当中做出一个类似自定义命令的东西,最大的功能是,可以简化很多程序代码。Function的语法如下:
function fname()
{
程序段
}
fname是自定义的执行命令名称,程序段是要执行的内容。注意:因为shell script的执行方式是由上而下、由左而右,因此在shell script当中的function的设置一定要在程序的最前面,这样才能够在执行时被找到可用的程序段。下面是程序的编写:
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
function printit()
{
echo -n "Your choice is "
}
echo "This program will print your selection!"
case $1 in
"one")
printit; echo $1 | tr 'a-z' 'A-Z'
;;
"two")
printit; echo $1 | tr 'a-z' 'A-Z'
;;
"three")
printit; echo $1 | tr 'a-z' 'A-Z'
;;
*)
echo "Usage $0 {one | two | three}"
;;
esac
上面的程序执行中,在case的one,two,three情况下,调用printit函数。
另外,function也是拥有内置变量的。它的内置变量与shell script很类似,函数名称表示$0,而后续接的变量也是以$1,$2…来替代的。
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
function printit()
{
echo -n "Your choice is $1 " #这个$1必须要参数下面命令的执行
}
echo "This program will print your selection!"
case $1 in
"one")
printit 1 #请注意,printit命令后面还有接参数
;;
"two")
printit 2
;;
"three")
printit 3
;;
*)
echo "Usage $0 {one | two | three}"
;;
esac
循环(loop)
循环可以不断地执行某个程序段落,直到用户设置的条件达成为止。其重点是条件的完成是什么。除了这种依据判断式达成与否的不定循环之外,还有另外一种已经固定要跑多少次的循环,可称为固定循环状态。
whiledo done, until do done(不定循环)
一般来说,补丁循环最常见的状态就是下面两种:
while [condition] < === 中括号内的状态就是判断式
do < === 循环的开始
程序段落
done < === 循环的结束
这种循环,当condition条件成立时,就进行循环,直到condition的条件不成立才停止。
不定循环
until [condition]
do
程序段
done
这种方式与while相反,当condition条件成立时,就终止循环,否则就持续进行循环的程序段。
while循环
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
while [ "$yn" != "yes" -a "$yn" != "YES" ]
do
read -p "Please input yes/YES to stop this program: " yn
done
echo "OK! you input the correct answer."
until循环
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
until [ "$yn" == "yes" -o "$yn" == "YES" ]
do
read -p "Please input yes/YES to stop this program: " yn
done
echo "OK! you input the correct answer."
计算1+2+…+100
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
s=0
i=0
while [ "$i" != "100" ]
do
i=$(($i+1))
s=$(($s+$i))
done
echo "The result of '1+2+3+...+100' is ===> $s"
for…do…done(固定循环)
相对于while,until的循环方式是必须要“符合某个条件”的状态,for这种语法则是“已经知道要进行几次循环”的状态。语法如下:
for var in con1 con2 con3…
do
程序段
done
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
for animal in dog cat elephant
do
echo "Three are ${animal}s..."
done
利用循环处理获取/etc/passwd并使用循环处理的方法。
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
users=$(cut -d ':' -f1 /etc/passwd)
for username in $users
do
id $usrname
echo $username
done
使用ping命令,判断网络状态。进行网络状态的实际检测时,要检测的域是本机所在的192.168.1.1~192.168.1.100,由于有100台主机,可以利用循环来实现,具体如下:
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
network="192.168.1"
for sitenu in $(seq 1 100)
do
ping -c 1 -w 1 ${network}.${sitenu} &> /dev/null && result=0 || result=1
if [ "$result" == 0 ]; then
echo "Server ${network}.${sitenu} is UP."
else
echo "Server ${network}.${sitenu} is Down."
fi
done
实现判断式上循环功能。让用户输入某个目录文件名,然后找出某目录内的文件名的权限,其实现如下:
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
# 1 先看看这个目录是否存在
read -p "Please input a directory: " dir
if [ "$dir" == "" -o ! -d "$dir" ]; then
echo "The $dir is NOT exist in your system."
exit 1
fi
# 2 开始测试文件
filelist=$(ls $dir)
for filename in $filelist
do
perm=""
test -r "$dir/$filename" && perm="$perm readable"
test -w "$dir/$filename" && perm="$perm writable"
test -e "$dir/$filename" && perm="$perm executable"
echo "The file $dir/$filename's permission is $perm"
done
for…do…done的数值处理
for ((初始值; 限制值; 执行步长))
do
程序段
done
这种语法适合于数值方式的运算当中,在for后面的括号内的三串内容意义为:
² 初始值:某个变量在循环当中的初始值,直接以类似i=1设置好;
² 限制值:当变量的值在这个限制值的范围内,就继续进行循环,例如,i<=100;
² 执行步长:没做一次循环时变量的变化量。如i=i+1。
#!/bin/bash
# Program:
# This script only accept the flowing parameter: one two or three.
# History:
# 2016/07/04 Yzhang First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input a number, I will count for 1+2+...+your_input: " nu
s=0
for((i=1; i<=$nu; i++))
do
s=$(($s+$i))
done
echo "The result of '1+2+3+...+$nu' is ====> $s"
shellscript的追踪与调试
script在执行之前,最怕的就是出现语法错误问题。可以使用bash相关的参数进行判断语法问题。
sh [-nvx] scripts.sh
参数:
-n:不要执行script,仅查询语法的问题;
-v:在执行script前,先将script的内容输出到屏幕上
-x:将使用到的script内容显示到屏幕上,这是很有用的信息。
测试是否存在语法问题,可以使用如下命令:
sh –n sh16.sh
将sh15.sh的执行过程全部列出来
sh –x sh15.sh
执行上述命令后,输出信息中,在加号后面的数据其实都是命令串,由sh –x的方式来将命令执行过程也显示出来,如此用户可以判断程序代码执行到哪一段时会出现相关的信息。
重点
² shell script是利用shell的功能所写的一个程序(program),这个程序使用纯文本文件,将一些shell的语法与命令(含外部命令)写在里面,搭配正则表达式、管道命令与数据流重定向等功能,以达到我们所想要的处理目的。
² shell script用在系统管理上面是很好的一项工具,但是用在处理大量数值运算上就不够好了,因为shell script的速度较慢,且使用的CPU资源较多,造成主机资源的分配不良。
² 在shell script的文件中,命令是从上而下、从左而右地分析与执行。
² shell script的执行至少需要有r的权限,若需要直接命令执行,则需要拥有r和x的权限。
² 在良好的编程习惯中,第一行要声明shell(#!/bin/bash),第二行以后则声明程序用途、版本、作者等。
² 对交互式脚本可以read命令达成
² 要创建每次执行脚本都有不同结果的数据,可使用date命令利用日期达成。
² script的执行若以source来执行时,代表在父进程的bash内执行之意。
² 若需要进行判断式,可以使用test或中括号([])来处理。
² 在script内,$0, $1, $2,…, $@是有特殊意义的。
² 条件判断式可使用if…then来判断,若是固定变量内容的情况下,可使用case $var in easc来处理。
² 循环主要分为不定循环(while, until)以及固定循环(for),配合do,done来达成所需任务。
² 可以使用sh –x script.sh来进行程序的调试。