shell编程之条件判断与流程控制

            1. 按文件类型判断
            测试选项                  作用
            -b 文件            判断该文件是否存在，并且是否为块设备文件（是块设备为真）
            -c 文件            判断该文件是否存在，并且是否为字符设备（是字符设备文件为真）
            -d 文件            判断该文件是否存在，并且是否为目录文件（是目录为真）
            -e 文件            判断该文件是否存在（存在为真）
            -f 文件             判断该文件是否存在，并且是否为普通文件（是普通文件为真）
            -L 文件            判断该文件是否存在，并且是否为符号链接文件（是符号链接文件为真）
            -p 文件            判断该文件是否存在，并且是否为管道文件（是管道文件为真）
            -s 文件            判断该文件是否存在，并且是否为非空（非空为真）
            -S 文件           判断该文件是否存在，并且是否为套接字文件（是套接字文件为真）

                                          两种判断格式
              
               test -e /root/install.log
               [ -e /root/install.log ]
               例：
               [ -e /root/install.log ] && echo yes || echo no

              2. 按文件权限进行判断
                测试选项                        作用
                    -r 文件            判断该文件是否存在，并且是否该文件拥有读权限（有读权限为真）
                   -w 文件            判断该文件是否存在，并且是否该文件拥有写权限（有写权限为真）
                   -x  文件            判断该文件是否存在，并且是否该文件拥有执行权限（有执行权限为真）
                   -u 文件             判断该文件是否存在，并且是否该文件拥有SUID权限（有SUID权限为真）
                   -g  文件            判断该文件是否存在，并且是否该文件拥有SGID权限（有SGID权限为真）       
                   -k  文件            判断该文件是否存在，并且是否该文件拥有SBIT权限（有SBIT权限为真）       
              
               3. 两个文件之间进行比较
                  测试选项                          作用
                文件1 -nt 文件2        判断文件1的修改时间是否比文件2的新（新为真）
                文件1 -ot 文件2        判断文件1的修改时间是否比文件2的旧（旧为真）
                文件1 -ef 文件2        判断文件1是否和文件2的inode号一直，可以理解为两个文件是否为
                                                  同一个文件。这个判断用于判断硬链接是很好的方法
             
               4. 两个整数之间比较
                    测试选项                    作用
                整数1 -eq 整数2           判断整数1是否和整数2相等（相等为真）
                整数1 -ne 整数2           判断整数1是否和整数2不相等（不相等为真）
                整数1 -gt 整数2            判断整数1是否大于整数2（大于为真）
                整数1 -lt 整数2             判断整数1是否小于整数2（小于为真）
                整数1 -ge 整数2           判断整数1是否大于等于整数2（大于等于为真） 
                整数1 -le 整数2            判断整数1是否小于等于整数2（小于等于为真）
  
               5. 字符串的判断
                      测试选项                           作用
                        -z 字符串               判断字符串是否为空（为空返回真）
                        -n 字符串               判断字符串是否为非空（非空返回真） 
               字符串1 == 字符串2       判断字符串1是否和字符串2相等（相等返回真）
           字符串1 ！== 字符串2       判断字符串1是否和字符串2不相等（不相等返回真）

                6. 多重条件判断
                        测试选项                        作用
                    判断1 -a 判断2           逻辑与，判断1和判断2都成立，最终的结果为真
                    判断1 -o 判断2           逻辑或，判断1和判断2有一个成立，最终的结果就为真
                    ！判断                        逻辑非，是原始的判断式取反

              单分支if条件语句
                    if [ 条件判断式 ]；then
                            程序
                    fi
                  或者
                    if [ 条件判断式 ]
                          then
                            程序
                    fi

              单分支条件语句需要注意几个点
                1. if语句使用fi结尾，和一般语句使用大括号结尾不同
                2. [ 条件判断式 ]  就是使用test命令判断，所以中括号和条件判断式之间必须有空格
                3. then后面跟符合条件之后执行的程序，可以放在[]之后，用“；”分割，也可以换行写入，就不想要“；”了

             例1： 判断登录的用户是否是root
                      #！/bin/bash
                      test = $( env | grep "USER" | cut -d "=" -f 2)
                      if [ "$test" == root ]
                        then
                          echo "current user is root"
                      fi
          
              例2： 判断分区使用率
                     #！/bin/bash
                       rate = $(df -h | grep "dev/sda1" | awk '{print $5}' | cut -d '%' -f 1)
                          if [ $rate -ge 80 ]
                              then
                                  echo "warning ! /dev/sda1 is full"
                          fi
  
              2. 双分支if条件语句
                  if [ 条件判断式 ]
                      then 
                            条件成立时，执行的程序
                      else
                            条件不成立时，执行另一个程序
                   fi
  
              例1 ： 判断输入的是否是一个目录
              #！/bin/bash
                read -t 30 -p "please input a diretory " dir
                    if [ -d $dir ]
                        then
                            echo "yes"
                       else
                            echo "no"
                     fi

              例2： 判断apache 是否启动
                  #！/bin/bash
                    test = $(ps aux | grep httpd } grep -v grep)
                      if [ -n "$test" ]
                            then
                                echo "$(date) httpd is ok !">>/tmp/acc.log
                            else                     
                                 /etc/rc,d/init.d/httpd start &> /dev/null
                                 echo "$(date) restart httpd! " >> err.log
                      fi

              3. 多分支if条件语句
                  if [ 条件判断式1 ]
                        then
                              当条件判断式1成立时，执行程序1
                  elif  [ 条件判断式2 ]
                         then
                               当条件判断式2成立时，执行程序2
                   else
                                当所有条件都不成立时，最后执行此程序
                    fi

                例： 计算器
                  #！/bin/bash
                  read -t 30 -p "please input first num : " firstnum
                  read -t 30 -p "please input last num : " lastnum
                  read -t 30 -p "please input your operation : " operation
  
                  if [ -n "$firstnum" -a -n "$lastnum" -a -n "$operation" ]
                            then
                            judgefirstnum =  $( echo $firstnum | sed 's/[0-9]//g')
                            judgelastnum =  $( echo $lastnum | sed 's/[0-9]//g')
                            
                            if [ -z "$jugefirstnum" -a -z "$judgelastnum " ]
                                    then
                                      if [ "$operation" == "+" ]
                                            then
                                                  sum = $(( $firstnum+$lastnum ))
                                      elif [ "$operation" == "-" ]
                                            then
                                                  sum = $(( $firstnum-$lastnum ))
                                      elif [ "$operation" == "*" ]
                                            then
                                                  sum = $(( $firstnum*$lastnum ))
                                       elif [ "$operation" == "/" ]
                                            then
                                                  sum = $(( $firstnum/$lastnum ))
                                       else
                                              echo "please enter a valid value"
                                              exit
                                        fi
                                      echo $firstnum $operation $lastnum "=" $sum
                      else
                            echo "please enter valid value 2"
                            exit
                      if
            else
                 echo "please enter valid value 3"
            fi

        例： 判断用户输入的是什么文件
                 #！/bin/bash
                   read -t 30 -p "please input a file name " file
                        if [ -z "$file" ]
                              then
                                  echo "error please input a filename"
                                  exit 11
                        elif [ -e "$file" ]
                              then
                                  echo "your input is not a file"
                                  exit 12
                         elif [ -f "$file" ]
                              then
                                  echo "$file is a regulare file"
                          elif [ -d "$file" ]
                              then
                                  echo "$file is a disectory"
                          else
                                 echo "$file is an other file"
                          fi

             多分支case条件语句
                case语句和if...elif...else语句一样都是多分支条件语句，不过和if多分支条件语句不同的事，case语句只能判断一种条件关系，而if语句可以判断多种条件关系

                 case  $变量名  in
                      "值1")
                          如果变量值等于1，则执行程序1
                          ;;
                      "值2")
                          如果变量值等于2，则执行程序2
                          ;;
                      *)
                          如果变量值都不是以上的值，则执行此程序
                          ;;
                  esac

        例：
                #！/bin/bash
                  read -t 30 -p "please choose yes/no" cho
                    
                    case $cho in 
                          "yes")
                                echo "your choose is yes"
                                ;;
                          "no")
                                echo "your choose is no"
                                ;;
                          *)
                                echo "your choose is yes"
                                ;;                                          
              esac

              for 循环
                  语法1
                    for  变量  in   值1 值2 值3
                          do
                                  程序
                          done

              例：
                     #！/bin/bash
                            for i in 1 2 3 4 5
                                    do
                                        echo $i
                                    done
                
                       #!/bin/bash
                            cd /root/test
                            ls *.tar.gz >ls.log
                             for i in $(cat ls.log)
                              do
                                   tar -zxvf $i &> /dev/null
                             done
                         rm -rf ls.log
    
            语法2 
                for (( 初始值；循环控制条件；变量变化 ))
                          do  
                              程序
                          done
                 
              例：
                #！/bin/bash
                    s=0
                     for (( i=1; i<100; i=i+1 ))
                          do
                              s=$(( $s+$i ))
                          done

             例：批量添加数量的用户
            #!/bin/bash
            read -t 30 -p "please input user name " name
            read -t 30 -p "please input the number of users " num
            read -t 30 -p "please input the password of users " pass

            if [ ! -z "$name" -a ! -z "$num" -a ! -z "$pass" ]
              then
                y=$(echo $num | sed 's/[0-9]//g')
                if [ -z "$y" ]
                        then
                            for (( i=1; i<=$num ; i=i+1 ))
                                do
                                    /usr/sbin/useradd $name$i &> /dev/null
                                    echo $pass | /usr/bin/paswd --stdin $name$i &>/dev/null
                                done
                  fi
          fi

           例: 删除所有用户
               #！/bin/bash

                  for i in $(cat /etc/passwd | grep /bin/bash | grep -v root | cut -d ":" -f 1 )
                          do
                                userdel -r $i
                          done
             
            while循环
              while循环是不定循环，也称作条件循环。只要条件判断式成立，循环就会一直继续，知道条件判断式不成立，循环才会停止。这就和for的固定循环不太一样了。

            while  [ 条件判断式 ]
                  do
                        程序
                  done

              例：
                  #！/bin/bash
                      i=1
                      s=0
                      while [ $i -le 100 ]
                        do 
                            s=$(( $s+$i ))
                            i=$(( $i+1 ))
                        done
                      echo "the num is $s" 

                  until循环
                    untile循环，和while循环相反，until循环时只要条件判断式不成立则进行循环，并执行循环程序，一旦循环条件成立，则终止循环
      
                  until [ 条件判断式 ]
                        do  
                            程序
                        done
              
                例：
                
                   #！/bin/bash
                    i=1
                    s=0
                      until [ $i -gt 100 ]
                            do  
                                s=$(( $s+$i )) 
                                i = $(( $i +1 ))
                             done
                      echo "the sum is : $s"