内容来源: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
done

    list代表要循环的值，在每次循环的时候，会把当前的值赋值给var（变量名而已，随意定）, 这样在循环体中就可以直接通过$var获取当前值了。
    先来一个例子吧：

    #!/bin/bash
for str in a b c d e
do
    echo $str
done

    结果为：

    a
b
c
d
e

    for…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=$oldIFS

    C语言风格的for循环
    bash中c语言风格的for循环遵循如下格式：

    for (( variable assignment ; condition ; iteration process ))

    #!/bin/bash
for (( i = 0; i <= 10; i++ ))
do
    echo $i
done

    while循环
    与其它编程语言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]
done

    flag=0
while (( $flag <= 10 ))
do
    echo $flag
    flag=$[$flag + 1]
done

    until循环语句
    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=1

    continue
    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
done

    linux定时任务

    来源
    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 -l

    0,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 -r

    5). 恢复丢失的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
fi

    crontab中的设置如下

    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 $aa

    linux 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.46

    shell中各种括号的作用详解()、(())、[]、[[]]、{}

    来源
    一、小括号，圆括号（）
    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} 
结果为：case

    4、字符串提取和替换

    ${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命令使用，因而cd dirname $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.out

    shell脚本中激活conda虚拟环境

    ubuntu18.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/myfuncs

    function 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命令和脚本

    来源：2016年05月07日 13:45:43

    介绍

    有时候我们在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: 24

    Shell脚本文本三剑客之Sed

    shell脚本开发环境

    使用Vscode调试shell脚本 环境搭建基本步骤

    vscode同步文件到服务器

    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脚本案例分享

# linux
Logo
Linux

更多推荐

Linux虚拟文件系统之文件系统卸载（sys_umount())

Linux中卸载文件系统由umount系统调用实现，入口函数为sys_umount()。较于文件系统的安装较为简单，下面是具体的实现。1. /*sys_umont系统调用*/2. SYSCALL_DEFINE2(umount, char __user *, name, int, flags)3. {4.struct path path;

avatar Linux

网卡速率和双工模式的配置

http://linux.chinaitlab.com/system/792187.html1、mii-tool 配置网络设备协商方式的工具；    1.1 mii-tool 介绍；    mii-tool - view, manipulate media-independent interface status （mii-tool 是查看，管理介质的网络接口的状态）

avatar Linux

Linux系统下超级终端Minicom的使用方法（例如：连接交换机，路由器等）转http://baike.baidu.com/view/2911642.htm?fr=ala0_1

<br />　　Linux系统下超级终端Minicom的使用方法 <br />　　Linux下的Minicom的功能与下的超级终端功能相似，适于在通过超级终端对设备的管理以及对嵌入操作系统的升级，现写出Minicom的使用手册： <br />　　1． 启动minicom <br />　　以root权限登录系统 <br />　　使用命令 <br />　　minicom –s 则minicom启动，屏

avatar Linux