内容来源:shell编程其实真的很简单（一）
几个面试官常问的Shell脚本编写
【Linux】肝！Shell 脚本编程最佳实践
基础概念
什么是shell编程？
用该作者的话讲：shell编程就是对一堆linux命令的逻辑化处理。
shell编程的好处：
我们完成一项任务的时候，一般会涉及到一系列步骤，比如先执行某个文件，得到中间结果，然后我们再执行另一个程序（上一步的结果作为这里的输入），等等，每次执行该任务的时候都要进行这一系列的操作，甚至涉及到一些软件的启动。在linux下我们可以将这一系列操作写成shell脚本，每次只要执行这个shell脚本就会自动运行一连串操作。省掉重复的人工介入。
shell入门小程序
#!bin/bash
#在屏幕输出'hello world!'
echo hello world!
解释
第一行比较特殊，一般会以#！开始，指明使用的shell类型，linux有很多版本的shell,比如zsh、dash。这是我们选择的是bash shell，这也中用得最多的。
第二行#开始，表示注释。
第三行表示输出串内容，这里是字符串。这其实就是我们平常在linux终端运行的命令。可以看到shell编程最基本的就是利用这些linux命令来实现功能，更复杂一点的也就是加入for 这些程序控制的结构。
运行shell脚本
将上面的功能代码保存成helloWorld.sh文件，当用户具有权限时，.sh文件在linux上可以运行。
给予文件可执行权限
chmod +x helloWorld.sh
直接在shell中./helloworld.sh时，系统会自动使用shell去跑这个文件中的指令。注意文件路径，如果不加./，则会到环境变量中去寻找该文件或者叫程序，这时找不着就会报错。
我们也可以指定运行程序的shell类型
/bin/sh helloWorld.sh
加入更多功能
变量
shell中的变量有两类：系统变量、自定义变量。
#!bin/bash
#使用环境变量
echo $PATH
#自定义变量
a="hello world!"
echo a
注意：定义变量时不需要$,使用变量的时候要加$；=号的两侧不要有空格；将字符串赋给变量时可以不加引号，但如果字符串中间有空格或引号，那么一定要加引号。
将linux执行结果赋给变量
#!bin/bash
#两种将命令执行结果赋给变量的方法
path=$(pwd)
files=`ls -al`
echo current path:$path
echo files:$files
算术及逻辑运算
| 符号 | 语义 | 描述 |
|---|---|---|
| + | 加 | 10+10，结果为20 |
| - | 减 | 10-3， 结果为7 |
| * | 乘 | 10*2，结果为20 |
| / | 除 | 10/3, 结果为3（取整数） |
| % | 求余 | 10%3, 结果为1 (取余数) |
| == | 判断是否相等 | 两数相等返回1，否则0 |
| != | 判断是否不等 | 两数不等返回1，否则0 |
| > | 大于 | 前者大于后者返回1，否则0 |
| > = | 大于或等于 | 前者大于或等于后者返回1，否则0 |
| < | 小于 | 前者小于后者返回1，否则0 |
| <= | 小于或等于 | 前者小于或等于后者返回1，否则0 |
| shell中的算术运算分为整数运算和浮点数运算。 | ||
| 整数运算主要通过expr和$[]来实现。第一种方式先不介绍，直接看第二种。 |
#!bin/bash
num1=10
num2=3
echo "num1+num2=$[$num1+$num2]"
echo "num1<num2=$[$num1<$num2]"
#结果为
#num1+num2=13
#num1<num2=0
其实一般也不会在shell里做运算，所以这里不再详细展开。
条件控制
if-then语句
if command
then
commands
fi
if语句后面接的是命令，其它编程语言中，if后接返回布尔值（true,false）的表达式。
shell脚本的if其实是根据紧跟后面的那个命令的退出状态码来判断是否执行then后面的语句的。
关于退出状态码，你只需要记住：正常退出（命令执行正常）的状态码是0， 非正常退出的状态码不是0（有不少）。以上语句的语义为： 如果if后面的命令执行正常（状态码0），那么就执行then后面的语句。否则不执行。 fi代表if语句的结束。
#!/bin/bash
#这儿由于pwd是linux内置的命令，因此执行后会正常退出（状态码0），所以会执行then中的语句
#如果此处替换为一个不存在的命令（例如: pw），那么就会非正常退出，不会执行then中的语句
if pwd
then
echo 执行then里面的语句
fi
执行结果如下：
执行then里面的语句
if-then还可以简写为
if command; then
commands
fi
如果我要判断处理异常退出（状态码非0）情况，该怎么办？
别着急： else 来帮你
if-then-else语句
if command
then
commands
else
commands
fi
#!/bin/bash
if pwd
then
echo 正常退出
else
echo 非正常退出
fi
我们还可以变形写出更多的else:
if command1
then
commands
elif
command2
then
command3
fi
上面就只能根据退出状态码判断，不能写表达式，你还让我怎么写？
test命令
test命令用于if-then或者if-then-else语句中，主要用于判断列出的条件是否成立，如果成立，就会退出并返回退出状态码0，否则返回非0。
if test condition
then
commands
fi
if test condition
then
commands
else
commands
fi
条件成立就执行then语句，否则else语句。
test命令只能判断一下三类条件：
- 数值比较
- 字符串比较
- 文件比较
Linux Shell日期比较，数值比较和字符串比较及相关
数值比较比较 描述 n1 -eq n2 判断n1是否等于n2 n1 -ge n2 判断n1是否大于或等于n2 n1 -gt n2 判断n1是否大于n2 n1 -le n2 判断n1是否小于或等于n2 n1 -lt n2 判断n1是否小于n2 n1 -ne n2 判断n1是否不等于n2 #!/bin/bash num1=100 num2=200 if test $num1 -eq $num2 then echo num1等于num2 else echo num2不等于num2 fi使用双括号
双括号命令允许你在比较过程中使用高级数学表达式。关键是使用双括号，咱就可以用数学比较符号啦（等于==, 大于>， 小于< 等等都能使用啦）。
使用方法：(( expression ))注意：括号里面两边都需要有空格
#!/bin/bash num1=100 num2=200 if ((num1 > num2)) then echo "num1 > num2" else echo "num2 <= num2" fi结果为：num2 <= num2
字符串比较
比较 描述 str1 = str2 判断str1是否与str2相同 str1 !＝ str2 判断str1是否与str2不相同 str1 < str2 判断str1是否比str2小(根据ASCII) str1 > str2 判断str1是否比str2大(根据ASCII) -n str1 判断str1的长度是否非0 -z str1 判断str1的长度是否为0 test命令和测试表达式使用标准的数学比较符号来表示字符串比较,而用文本代码来表 示数值比较。这与其它语言相比都不一样。
#!/bin/bash var1=test var2=Test if test $var1 = $var2 then echo 相等 else echo 不相等 fi结果为：不相等
注意，在使用大于（>）或小于（<）符号时，需要转义（>）(<)，不然会把这两种符号时别为重定向（后面文章才会讲到）。
使用双方括号
双方括号命令提供了针对字符串比较的高级特性。它不仅解决了使用test所带来的一系列毛病，还提供了一些test命令所没有的高级用法。双方括号命令的格式如下:[[ expression ]]注意，可能有些shell不支持此种写法。不过bash完美支持。以上写法注意括号内两边都有空格。
#!/bin/bash var1=test var2=Test if [[ $var1< $var2 ]] then echo "var1< var2" else echo "var1>= var2" fi结果：var1< var2
文件比较
对于文件的比较，其实跟上面差不多，都是用test命令。由于篇幅有限，我这儿就不多写了。通过man test命令可以看到具体的用法。描述 代码 如果 filename存在，则为真 [ -e /var/log/syslog ]-d filename 如果 filename为目录，则为真 [ -d /tmp/mydir ]-f filename 如果 filename为常规文件，则为真 [ -f /usr/bin/grep ]-L filename 如果 filename为符号链接，则为真 [ -L /usr/bin/grep ]-r filename 如果 filename可读，则为真 [ -r /var/log/syslog ]-w filename 如果 filename可写，则为真 [ -w /var/mytmp.txt ]-x filename 如果 filename可执行，则为真 [ -L /usr/bin/grep ]filename1-nt filename2 如果 filename1比 filename2新，则为真 [ /tmp/install/etc/services -nt /etc/services ]filename1-ot filename2 如果 filename1比 filename2旧，则为真 [ /boot/bzImage -ot arch/i386/boot/bzImage ] case语句
在使用if-then-else语句中，如果碰到条件很多的情况，如下：#!/bin/bash num=3 if (( $num == 1 )) then echo "num=1" elif (( $num == 2 )) then echo "num=2" elif (( $num == 3 )) then echo "num=3" elif (( $num == 4 )) then echo "num=4" fi其实还有一种替代方案，那就是使用case.
#!/bin/bash num=3 case $num in 1) echo "num=1";; 2) echo "num=2";; 3) echo "num=3";; 4) echo "num=4";; *) echo "defaul";; esac结果：num=3
不管是command还是test或者(())或者[[]]，从外面看都是成功或为真时执行then后的语句，尽管command正常执行返回为0
for
for循环有两种形式：
for-in语句
基本格式如下：for var in list do commands donelist代表要循环的值，在每次循环的时候，会把当前的值赋值给var（变量名而已，随意定）, 这样在循环体中就可以直接通过$var获取当前值了。
先来一个例子吧：#!/bin/bash for str in a b c d e do echo $str done结果为：
a b c d efor…in循环默认是循环一组通过空格或制表符（tab键）或换行符（Enter键）分割的值。这个其实是由内部字段分隔符配置的，它是由系统环境变量IFS定义的。当然，既然是由环境变量定义的，那当然也就能修改啊。
修改IFS值#!/bin/bash #定义一个变量oldIFS保存未修改前的IFS的值 oldIFS=$IFS #修改IFS值，以逗号为分隔符 IFS=$',' list=a,b,c,d,e list2="a b c d e" for var in $list do echo $var done for var2 in $list2 do echo $var2 done #还原IFS的值 IFS=$oldIFSC语言风格的for循环
bash中c语言风格的for循环遵循如下格式：for (( variable assignment ; condition ; iteration process ))
#!/bin/bash for (( i = 0; i <= 10; i++ )) do echo $i donewhile循环
与其它编程语言while的不同在于：在bash中的while语句，看起来似乎是结合了if-then语句(参考上一篇)和for循环语句。其基本格式如下：while test command do other commands done与if-then语句一样，后面接test命令，如果test后面的命令的退出状态码为0. 那么就进入循环，执行do后面的逻辑。要注意在do后面的逻辑中写条件，避免死循环。
既然是接test命令，那么一切都可以参考if-then的test#!/bin/bash flag=0 while test $flag -le 10 do echo $flag # 如果没有这句，那么flag的值一直为0，就会无限循环执行 flag=$[$flag + 1] done#!/bin/bash flag=0 while [ $flag -le 10 ] do echo $flag flag=$[$flag + 1] doneflag=0 while (( $flag <= 10 )) do echo $flag flag=$[$flag + 1] doneuntil循环语句
until语句基本格式如下：until test commands do other commands done在掌握while循环语句之后， until语句就很简单了。until语句就是与while语句恰好相反， while语句是在test命令退出状态码为0的时候执行循环， 而until语句是在test命令退出状态码不为0的时候执行。
#!/bin/bash flag=0 until (( $flag > 10 )) do echo $flag flag=$[ $flag + 1 ] done控制循环
break
break用于跳出当前循环。#!/bin/bash for (( flag=0; flag <= 10; flag++ )) do if (( $flag == 5 )) then break fi echo $flag done以上当flag的值为5的时候，退出循环。输出结果为0-4的值。
break用于跳出内层循环。#!/bin/bash flag=0 while (( $flag < 10 )) do for (( innerFlag=0; innerFlag < 5; innerFlag++ )) do if (( $innerFlag == 2 )) then break fi echo "innerFlag=$innerFlag" done echo "outerFlag=$flag" done以上代码在执行内部循环for的时候，当innerFlag值为2的时候就会跳出到外层的while循环, 由于外层循环一直flag都为0， 所以while会成为一个死循环，不停的输出:
... innerFlag=0 innerFlag=1 outerFlag=0 ...break用于跳出外层循环
break 可后接数字，用于表示退出当前循环的外层的第几层循环。#!/bin/bash flag=0 while (( $flag < 10 )) do for (( innerFlag=0; innerFlag < 5; innerFlag++ )) do if (( $innerFlag == 2 )) then # 2表示外面一层循环 break 2 fi echo "innerFlag=$innerFlag" done echo "outerFlag=$flag" done与上面例子相比，本例就只是在break后面跟了个数字2，表示退出外面的第一层循环。最终输出：
innerFlag=0 innerFlag=1continue
continue表示终止当前的一次循环，进入下一次循环，注意,continue后面的语句不会执行。
continue的语法与break一样。flag=0 while (( $flag <= 10 )) do if (( $flag == 5 )) then flag=$[$flag+1] continue fi echo "outerFlag=$flag" for (( innerFlag=11; innerFlag < 20; innerFlag++ )) do if (( $innerFlag == 16 )) then flag=$[$flag+1] continue 2 fi echo "innerFlag=$innerFlag" done donelinux定时任务
来源
linux 系统则是由 cron (crond) 这个系统服务来控制的。Linux 系统上面原本就有非常多的计划性工作，因此这个系统服务是默认启动的。另 外, 由于使用者自己也可以设置计划任务，所以， Linux 系统也提供了使用者控制计划任务的命令 :crontab 命令。
一、crond简介
crond 是linux下用来周期性的执行某种任务或等待处理某些事件的一个守护进程，与windows下的计划任务类似，当安装完成操作系统后，默认会安装此服务 工具，并且会自动启动crond进程，crond进程每分钟会定期检查是否有要执行的任务，如果有要执行的任务，则自动执行该任务。
Linux下的任务调度分为两类，系统任务调度和用户任务调度。
系统任务调度：系统周期性所要执行的工作，比如写缓存数据到硬盘、日志清理等。在/etc目录下有一个crontab文件，这个就是系统任务调度的配置文件。
/etc/crontab文件包括下面几行：SHELL=/bin/bash PATH=/sbin:/bin:/usr/sbin:/usr/bin MAILTO=root HOME=/ # For details see man 4 crontabs # Example of job definition: # .---------------- minute (0 - 59) # | .------------- hour (0 - 23) # | | .---------- day of month (1 - 31) # | | | .------- month (1 - 12) OR jan,feb,mar,apr ... # | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat # | | | | | # * * * * * user-name command to be executed下面是一个例子：
SHELL=/bin/bash PATH=/sbin:/bin:/usr/sbin:/usr/bin MAILTO=HOME=/ # run-parts 51 * * * * root run-parts /etc/cron.hourly 24 7 * * * root run-parts /etc/cron.daily 22 4 * * 0 root run-parts /etc/cron.weekly 42 4 1 * * root run-parts /etc/cron.monthly前 四行是用来配置crond任务运行的环境变量，第一行SHELL变量指定了系统要使用哪个shell，这里是bash，第二行PATH变量指定了系统执行 命令的路径，第三行MAILTO变量指定了crond的任务执行信息将通过电子邮件发送给root用户，如果MAILTO变量的值为空，则表示不发送任务 执行信息给用户，第四行的HOME变量指定了在执行命令或者脚本时使用的主目录。第六至九行表示的含义将在下个小节详细讲述。这里不在多说。
用户任务调度：用户定期要执行的工作，比如用户数据备份、定时邮件提醒等。用户可以使用 crontab 工具来定制自己的计划任务。所有用户定义的crontab 文件都被保存在 /var/spool/cron目录中。其文件名与用户名一致。
使用者权限文件： 文件：/etc/cron.deny 说明：该文件中所列用户不允许使用crontab命令 文件：/etc/cron.allow 说明：该文件中所列用户允许使用crontab命令 文件：/var/spool/cron/ 说明：所有用户crontab文件存放的目录,以用户名命名 crontab文件的含义： 用户所建立的crontab文件中，每一行都代表一项任务，每行的每个字段代表一项设置，它的格式共分为六个字段，前五段是时间设定段，第六段是要执行的命令段，格式如下： minute hour day month week command 其中： minute： 表示分钟，可以是从0到59之间的任何整数。 hour：表示小时，可以是从0到23之间的任何整数。 day：表示日期，可以是从1到31之间的任何整数。 month：表示月份，可以是从1到12之间的任何整数。 week：表示星期几，可以是从0到6之间的任何整数，这里的0或7代表星期日。 command：要执行的命令，可以是系统命令，也可以是自己编写的脚本文件。
在以上各个字段中，还可以使用以下特殊字符：
星号（*）：代表所有可能的值，例如month字段如果是星号，则表示在满足其它字段的制约条件后每月都执行该命令操作。 逗号（,）：可以用逗号隔开的值指定一个列表范围，例如，“1,2,5,7,8,9” 中杠（-）：可以用整数之间的中杠表示一个整数范围，例如“2-6”表示“2,3,4,5,6” 正斜线（/）：可以用正斜线指定时间的间隔频率，例如“0-23/2”表示每两小时执行一次。同时正斜线可以和星号一起使用，例如*/10，如果用在minute字段，表示每十分钟执行一次。二、crond服务
安装crontab：
yum install crontabs
服务操作说明：
/sbin/service crond start //启动服务
/sbin/service crond stop //关闭服务
/sbin/service crond restart //重启服务
/sbin/service crond reload //重新载入配置
/sbin/service crond status //启动服务
查看crontab服务是否已设置为开机启动，执行命令：
ntsysv
加入开机自动启动：
chkconfig –level 35 crond on
三、crontab命令详解
1．命令格式：
crontab [-u user] file
crontab [-u user] [ -e | -l | -r ]
2．命令功能：
通过crontab 命令，我们可以在固定的间隔时间执行指定的系统指令或 shell script脚本。时间间隔的单位可以是分钟、小时、日、月、周及以上的任意组合。这个命令非常适合周期性的日志分析或数据备份等工作。
3．命令参数：-u user：用来设定某个用户的crontab服务，例如，“-u ixdba”表示设定ixdba用户的crontab服务，此参数一般由root用户来运行。 file：file是命令文件的名字,表示将file做为crontab的任务列表文件并载入crontab。如果在命令行中没有指定这个文件，crontab命令将接受标准输入（键盘）上键入的命令，并将它们载入crontab。 -e：编辑某个用户的crontab文件内容。如果不指定用户，则表示编辑当前用户的crontab文件。 -l：显示某个用户的crontab文件内容，如果不指定用户，则表示显示当前用户的crontab文件内容。 -r：从/var/spool/cron目录中删除某个用户的crontab文件，如果不指定用户，则默认删除当前用户的crontab文件。 -i：在删除用户的crontab文件时给确认提示。4．常用方法：
1). 创建一个新的crontab文件
在 考虑向cron进程提交一个crontab文件之前，首先要做的一件事情就是设置环境变量EDITOR。cron进程根据它来确定使用哪个编辑器编辑 crontab文件。9 9 %的UNIX和LINUX用户都使用vi，如果你也是这样，那么你就编辑$ HOME目录下的. profile文件，在其 中加入这样一行：
EDITOR=vi; export EDITOR然后保存并退出。不妨创建一个名为 cron的文件，其中是用户名，例如， davecron。在该文件中加入如下的内容。
# (put your own initials here)echo the date to the console every # 15minutes between 6pm and 6am 0,15,30,45 18-06 * * * /bin/echo ‘date’ > /dev/console保存并退出。确信前面5个域用空格分隔。
在 上面的例子中，系统将每隔1 5分钟向控制台输出一次当前时间。如果系统崩溃或挂起，从最后所显示的时间就可以一眼看出系统是什么时间停止工作的。在有些 系统中，用tty1来表示控制台，可以根据实际情况对上面的例子进行相应的修改。为了提交你刚刚创建的crontab文件，可以把这个新创建的文件作为 cron命令的参数：$ crontab davecron现在该文件已经提交给cron进程，它将每隔1 5分钟运行一次。
同时，新创建文件的一个副本已经被放在/var/spool/cron目录中，文件名就是用户名(即dave)。
2). 列出crontab文件
为了列出crontab文件，可以用：$ crontab -l0,15,30,45,18-06 * * * /bin/echo `date` > dev/tty1你将会看到和上面类似的内容。可以使用这种方法在$ H O M E目录中对crontab文件做一备份：
$ crontab -l > $HOME/mycron这样，一旦不小心误删了crontab文件，可以用上一节所讲述的方法迅速恢复。
3). 编辑crontab文件
如果希望添加、删除或编辑crontab文件中的条目，而E D I TO R环境变量又设置为v i，那么就可以用v i来编辑crontab文件，相应的命令为：$ crontab -e可以像使用v i编辑其他任何文件那样修改crontab文件并退出。如果修改了某些条目或添加了新的条目，那么在保存该文件时， c r o n会对其进行必要的完整性检查。如果其中的某个域出现了超出允许范围的值，它会提示你。
我们在编辑crontab文件时，没准会加入新的条目。例如，加入下面的一条：# DT:delete core files,at 3.30am on 1,7,14,21,26,26 days of each month 30 3 1,7,14,21,26 * * /bin/find -name “core’ -exec rm {} \;现在保存并退出。最好在crontab文件的每一个条目之上加入一条注释，这样就可以知道它的功能、运行时间，更为重要的是，知道这是哪位用户的作业。
现在让我们使用前面讲过的crontab -l命令列出它的全部信息：
$ crontab -l# (crondave installed on Tue May 4 13:07:43 1999) # DT:ech the date to the console every 30 minites 0,15,30,45 18-06 * * * /bin/echo `date` > /dev/tty1 # DT:delete core files,at 3.30am on 1,7,14,21,26,26 days of each month 30 3 1,7,14,21,26 * * /bin/find -name “core’ -exec rm {} \;4). 删除crontab文件
要删除crontab文件，可以用：$ crontab -r5). 恢复丢失的crontab文件
如果不小心误删了crontab文件，假设你在自己的$ H O M E目录下还有一个备份，那么可以将其拷贝到/var/spool/cron/，其中是用户名。如果由于权限问题无法完成拷贝，可以用：$ crontab <filename>其中，
<filename>是你在$ H O M E目录中副本的文件名。
我建议你在自己的$ H O M E目录中保存一个该文件的副本。我就有过类似的经历，有数次误删了crontab文件（因为r键紧挨在e键的右边）。这就是为什么有些系统文档建议不要直接编辑crontab文件，而是编辑该文件的一个副本，然后重新提交新的文件。
有些crontab的变体有些怪异，所以在使用crontab命令时要格外小心。如果遗漏了任何选项，crontab可能会打开一个空文件，或者看起来像是个空文件。这时敲delete键退出，不要按<Ctrl-D>，否则你将丢失crontab文件。
5．使用实例实例1：每1分钟执行一次command 命令： * * * * * command实例2：每小时的第3和第15分钟执行 命令： 3,15 * * * * command实例3：在上午8点到11点的第3和第15分钟执行 命令： 3,15 8-11 * * * command实例4：每隔两天的上午8点到11点的第3和第15分钟执行 命令： 3,15 8-11 */2 * * command实例5：每个星期一的上午8点到11点的第3和第15分钟执行 命令： 3,15 8-11 * * 1 command实例6：每晚的21:30重启smb 命令： 30 21 * * * /etc/init.d/smb restart实例7：每月1、10、22日的4 : 45重启smb 命令： 45 4 1,10,22 * * /etc/init.d/smb restart实例8：每周六、周日的1 : 10重启smb 命令： 10 1 * * 6,0 /etc/init.d/smb restart实例9：每天18 : 00至23 : 00之间每隔30分钟重启smb 命令： 0,30 18-23 * * * /etc/init.d/smb restart实例10：每星期六的晚上11 : 00 pm重启smb 命令： 0 23 * * 6 /etc/init.d/smb restart实例11：每一小时重启smb 命令： * */1 * * * /etc/init.d/smb restart实例12：晚上11点到早上7点之间，每隔一小时重启smb 命令： * 23-7/1 * * * /etc/init.d/smb restart实例13：每月的4号与每周一到周三的11点重启smb 命令： 0 11 4 * mon-wed /etc/init.d/smb restart实例14：一月一号的4点重启smb 命令： 0 4 1 jan * /etc/init.d/smb restart实例15：每小时执行/etc/cron.hourly目录内的脚本 命令： 01 * * * * root run-parts /etc/cron.hourly说明：
run-parts这个参数了，如果去掉这个参数的话，后面就可以写要运行的某个脚本名，而不是目录名了.
四、使用注意事项
注意环境变量问题
有时我们创建了一个crontab，但是这个任务却无法自动执行，而手动执行这个任务却没有问题，这种情况一般是由于在crontab文件中没有配置环境变量引起的。
在 crontab文件中定义多个调度任务时，需要特别注意的一个问题就是环境变量的设置，因为我们手动执行某个任务时，是在当前shell环境下进行的，程 序当然能找到环境变量，而系统自动执行任务调度时，是不会加载任何环境变量的，因此，就需要在crontab文件中指定任务运行所需的所有环境变量，这 样，系统执行任务调度时就没有问题了。
不要假定cron知道所需要的特殊环境，它其实并不知道。所以你要保证在shelll脚本中提供所有必要的路径和环境变量，除了一些自动设置的全局变量。所以注意如下3点：
1）脚本中涉及文件路径时写全局路径；
2）脚本执行要用到java或其他环境变量时，通过source命令引入环境变量，如：cat start_cbp.sh#!/bin/sh source /etc/profile export RUN_CONF=/home/d139/conf/platform/cbp/cbp_jboss.conf /usr/local/jboss-4.0.5/bin/run.sh -c mev &3）当手动执行脚本OK，但是crontab死活不执行时。这时必须大胆怀疑是环境变量惹的祸，并可以尝试在crontab中直接引入环境变量解决问题。如：
0 * * * * . /etc/profile;/bin/sh /var/www/java/audit_no_count/bin/restart_audit.sh注意清理系统用户的邮件日志
每条任务调度执行完毕，系统都会将任务输出信息通过电子邮件的形式发送给当前系统用户，这样日积月累，日志信息会非常大，可能会影响系统的正常运行，因此，将每条任务进行重定向处理非常重要。
例如，可以在crontab文件中设置如下形式，忽略日志输出：0 */3 * * * /usr/local/apache2/apachectl restart >/dev/null 2>&1“/dev/null 2>&1”表示先将标准输出重定向到/dev/null，然后将标准错误重定向到标准输出，由于标准输出已经重定向到了/dev/null，因此标准错误也会重定向到/dev/null，这样日志输出问题就解决了。
系统级任务调度与用户级任务调度
系 统级任务调度主要完成系统的一些维护操作，用户级任务调度主要完成用户自定义的一些任务，可以将用户级任务调度放到系统级任务调度来完成（不建议这么 做），但是反过来却不行，root用户的任务调度操作可以通过“crontab –uroot –e”来设置，也可以将调度任务直接写入/etc /crontab文件，需要注意的是，如果要定义一个定时重启系统的任务，就必须将任务放到/etc/crontab文件，即使在root用户下创建一个 定时重启系统的任务也是无效的。
其他注意事项新创建的cron job，不会马上执行，至少要过2分钟才执行。如果重启cron则马上执行。 当crontab突然失效时，可以尝试/etc/init.d/crond restart解决问题。或者查看日志看某个job有没有执行/报错tail -f /var/log/cron。 千万别乱运行crontab -r。它从Crontab目录（/var/spool/cron）中删除用户的Crontab文件。删除了该用户的所有crontab都没了。 在crontab中%是有特殊含义的，表示换行的意思。如果要用的话必须进行转义\%，如经常用的date ‘+%Y%m%d’在crontab里是不会执行的，应该换成date ‘+\%Y\%m\%d’。示例
#!/bin/bash source /etc/profile if spark-submit --master yarn --num-executors 3 --executor-cores 30 --executor-memory 120g --driver-memory 24g /home/job/sdpjob//parquetToHive_AAA_day.py then if spark-submit --master yarn --num-executors 3 --executor-cores 30 --executor-memory 120g --driver-memory 24g /home/job/sdpjob//parquetToHive_BBB_day.py then spark-submit --master yarn --num-executors 3 --executor-cores 30 --executor-memory 120g --driver-memory 24g /home/job/sdpjob//parquetToHive_CCC_day.py fi ficrontab中的设置如下
0 6 * * * /bin/sh /home/job/XXXjob/hdfsToHive.sh > /home/job/XXXjob/crontab.txt如何从一个文件读取shell脚本执行参数
使用source命令可以把一个文件的内容读取到当前脚本来
例如：
a.conf 里面有一个变量 aa=“1234”
在脚本里面使用source#!/bin/bash source ./a.conf (source的时候最好用绝对路径，我这儿用的相对路径) echo $aalinux shell中’',""和``的区别
单引号
''，双引号""
都可以用来界定一个字符串。
区别是：
1）、单引号属于强引用，它会忽略所有被引起来的字符的特殊处理，被引用起来的字符会被原封不动的使用，唯一需要注意的点是不允许引用自身；
2）、双引号属于弱引用，它会对一些被引起来的字符进行特殊处理，主要包括以下情况：1：$加变量名可以取变量的值 ，比如： [root@localhost ~]# echo '$PWD' 结果是：$PWD [root@localhost ~]# echo "$PWD" 结果是：/root 2：反引号和$()引起来的字符会被当做命令执行后替换原来的字符，比如： [root@localhost ~]# echo '$(echo hello world)' 结果是：$(echo hello world) [root@localhost ~]# echo "$(echo hello world)" 结果是：hello world [root@localhost ~]# echo '`echo hello world`' 结果是：`echo hello world` [root@localhost ~]# echo "`echo hello world`" 结果是：hello world 3：当需要使用字符（$ ` " \）时必须进行转义，也就是在前面加\ ； [root@localhost ~]# echo '$ ` " \' 结果是：$ ` " \ [root@localhost ~]# echo "\$ \` \" \\" 结果是：$ ` " \反引号` `
反引号` `是命令替换(与$()差不多)，命令替换是指Shell可以先执行` ` 中的命令，将输出结果暂时保存，在适当的地方输出。语法:`command`#!/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 Sat Mar 24 16:30:50 CST 2018 Logged in user are 1 Uptime is Sat Mar 24 16:34:16 CST 2018 16:34:16 up 383 days, 6:41, 1 user, load average: 3.35, 3.36, 3.46shell中各种括号的作用详解()、(())、[]、[[]]、{}
来源
一、小括号，圆括号（）
1、单小括号 ()①命令组。括号中的命令将会新开一个子shell顺序执行，所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开，最后一个命令可以没有分号，各命令和括号之间不必有空格。而{}则不会新开子shell。 ②命令替换。等同于`cmd`，shell扫描一遍命令行，发现了$(cmd)结构，便将$(cmd)中的cmd执行一次，得到其标准输出，再将此输出放到原来命令。有些shell不支持，如tcsh。 ③用于初始化数组。如：array=(a b c d)2、双小括号 (( ))
①整数扩展。这种扩展计算是整数型的计算，不支持浮点型。((exp))结构扩展并计算一个算术表达式的值，如果表达式的结果为0，那么返回的退出状态码为1，或者 是"假"，而一个非零值的表达式所返回的退出状态码将为0，或者是"true"。若是逻辑判断，表达式exp为真则为1,假则为0。 ②只要括号中的运算符、表达式符合C语言运算规则，都可用在$((exp))中，甚至是三目运算符。作不同进位(如二进制、八进制、十六进制)运算时，输出结果全都自动转化成了十进制。如：echo $((16#5f)) 结果为95 (16进位转十进制) ③单纯用 (( )) 也可重定义变量值，比如 a=5; ((a++)) 可将 $a 重定义为6 ④常用于算术运算比较，双括号中的变量可以不使用$符号前缀。括号内支持多个表达式用逗号分开。 只要括号中的表达式符合C语言运算规则,比如可以直接使用for((i=0;i<5;i++)), 如果不使用双括号, 则为for i in `seq 0 4`或者for i in {0..4}。再如可以直接使用if (($i<5)), 如果不使用双括号, 则为if [ $i -lt 5 ]。二、中括号，方括号[]
1、单中括号 []
①bash 的内部命令，[和test是等同的。如果我们不用绝对路径指明，通常我们用的都是bash自带的命令。if/test结构中的左中括号是调用test的命令标识，右中括号是关闭条件判断的。这个命令把它的参数作为比较表达式或者作为文件测试，并且根据比较的结果来返回一个退出状态码。if/test结构中并不是必须右中括号，但是新版的Bash中要求必须这样。 ②Test和[]中可用的比较运算符只有==和!=，两者都是用于字符串比较的，不可用于整数比较，整数比较只能使用-eq，-gt这种形式。无论是字符串比较还是整数比较都不支持大于号小于号。如果实在想用，对于字符串比较可以使用转义形式，如果比较"ab"和"bc"：[ ab \< bc ]，结果为真，也就是返回状态为0。[ ]中的逻辑与和逻辑或使用-a 和-o 表示。 ③字符范围。用作正则表达式的一部分，描述一个匹配的字符范围。作为test用途的中括号内不能使用正则。 ④在一个array 结构的上下文中，中括号用来引用数组中每个元素的编号。2、双中括号[[ ]]
①[[是 bash 程序语言的关键字。并不是一个命令，[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割，但是会发生参数扩展和命令替换。 ②支持字符串的模式匹配，使用=~操作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式，而不仅仅是一个字符串，比如[[ hello == hell? ]]，结果为真。[[ ]] 中匹配字符串或通配符，不需要引号。 ③使用[[ ... ]]条件判断结构，而不是[ ... ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。 ④bash把双中括号中的表达式看作一个单独的元素，并返回一个退出状态码。三、大括号、花括号 {}
1、常规用法①大括号拓展。(通配(globbing))将对大括号中的文件名做扩展。在大括号中，不允许有空白，除非这个空白被引用或转义。第一种：对大括号中的以逗号分割的文件列表进行拓展。如 touch {a,b}.txt 结果为a.txt b.txt。第二种：对大括号中以点点（..）分割的顺序文件列表起拓展作用，如：touch {a..d}.txt 结果为a.txt b.txt c.txt d.txt # ls {ex1,ex2}.sh 结果是：ex1.sh ex2.sh # ls {ex{1..3},ex4}.sh 结果是：ex1.sh ex2.sh ex3.sh ex4.sh # ls {ex[1-3],ex4}.sh 结果是：ex1.sh ex2.sh ex3.sh ex4.sh ②代码块，又被称为内部组，这个结构事实上创建了一个匿名函数 。与小括号中的命令不同，大括号内的命令不会新开一个子shell运行，即脚本余下部分仍可使用括号内变量。括号内的命令间用分号隔开，最后一个也必须有分号。{}的第一个命令和左括号之间必须要有一个空格。2、几种特殊的替换结构
${var:-string},${var:+string},${var:=string},${var:?string} ①${var:-string}和${var:=string}:若变量var为空，则用在命令行中用string来替换${var:-string}，否则变量var不为空时，则用变量var的值来替换${var:-string}；对于${var:=string}的替换规则和${var:-string}是一样的，所不同之处是${var:=string}若var为空时，用string替换${var:=string}的同时，把string赋给变量var： ${var:=string}很常用的一种用法是，判断某个变量是否赋值，没有的话则给它赋上一个默认值。 ② ${var:+string}的替换规则和上面的相反，即只有当var不是空的时候才替换成string，若var为空时则不替换或者说是替换成变量 var的值，即空值。(因为变量var此时为空，所以这两种说法是等价的) ③${var:?string}替换规则为：若变量var不为空，则用变量var的值来替换${var:?string}；若变量var为空，则把string输出到标准错误中，并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。补充扩展：在上面这五种替换结构中string不一定是常值的，可用另外一个变量的值或是一种命令的输出。
3、四种模式匹配替换结构
模式匹配记忆方法：# 是去掉左边(在键盘上#在$之左边) % 是去掉右边(在键盘上%在$之右边) #和%中的单一符号是最小匹配，两个相同符号是最大匹配。 ${var%pattern},${var%%pattern},${var#pattern},${var##pattern}第一种模式：${variable%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最短的匹配模式 第二种模式： ${variable%%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最长的匹配模式 第三种模式：${variable#pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern开始，如果是，就从命令行把variable中的内容去掉左边最短的匹配模式 第四种模式： ${variable##pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最长的匹配模式 这四种模式中都不会改变variable的值，其中，只有在pattern中使用了*匹配符号时，%和%%，#和##才有区别。结构中的pattern支持通配符，*表示零个或多个任意字符，?表示仅与一个任意字符匹配，[...]表示匹配中括号里面的字符，[!...]表示不匹配中括号里面的字符。# var=testcase # echo $var 结果为：testcase # echo ${var%s*e} 结果为：testca 最小范围找 # echo ${var%%s*e} 结果为：te 最大范围找 # echo ${var#?e} 结果为：stcase # echo ${var##?e} 结果为：stcase # echo ${var##*e} 结果为： # echo ${var##*s} 结果为：e # echo ${var##test} 结果为：case4、字符串提取和替换
${var:num},${var:num1:num2},${var/pattern/pattern},${var//pattern/pattern} 第一种模式：${var:num}，这种模式时，shell在var中提取第num个字符到末尾的所有字符。若num为正数，从左边0处开始；若num为负数，从右边开始提取字串，起始值为-1但必须使用在冒号后面加空格或一个数字或整个num加上括号，如${var: -2}、${var:1-3}或${var:(-2)}。 第二种模式：${var:num1:num2}，num1是位置，num2是长度。表示从$var字符串的第$num1个位置开始提取长度为$num2的子串。不能为负数。 第三种模式：${var/pattern/pattern}表示将var字符串的第一个匹配的pattern替换为另一个pattern。 第四种模式：${var//pattern/pattern}表示将var字符串中的所有能匹配的pattern替换为另一个pattern。[root@centos ~]# var=/home/centos [root@centos ~]# echo $var 结果为：/home/centos [root@centos ~]# echo ${var:5} 结果为：/centos [root@centos ~]# echo ${var: -6} 结果为：centos [root@centos ~]# echo ${var:(-6)} 结果为：centos [root@centos ~]# echo ${var:1:4} 结果为：home [root@centos ~]# echo ${var/o/h} 结果为：/hhme/centos [root@centos ~]# echo ${var//o/h} 结果为：/hhme/cenths四、符号$后的括号
shell脚本中KaTeX parse error: Expected 'EOF', got '#' at position 1: #̲、*、 @ 、 @、 @、?、$0等含义一文搞懂
（1）${a} 变量a的值, 在不引起歧义的情况下可以省略大括号。 （2）$(cmd) 命令替换，和`cmd`效果相同，结果为shell命令cmd的输，不过某些Shell版本不支持$()形式的命令替换, 如tcsh。 （3）$((expression)) 和`exprexpression`效果相同, 计算数学表达式exp的数值, 其中exp只要符合C语言的运算规则即可, 甚至三目运算符和逻辑表达式都可以计算。$后面跟符号
${1} #输入的第2个参数 ${2} #输入的第3个参数 ${0} #输入的第1个参数 #====== 示例 ================ ./main.sh 25 43 当执行脚本main.sh时候，后面接了25 43 参数，那么$0代表第一个参数main.sh $1代表25 $2代表43 以此类推。 cat /data/soft/env/ ${1} 由于/data/soft/env/是保存参数的文件，这一文件作为cat命令的参数传入，因而${1}获得的就是该文件本身其实类似的有
$# 是传递给脚本的参数个数； $0 是脚本本身的名字； $1 是传递给该shell脚本的第一个参数； $2 是传递给该shell脚本的第二个参数； $@ 是传递给脚本的所有参数的列表(是多个字符串，每个参数为1个字符串)； $* 是传递给脚本的所有参数的列表(以一个单字符串显示所有参数)，与位置变量不同，参数可超过9个； $$ 是运行脚本的当前进程ID号； $? 是显示执行上一条Shell命令的返回值，0表示没有错误，其他表示有错误。五、使用
1、多条命令执行
（1）单小括号，(cmd1;cmd2;cmd3) 新开一个子shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后可以没有分号。
（2）单大括号，{ cmd1;cmd2;cmd3;} 在当前shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后必须有分号, 第一条命令和左括号之间必须用空格隔开。
对{}和()而言, 括号中的重定向符只影响该条命令， 而括号外的重定向符影响到括号中的所有命令。##9、shell 中`dirname KaTeX parse error: Expected group as argument to '\`' at position 4: 0\` ̲及``````后面跟不同字符的意义
$0 表示当前动行的命令名，一般用于shell 脚本中，更多的用法如下：符号 意义 $0 这个程式的执行名字 $n 这个程式的第n个参数值，n=1…9 $* 这个程式的所有参数,此选项参数可超过9个。 $# 这个程式的参数个数 $$ 这个程式的PID(脚本运行的当前进程ID号) $! 执行上一个背景指令的PID(后台运行的最后一个进程的进程ID号) $? 执行上一个指令的返回值 (显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误) $- 显示shell使用的当前选项，与set命令功能相同 $@ 跟$*类似，但是可以当作数组用 dirname 用于取指定文件所在的目录
HOME=$(cd `dirname $0`; cd ..; pwd)以上面语句为例：
dirname $0表示执行取当前命令所在文件的目录，返回结果给cd命令使用，因而cddirname $0命令就进入了当前命令所在文件的目录；接着执行第二条语句cd …，这表示进入当前目录的父目录；第三条语句pwd则返回原文件的父目录。整个执行结果被返回，并赋给了变量HOME
其他的一些用法可参考该文用shell脚本重启进程
来源
功能需求：
1、杀死指定进程
2、启动指定进程
3、检查指定进程是否启动
算法思路：
1、ps工具查找进程
ps -ef
2、grep工具在ps找出的进程中筛选指定进程
ps -ef | grep 程序名(如XX.py)
grep也在结果中，再筛选一次，用-v过滤掉grep
ps -ef | grep 程序名(如XX.py) | grep -v grep
3、awk工具在筛选出的进程信息中找出PID
ps -ef | grep 程序名(如XX.py) | grep -v grep | awk '{print $2}'
4、kill工具结束PID
kill是不支持管道的,那就先执行第4步， 再执行kill 第4步返回的PID
kill - 9 `ps -ef | grep 程序名(如XX.py) | grep -v grep | awk '{print $2}'`
5、启动进程
启动程序的命令或可执行文件
6、第一步+第二步判断进程是否启动
用判断符号 [ -z “${变量名}”] 来判断变量是否为空，关于-z及其他类似的用法可参考if [ -z "`ps -ef | grep 程序名(如XX.py) | grep -v grep | awk '{print $2}'`" ] then 处理逻辑 fi或者当进程不存在时，再次重启，直至成功。
while [ -z "`ps -ef | grep 程序名(如XX.py) | grep -v grep | awk '{print $2}'`" ] do 处理逻辑 done关于杀进程还可参考该文
Shell判断字符串是否包含小结
shell 判断字符串中是否含有指定字符#!/bin/bash source /etc/profile cd /AAAAA/pred2 strCoil="`ps -ef | grep imgPredCNNRltmSDHrFtNow.pyc | grep -v grep | awk '{print $10}'`" strL323="/BBBB/3号机" strL327="/BBBB/7号机" strL328="/BBBB/8号机" resultCoil="`echo $strCoil | grep $strL323`" if [[ "$resultCoil" != "" ]] then echo "3号机检验程序正运行" else /root/anaconda3/bin/python /AAAAA/pred2/imgPredCNNRltmSDHrFtNow.pyc '/BBBB/3号机' fi resultCoil="`echo $strCoil | grep $strL327`" if [[ "$resultCoil" != "" ]] then echo "7号机检验程序正运行" else /root/anaconda3/bin/python /AAAAA/pred2/imgPredCNNRltmSDHrFtNow.pyc '/BBBB/7号机' fi resultCoil="`echo $strCoil | grep $strL328`" if [[ "$resultCoil" != "" ]] then echo "8号机检验程序正运行" else /root/anaconda3/bin/python /AAAAA/pred2/imgPredCNNRltmSDHrFtNow.pyc '/BBBB/8号机' fi引入环境变量
第一种方法：crontab中引入
1 0 * * * . /etc/profile;/bin/sh /usr/zlp/sparkShell.sh第二种方法：shell脚本中引入
#!/bin/bash source /etc/profile spark-submit /usr/zlp/wbfiveconnectins.jar > /usr/zlp/log1229.outubuntu18.04下，利用shell脚本启动conda虚拟环境，并实现python程序自启动
linux的nohup命令的用法
来源
在应用Unix/Linux时，我们一般想让某个程序在后台运行，于是我们将常会用 & 在程序结尾来让程序自动运行。比如我们要运行mysql在后台： /usr/local/mysql/bin/mysqld_safe –user=mysql &。可是有很多程序并不想mysqld一样，这样我们就需要nohup命令。nohup /root/start.sh &在shell中回车后提示：
[~]$ appending output to nohup.out原程序的的标准输出被自动改向到当前目录下的nohup.out文件，起到了log的作用。
但是有时候在这一步会有问题，当把终端关闭后，进程会自动被关闭，察看nohup.out可以看到在关闭终端瞬间服务自动关闭。
咨询红旗Linux工程师后，他也不得其解，在我的终端上执行后，他启动的进程竟然在关闭终端后依然运行。
在第二遍给我演示时，我才发现我和他操作终端时的一个细节不同：他是在当shell中提示了nohup成功后还需要按终端上键盘任意键退回到shell输入命令窗口，然后通过在shell中输入exit来退出终端；而我是每次在nohup执行成功后直接点关闭程序按钮关闭终端.。所以这时候会断掉该命令所对应的session，导致nohup对应的进程被通知需要一起shutdown。shell脚本中的函数
Shell脚本函数定义
shell允许将一组命令集或语句形成一个可用块，这些块称为shell函数。
shell中函数的定义格式如下：函数名(){ command1 command2 ... commandN [ return value ] }如果愿意，可在函数名前加上关键字function，这取决于使用者。
function 函数名(){ command1 command2 ... commandN [ return value ] }函数返回值，可以显示增加return语句；如果不加，则将最后一条命令运行结果作为返回值（一般为0，如果执行失败则返回错误代码）。 return后跟数值（0-255）。
函数可以放在同一个文件中作为一段代码，也可以放在只包含函数的单独文件中。函数不必包含很多语句或命令，甚至可以只包含一个echo语句，这取决于使用者。
下面的例子定义了一个函数并进行调用：#!/bin/bash demoFun(){ echo "This is your first shell function!" } echo "Function begin..." demoFun echo "Function end!"结果如下：
Function begin... This is your first shell function! Function end!下面定义一个带有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 echo "The sum of two numbers is $? !"#$?表示上一条指令的返回值结果大致如下：
The function is to get the sum of two numbers... Input first number: 10 Input another number: 30 The two numbers are 10 and 30 ! The sum of two numbers is 40 !注意：所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至shell解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。
函数输出
注意参考前一节中函数返回值的说明
为了返回大于255的数、浮点数和字符串值，最好用函数输出到变量：#!/bin/bash function fun2 { read -p "enter a: " a echo -n "print 2a: " echo $[ $a * 2 ] } result=`fun2` echo "return value $result"结果如下：
enter a: 3 return value print 2a: 6将函数赋给变量，然后再引用变量的时候，相当于执行了一遍函数，而不是获得函数的返回值，这一点与java,python这些编程语言极不一样。如果要获得函数返回值，可以再执行函数，然后再用
$?来获取。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 11 ! The string of the parameters is 1 2 3 4 5 6 7 8 9 34 73 !注意，$10 不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。
全局变量与局部变量
默认条件下，在函数和shell主体中建立的变量都是全局变量，可以相互引用，当shell主体部分与函数部分拥有名字相同的变量时，可能会相互影响，例如:
#!/bin/bash if [ $# -ne 3 ] then echo "usage: $0 a b c" exit fi temp=5 value=6 echo temp is: $temp echo value is: $value fun3() { temp=`echo "scale=3;$1*$2*$3" | bc -ql` result=$temp } fun3 $1 $2 $3 echo "the result is $result" if [ `echo "$temp > $value" | bc -ql` -ne 0 ] then echo "temp is larger" else echo "temp is still smaller" fi./variable.sh 12 3 2结果如下：
temp is: 5 value is: 6 the result is 72 temp is larger在这种情况下，在函数内部最好使用局部变量，消除影响。
#!/bin/bash if [ $# -ne 3 ] then echo "usage: $0 a b c" exit fi temp=5 value=6 echo temp is: $temp echo value is: $value fun3() { local temp=`echo "scale=3;$1*$2*$3" | bc -ql` result=$temp } fun3 $1 $2 $3 echo "the result is $result" if [ `echo "$temp > $value" | bc -ql` -ne 0 ] then echo "temp is larger" else echo "temp is still smaller" fi./variable.sh 12 3 2结果如下：
temp is: 5 value is: 6 the result is 72 temp is still smaller向函数传递数组变量
#!/bin/bash a=(11 12 13 14 15) echo ${a[*]} function array(){ echo parameters : "$@" local factorial=1 for value in "$@" do factorial=$[ $factorial * $value ] done echo $factorial } array ${a[*]}结果如下：
11 12 13 14 15 parameters : 11 12 13 14 15 360360函数返回数组变量
#!/bin/bash a=(11 12 13 14 15) function array(){ echo parameters : "$@" local newarray=(`echo "$@"`) local element="$#" local i for (( i = 0; i < $element; i++ )) { newarray[$i]=$[ ${newarray[$i]} * 2 ] } echo new value:${newarray[*]} } result=`array ${a[*]}` echo ${result[*]}结果如下：
parameters : 11 12 13 14 15 new value:22 24 26 28 30创建库
在单个脚本中，使用函数可以省去一些键入的工作，但如果你碰巧要在脚本之间使用同一个代码块呢？显然，在每个脚本中都定义一个同样的函数会比较麻烦。有个方法能解决这个问题，bash shell允许创建函数库文件，然后在需要时在多个文件中引用该库文件。这个过程的第一步时创建一个包含脚本中所需函数的共用库文件，如：
/home/zh/work_space/scripts/function/myfuncsfunction add { echo $[ $1+$2 ] } function mult { echo $[ $1 * $2 ] } function div { if [ $2 -ne 0 ] then echo $[ $1 /$2 ] else echo -1 fi }使用函数库到关键在于source 命令，source命令会在当前的shell上下文中执行命令，而不是创建一个新的shell来执行命令。可以用source命令来在shell脚本中运行库文件脚本，这样函数就对脚本可用了。source命令有个快捷别名，称作点操作符(dot operator) ，要在shell 脚本中运行myfuncs库文件，你只需要添加下面这行：
. ./myfuncs#!/bin/bash . ./myfuncs value1=50 value2=10 result1=`add $value1 $value2` result2=`mult $value1 $value2` result3=`div $value1 $value2` echo "The result of add: $result1" echo "The result of mult: $result2" echo "The result of div: $result3"在
.bashrc文件中定义函数直接定义函数
读取库文件脚本
shell还会将定义好的函数传给子shell进程，这样这些函数会在该shell会话中的任何脚本中也都可以用13、Java调用Shell命令和脚本
介绍
有时候我们在Linux中运行Java程序时，需要调用一些Shell命令和脚本。而Runtime.getRuntime().exec()方法给我们提供了这个功能，而且Runtime.getRuntime()给我们提供了以下几种exec()方法：
Process exec(String command) 在单独的进程中执行指定的字符串命令。 Process exec(String[] cmdarray) 在单独的进程中执行指定命令和变量。 Process exec(String[] cmdarray, String[] envp) 在指定环境的独立进程中执行指定命令和变量。 Process exec(String[] cmdarray, String[] envp, File dir) 在指定环境和工作目录的独立进程中执行指定的命令和变量。 Process exec(String command, String[] envp) 在指定环境的单独进程中执行指定的字符串命令。 Process exec(String command, String[] envp, File dir) 在有指定环境和工作目录的独立进程中执行指定的字符串命令。其中，其实cmdarray和command差不多，同时如果参数中如果没有envp参数或设为null，表示调用命令将在当前程序执行的环境中执行；如果没有dir参数或设为null，表示调用命令将在当前程序执行的目录中执行，因此调用到其他目录中的文件和脚本最好使用绝对路径。各个参数的含义：
- cmdarray: 包含所调用命令及其参数的数组。
- command: 一条指定的系统命令。
- envp: 字符串数组，其中每个元素的环境变量的设置格式为
name=value；如果子进程应该继承当前进程的环境，则该参数为 null。
dir: 子进程的工作目录；如果子进程应该继承当前进程的工作目录，则该参数为 null。
细心的读者会发现，为了执行调用操作，JVM会启一个Process，所以我们可以通过调用Process类的以下方法，得知调用操作是否正确执行：
abstract int waitFor() 导致当前线程等待，如有必要，一直要等到由该 Process 对象表示的进程已经终止。进程的出口值。根据惯例，0 表示正常终止；否则，就表示异常失败。
另外，调用某些Shell命令或脚本时，会有返回值，那么我们如果捕获这些返回值或输出呢？为了解决这个问题，Process类提供了：
abstract InputStream getInputStream() 获取子进程的输入流。 最好对输入流进行缓冲。调用Shell命令
这里为了说明问题，我仅用tar命令进行演示。tar命令是一个打包而不进行压缩的命令。同时，为了检查tar的调用是否被正常执行，我将调用waitFor()方法。
private void callCMD(String tarName, String fileName, String... workspace){ try { String cmd = "tar -cf" + tarName + " " + fileName; // String[] cmd = {"tar", "-cf", tarName, fileName}; File dir = null; if(workspace[0] != null){ dir = new File(workspace[0]); System.out.println(workspace[0]); } process = Runtime.getRuntime().exec(cmd, null, dir); // process = Runtime.getRuntime().exec(cmd); int status = process.waitFor(); if(status != 0){ System.err.println("Failed to call shell's command and the return status's is: " + status); } } catch (Exception e){ e.printStackTrace(); } }注意：如果把命令放到一个String[]中时，必须把命令中每个部分作为一个元素存在String[]中，或者是把命令按照空格符分割得到的String[]。
String[] cmd = {"tar", "-cf", tarName, fileName}; //right String[] cmd = {"tar -cf", tarName, fileName}; //error为了说明dir参数的作用，我特地把该Java程序和要打包的目录hive/放在不同的目录：
/root/workspace/eclipse/Test/src/edu/wzm/CallShell.java /root/experiment/hive如果我不设置dir或设dir为null，那么fileName不得不是相对路径，最好是绝对路径：
call.callCMD("/root/experiment/hive.tar", "/root/experiment/hive", null); // OR call.callCMD("/root/experiment/hive.tar", "/root/experiment/hive");如果我设置了dir指向了hive所在的父目录就好办多了：
call.callCMD("hive.tar", "hive", "/root/experiment/");调用Shell命令
Java调用Shell命令和调用Shell脚本的操作一模一样。我这里介绍另外几个方面：
- 给脚本传递参数；
- 捕获调用的输出结果；
- envp的使用。
给脚本传递参数，这个操作很简单，无非是把参数加到调用命令后面组成String，或String[]。
捕获调用输出信息，前面也提到过用
Process.getInputStream()。不过，建议最好对输入流进行缓冲：BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));另外，envp是一个String[]，并且String[]中的每一个元素的形式是：name=value。如：我的Linux系统中没有以下环境变量，但是我把它们写在Java代码中，作为envp：
val=2 call=Bash Shell我要调用的Shell脚本是：
/root/experiment/test.sh。#!/usr/bin/env bash args=1 if [ $# -eq 1 ];then args=$1 echo "The argument is: $args" fi echo "This is a $call" start=`date +%s` sleep 3s end=`date +%s` cost=$((($end - $start) * $args * $val)) echo "Cost Time: $cost"Java调用代码是：
private void callScript(String script, String args, String... workspace){ try { String cmd = "sh " + script + " " + args; // String[] cmd = {"sh", script, "4"}; File dir = null; if(workspace[0] != null){ dir = new File(workspace[0]); System.out.println(workspace[0]); } String[] evnp = {"val=2", "call=Bash Shell"}; process = Runtime.getRuntime().exec(cmd, evnp, dir); // process = Runtime.getRuntime().exec(cmd); BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream())); String line = ""; while ((line = input.readLine()) != null) { System.out.println(line); } input.close(); } catch (Exception e){ e.printStackTrace(); } } public static void main(String[] args) { // TODO Auto-generated method stub CallShell call = new CallShell(); call.callScript("test.sh", "4", "/root/experiment/"); }输出：
/root/experiment/ The argument is: 4 This is a Bash Shell Cost Time: 24Shell脚本文本三剑客之Sed
shell脚本开发环境
linux 下如何通过ssh到其他机器然后执行命令
来源：2015年07月15日 15:55:30
连到另一台机器上只是执行一个命令可以这样写：ssh hostname@10.2.226.202 cd /opt/连到另一台机器上执行多于一个命令可以这样写：
ssh hostname@10.2.226.203 "cd /opt/;pwd"注意：当多于两个命令时，一定要把所有命令以分号的方式写在双引号里面。
shell脚本执行出错时处理
shell脚本在执行命令出错时，默认会继续执行后面的语句
其实一般情况下, 只要在脚本中打开
set -e, 就能在遇到错误时终止脚本的执行**注意：**命令执行成功时返回的是0，而执行0||命令1时，不会再执行命令1的，这时的0相当于程序中的true
#!/bin/bash #sqoop import set -e source /etc/profile datetime=`date +%Y%m%d%H%M%S` sudo su - hdfs -l -c "sqoop import -username 'AAA' -password 'XXX' -connect jdbc:mysql://XXX.XXX.X.XXX:3306/BBB -driver com.mysql.jdbc.Driver -query 'select * from BBB_CCC where id <= 40000000 and \$CONDITIONS' -split-by ID -target-dir 'hdfs://ndhdfs/apps/hive/warehouse/BBB.db/BBB_CCC/$datetime/' -m 20 --as-parquetfile --null-non-string '\\\\N' --null-string '\\\\N'"杂
python - os.path.exists 在 python 中没有按预期工作: 在shell脚本中可以使用
~/dir，但是在shell脚本及python脚本中最好不要使用。企业生产环境shell脚本案例分享
扫一扫
4945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
