编程基础---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脚本案例分享