编程基础---shell编程

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

其实一般也不会在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 
    

    其中,是你在$ H O M E目录中副本的文件名。
    我建议你在自己的$ H O M E目录中保存一个该文件的副本。我就有过类似的经历,有数次误删了crontab文件(因为r键紧挨在e键的右边)。这就是为什么有些系统文档建议不要直接编辑crontab文件,而是编辑该文件的一个副本,然后重新提交新的文件。
    有些crontab的变体有些怪异,所以在使用crontab命令时要格外小心。如果遗漏了任何选项,crontab可能会打开一个空文件,或者看起来像是个空文件。这时敲delete键退出,不要按,否则你将丢失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
    

    四、符号$后的括号

    (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 [email protected]  cd /opt/
    

    连到另一台机器上执行多于一个命令可以这样写:

    ssh [email protected] "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脚本案例分享

你可能感兴趣的:(编程语言,shell,linux,编程)