shellScript 常用

最新推荐文章于 2024-02-03 20:03:26 发布

repeatthink_yuchao

最新推荐文章于 2024-02-03 20:03:26 发布

阅读量287

点赞数

分类专栏： shellScript shell 文章标签： shellScript

本文链接：https://blog.csdn.net/qq_34606853/article/details/102454786

版权

shellScript 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

shell

1 篇文章 0 订阅

订阅专栏

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>shell脚本常用</title>
</head>

<body>

<pre>
#指定用哪个shell执行脚本
#!/bin/sh
#----------------
echo "当前脚本: /ShellProgramSecond/shellTest.sh"
#----------------
   #if测试
   function ifFuncTest(){
       echo -e "ifFuncTest====开始";
       #date 命令结束状态码为 0 时执行 if 语句体
       if date; then
           echo "date 指令结束状态码为0"
       fi
       echo -e "ifFuncTest====结束";
   }
#----------------
   #ifelse 测试
   function ifelseFuncTest(){
       echo -e "ifelseFuncTest====开始";
       #date 命令结束状态码为 0 时执行 if 语句体,否则执行else语句体
       if date; then
           echo "date 指令结束状态码为0"
       else
           echo "date 指令结束状态码非0"
       fi
       echo -e "ifelseFuncTest====结束";
   }
#----------------
   #if 与 test 命令
   function shtestif(){
       echo -e "shtestif====开始";
       v1=6;
       v2=7
       if [ $v1 -lt $v2 ]; then
           echo $v1 小于 $v2
       fi
       echo -e "shtestif====结束";
   }

#----------------
   #ifelse 与 test 命令
   function shtestifelse(){
       echo -e "shtestifelse====开始";
       v1=6;
       v2=7;
       if [ $v1 -lt $v2 ]; then
           echo $v1 小于 $v2
       else
           echo $v1 大于等于 $v2
       fi
       echo -e "shtestifelse====结束";
   }
#----------------
   #ifelif 与 test 命令
   function shtestifelif(){
       echo -e "shtestifelif====开始";
       v1=8;
       v2=7;
       if [ $v1 -lt $v2 ]; then
           echo $v1 小于 $v2
       elif [ $v1 -eq $v2 ]; then
           echo $v1 等于 $v2
       else
           echo $v1 大于 $v2
       fi
       echo -e "shtestifelif====结束";
   }
#----------------
   #字符串比较大小
   function strGTTest(){
       echo -e "strGTTest====开始";
       s1=aCc;
       s2=abcd;
       if [ $s1 \> $s2 ]; then
           echo $s1 大于 $s2
       else
           echo $s1 小于或等于 $s2
       fi
       echo -e "strGTTest====结束";
   }
#----------------
   #字符串比较大小
   function strLengthTest(){
       echo -e "strLengthTest====开始";
       defineEmpty='';
       echo undefine的值: $undefine
       #-n 未定义【未定义变量加双引号(同时避免空格的干扰)时默认长度为0 走else 】
       if [ -n "$undefine" ]; then
           echo "-n 未定义 if 执行【加双引号】"
       else
           echo "-n 未定义 else 执行【加双引号】"
       fi

       #-n 未定义【未定义变量加双引号(同时避免空格的干扰)时默认长度为非0 走if 】
       if [ -n $undefine ]; then
           echo "-n 未定义 if 执行【不加双引号】"
       else
           echo "-n 未定义 else 执行【不加双引号】"
       fi

       #-z 未定义【默认长度为0 走 if】
       if [ -z $undefine ]; then
           echo "-z 未定义 if 执行【不加双引号】"
       else
           echo "-z 未定义 else 执行【不加双引号】"
       fi

       # z 未定义【长度为0 走 if 】
       if [ -z "$undefine" ]; then
           echo "-z 未定义 if 执行【加双引号】"
       else
           echo "-z 未定义 else 执行【加双引号】"
       fi

       #-n 定义值为空【默认长度非0走if】
       if [ -n $defineEmpty ]; then
           echo "-n 定义但值空 if 执行【不加双引号】"
       else
           echo "-n 定义但值空 else 执行【不加双引号】"
       fi

       #-n 定义值为空【默认长度0走else】
       if [ -n "$defineEmpty" ]; then
           echo "-n 定义但值空 if 执行【加双引号】"
       else
           echo "-n 定义但值空 else 执行【加双引号】"
       fi

       #-z 定义值为空【默认长度为0走if】
       if [ -z $defineEmpty ]; then
           echo "-z 定义但值空 if 执行【不加双引号】"
       else
           echo "-z 定义但值空 else 执行【不加双引号】"
       fi

       #-z 定义值为空【默认长度为0走if】
       if [ -z "$defineEmpty" ]; then
           echo "-z 定义但值空 if 执行【加双引号】"
       else
           echo "-z 定义但值空 else 执行【加双引号】"
       fi

       echo -e "strLengthTest====结束";
   }
#----------------

#---------------
   function strCompareTest(){
       echo -e "strCompareTest====开始";
       p1=p1
       p2=p2;
       p11=p1;
       #相同
       if [ $p1=$p11 ]; then
           echo $p1 相同于 $p11
       else
           echo $p1 不相同于 $p11
       fi
       #不同
       if [ $p1=$p2 ]; then
           echo $p1 相同于 $p2
       else
           echo $p1 不相同于 $p2
       fi
       #> 备注必须使用转义字符因为 > 默认是重定向, 转移后 \v 才是比较运算
       if [ $p1 \> $p2 ]; then
           echo $p1 大于 $p2
       else
           echo $p1 小于 $p2
       fi
       #< 备注必须使用转义字符因为 > 默认是重定向, 转移后 \v 才是比较运算
       if [ $p1 \< $p2 ]; then
           echo $p1 小于 $p2
       else
           echo $p1 大于 $p2
       fi
       #-n 长度非0时执行 , 备注变量必须用双引号(同时避免空格的干扰)包裹
       if [ -n "$p1" ];then
           echo $p1 长度非0
       else
           echo $p1 长度为0
       fi
       #-z 长度0时执行, 备注变量必须用双引号(同时避免空格的干扰)包裹
       if [ -z "$p2" ];then
           echo $p2 长度为0
       else
           echo $p2 长度非0
       fi
       echo -e "strCompareTest====结束";
   }
#---------------
   #测文件比较
   function fileCompare(){
       echo -e "fileCompare====开始";
       curFolderPath="./ShellProgramSecond/";
       fe=yc.txt;
       fne=ycne.txt;
       de=folder;
       dne=folderne;
       #文件存在
       tfe=$curFolderPath$fe;
       #文件不存在
       tfne=$curFolderPath$fne;
       #文件夹存在
       tde=$curFolderPath$de;
       #文件夹不存在
       tdne=$curFolderPath$dne;
       echo tfe : $tfe;
       echo tfne : $tfne;
       echo tde : $tde;
       echo tdne : $tdne;

       #文件存在且类型是文件
       if [ -f $tfe ]; then
           echo $tfe 文件存在
       else
           echo $tfe 文件不存在
       fi

       #文件存在且类型是文件
       if [ -f $tfne ]; then
           echo $tfne 文件存在
       else
           echo $tfne 文件不存在
       fi

       #文件夹存在且类型是文件夹
       if [ -d $tde ]; then
           echo $tde 文件夹存在
       else
           echo $tde 文件夹不存在
       fi

       #文件夹存在且类型是文件夹
       if [ -d $tdne ]; then
           echo $tdne 文件夹存在
       else
           echo $tdne 文件夹不存在
       fi

       #判断文件是否存在[无论类型是文件还是文件夹] 是否存在
       if [ -e $tfe ]; then
           echo $tfe 文件存在
       else
           echo $tfe 文件不存在
       fi

       #判断类型为文件的文件是否为空文件 [文件为空的判断:文件大小为0]
       if [ -s $tfe ];then
           echo $tfe 文件存在且非空
       else
           echo $tfe 文件不存在或文件存在但空[文件大小为0]
       fi

       #只局限于文件类型为文件的, 目录的行不通
       if [ -s $tde ];then
           echo $tde 文件夹存在且非空
       else
           echo $tde 文件夹不存在或文件夹存在但空
       fi

       #检测: 文件类型是文件且文件是否可读
       if [ -r $tfe ];then
           echo $tfe 文件存在且可读
       else
           echo $tfe 文件不存在或文件存在但不可读
       fi

       #检测: 文件类型是文件且文件是否可写
       if [ -w $tfe ];then
           echo $tfe 文件存在且可写
       else
           echo $tfe 文件不存在或文件存在但不可写
       fi

       #检测: 文件类型是文件且是否可执行
       if [ -x $tfe ]; then
           echo $tfe 文件存在且可执行
       else
           echo $tfe 文件不存在或文件存在但不可执行
       fi

       #判断文件的属主是否是当前登录用户
       if [ -O $tfe ]; then
           echo $tfe 文件的属主是当前登录用户
       else
           echo $tfe 文件的属主不是当前登录用户
       fi

       #比较 [ ./19 -nt ./18 ] 文件19的更新时间比文件18的更新时间大时执行
       if [ ./19 -nt ./18 ]; then
           echo 19 比 18新
       else
           echo 19 没 18新
       fi

       echo -e "fileCompare====结束";
   }
#----------------
   #双圆括号测试
   function dbKuoTest(){
       echo -e "dbKuoTest====开始";
       v1=10;
       #备注双括号里 > 不是重定向也不用 \> 进行转义
       if (( $v1**2 > 90 )); then
           echo $v1**2 大于 90
           #声明变量并进行计算,备注计算与赋值均是在 (()) 中按成的
           (( v2=$v1**2 ))
           echo v2值: $v2
       else
           echo $v1**2 小于 90
       fi
       echo -e "dbKuoTest====结束";
   }
#----------------
   #双方括号测试
   function doubleFangTest(){
       echo -e "doubleFangTest====开始";
       n=yuchao;
       if [[ $n==yu* ]];then
           echo $n 匹配正则yu*
       else
           echo $n 不匹配正则yu*
       fi
       echo -e "doubleFangTest====结束";
   }
#----------------
   #case 测试 case 用法
   function caseTest(){
       echo -e "caseTest====开始";
       p=1;
       case $p in
           1 | 2)
                   echo p的值: $p ;;
                   3)
                   echo p的值: $p ;;
                   *)
                   echo p的值未知 ;;
       esac
       echo -e "caseTest====结束";
   }
#----------------
   function shfuncName(){
       echo -e "shfuncName====开始";

       echo -e "shfuncName====结束";
   }
#----------------
   #sh 第一种for 循环
   function shforone(){
       echo -e "shforone====开始";
       #内部字段分割符使用的优先次序是换行,制表,空格 ,谁先存在就先使用谁
       echo -e "list1====开始";
       list='yuchao1 yuchao2 yuchao3';
       for ele in $list
       do
           echo $ele
       done
       echo -e "list1====结束";

       echo -e "list2====开始";
       #用双引号括起单引号或反过来
       list2="yu'chao1 yu'chao2";
       for ele2 in $list2
       do
           echo $ele2
       done
       echo -e "list2====结束";

       #值含有空格的解决方法
       echo -e "list3====开始";
       for ele3 in "yu chao1" "yu chao2" "yu chao3"
       do
           echo $ele3
       done
       echo -e "list3====结束";

       echo -e "list4====开始";
       list41="yuchao1 yuchao2 yuchao3";
       #备注 shell 脚本字符串拼接与 java字符串拼接两种语法处理是不一样的,习惯就好
       list4=$list41" yuchao4";
       for ele4 in $list4
       do
           echo $ele4
       done
       echo -e "list4====结束";

       echo -e "shforone====结束";
   }
#----------------
   #for命令从命令读取列表
   function shforcmd(){
       echo -e "shforcmd====开始";
       #文件绝对路径
       fap="./ShellProgramSecond/yc.txt";
       #反引号获取命令出参数并当做 for命令的入参数, for 的 IFS 优先次序是 : 换行/制表/空格【默认情况下:大家依次去分割】
       for ele in ` cat $fap `
       do
           echo $ele
       done
       echo -e "shforcmd====结束";
   }
#----------------
   #for命令 ifs 更换成换行分割符测试
   function shforcmdifs(){
       echo -e "shforcmdifs====开始";
       fap="./ShellProgramSecond/yc.txt";

       IFSOLD=$IFS;
       #换行符作为分割符
       IFS=$'\n';
       for ele in ` cat $fap `
       do
           echo $ele
       done
       IFS=$IFSOLD;

       echo -e "shforcmdifs====结束";
   }
#----------------
   #for命令用通配符读取目录
   function shforpathreg(){
       echo -e "shforpathreg====开始";
       pathReg="./ShellProgramSecond/*";
       for file in $pathReg
       do
           #路径
           if [ -d "$file" ] ; then
               echo 路径:$file;
           #文件
           elif [ -f "$file" ]; then
               echo 文件:$file;
           else
               echo 非路径且非文件:$file;
           fi
       done
       echo -e "shforpathreg====结束";
   }
#----------------
   #for命令用通配符读取目录
   function shforpathregTest(){
       echo -e "shforpathregTest====开始";
       pathReg="./*"
       echo 通配符路径名:$pathReg;
       #遍历统配符路径 pathReg 下的所有目录与文件
       for file in $pathReg
       do
           #路径
           if [ -d "$file" ] ; then
               echo 路径:$file;
           #文件
           elif [ -f "$file" ]; then
               echo 文件:$file;
           else
               echo 非路径且非文件:$file;
           fi
       done
       echo -e "shforpathregTest====结束";
   }
#----------------
   #c风格的for[单个变量]
   function shcfor(){
       echo -e "shcfor====开始";
       #变量名 = 变量值可有空格且计算不同 expr 与 [ exp ]
       for (( i=1;i<=10;i++ ))
       do
           echo $i
       done
       echo -e "shcfor====结束";
   }
#----------------
   #c风格的for[多个变量]
   function shcfordoublep(){
       echo -e "shcfordoublep====开始";
       for (( i=1,j=1;i<=10;i++ ))
       do
           #计算
           j=$[ $j+1 ];
           echo i:$i j:$j
       done
       echo -e "shcfordoublep====结束";
   }
#----------------
   #while循环条件是命令结束状态码
   function shwhiletest(){
       echo -e "shwhiletest====开始";
       #你会发现这个是死循环,因为 echo yuchao 的结束状态码永远是 0
       while echo yuchao
       do
           echo 执行while方法体
       done
       echo -e "shwhiletest====结束";
   }
#----------------
   #while循环条件是表达式计算的结果
   function shwhileexpression(){
       echo -e "shwhileexpression====开始";
       con=10;
       #表达式计算为真时执行
       while [ $con -ge 0 ]
       do
           echo $con;
           #计算
           con=$[ $con-1 ];
       done
       echo -e "shwhileexpression====结束";
   }
#----------------
   #until循环条件是命令结束状态码
   function shuntilcmd(){
       echo -e "shuntilcmd====开始";
       #command 命令结束状态码非0时执行,0时退出 [ 所以你会发现仅仅会执行一次 command]
       until echo yuchao
       do
           commands
       done
       echo -e "shuntilcmd====结束";
   }
#----------------
   # until 循环条件是表达式计算的结果
   function shuntilexpression(){
       echo -e "shuntilexpression====开始";
       con=10;
       #表达式计算结果为假时执行,真时退出
       until [ $con -eq 0 ]
       do
           echo $con
           #计算
           con=$[ $con-1 ];
       done
       echo -e "shuntilexpression====结束";
   }

#----------------
   #C风格嵌套循环
   function shcforcfor(){
       echo -e "shcforcfor====开始";
       #变量名 = 变量值可有空格且计算不用 expr 与 [ exp ]
       for (( i=1;i<=3;i++ ))
       do
           echo $i ====开始;
           for (( j=1;j<=3;j++ ))
           do
               echo $j
           done
           echo $i ====结束;
       done
       echo -e "shcforcfor====结束";
   }
#----------------
   #while 中嵌入 cfor
   function shwhilecfor(){
       echo -e "shwhilecfor====开始";
       whiCon=3;

       while [ $whiCon -gt 0 ]
       do
           echo $whiCon ====开始;
           for (( i=1;i<=$whiCon;i++))
           do
               echo $i
           done
           echo $whiCon ====结束;
           #计算
           whiCon=$[ $whiCon-1 ];
       done
       echo -e "shwhilecfor====结束";
   }
#----------------
   #for 循环遍历文件
   function shforfile(){
       echo -e "shforfile====开始";
       #待读文件绝对路径
       fap="./ShellProgramSecond/yc.txt";
       #原始 IFS
       IFSOLD=$IFS;
       #自定义 IFS 为换行
       IFS=$'\n';
       #反引号中查看路径fap文件命令的出参数用 IFS 切割后给外层for
       for line in ` cat $fap `
       do
           echo $line;
       done
       #还原IFS初始值
       IFS=$IFSOLD;
       echo -e "shforfile====结束";
   }
#----------------
   #for 与 for 结合遍历文件内容的demo
   function shforforfile(){
       echo -e "shforforfile====开始";
       #这里文件的内容是从 /etc/passwd 文件中拷贝出来的
       fap="./ShellProgramSecond/yc.txt";
       #原始 IFS
       IFSOLD=$IFS;
       #自定义 IFS 为换行
       IFS=$'\n';
       #反引号中查看路径fap文件命令的出参数用 IFS 切割后给外层for
       for line in ` cat $fap `
       do
           #我比较好奇的是这里打印的行数据和文件中的行数据有些出入
           echo $line ====开始;
           #重新设置IFS分割符为:号
           IFS=:
           #将行line 用 IFS 分割后给内层for
           for field in $line
           do
               echo $field
           done
           echo $line ====结束;
       done
       #还原IFS初始值
       IFS=$IFSOLD;
       echo -e "shforforfile====结束";
   }
#----------------
   #单重循环 break 【 slb 】 ,跳出整个循环体
   function slb(){
       echo -e "slb====开始";
       list="1 2 3";
       for ele in $list
       do
           #2时跳出整个循环体
           if [ $ele -eq 2 ];then
               echo slb 在 2 时跳出整个循环体;
               break;
           else
               echo $ele;
           fi
       done
       echo -e "slb====结束";
   }
#----------------
   #单重循环 continue 【 slc 】,结束当前 i访问与 i+1访问之间的内容,然后从 i+1访问开始
   function slc(){
       echo -e "slc====开始";
       list="1 2 3";
       for ele in $list
       do
           #2时跳出整个循环体
           if [ $ele -eq 2 ];then
               echo 结束 2 与 3 之间的内容,然后从3开始访问;
               continue;
           else
               echo $ele;
           fi
           echo $ele 与 $[ $ele+1 ] 之间的内容
       done
       echo -e "slc====结束";
   }
#----------------
   #双重循环外 break 【 dlob 】,跳出整个外循环体
   function dlob(){
       echo -e "dlob====开始";
       list1="1 2 3";
       list2="a b c";
       for ele1 in $list1
       do
           #2时跳出整个循环体
           if [ $ele1 -eq 2 ];then
               echo 外循环在2时执行break;
               break;
           else
               echo $ele1 ====外开始;
           fi
           #内层循环
           for ele2 in $list2
           do
               echo $ele2
           done
           echo $ele1 ====外结束;
       done
       echo -e "dlob====结束";
   }
#----------------
   #双重循环内 break【 dlib 】,跳出外循环当前 i访问时对应的那个内循环体 , 然后开始外循环的i+1访问
   function dlib(){
       echo -e "dlib====开始";
       list1="1 2 3";
       list2="a b c";
       for ele1 in $list1
       do
           echo $ele1 ====外开始;
           #内层循环
           for ele2 in $list2
           do
               #a时跳出整个循环体
               if [ $ele2 = "a" ];then
                   echo 外层 $ele1 对应的内循环在a时执行 break, 结束外层 $ele1 访问对应的内循环,开始 $[ $ele1+1 ] 访问;
                   break;
               else
                   echo $ele2
               fi
           done
           echo $ele1 ====外结束;
       done
       echo -e "dlib====结束";
   }
#----------------
   #双重循环外 continue【 dloc 】,结束外循环中 i 访问与 i+1 访问之间的内容,开始外循环的 i+1
   function dloc(){
       echo -e "dloc====开始";
       list1="1 2 3";
       list2="a b c";
       for ele1 in $list1
       do
           echo $ele1 ====外开始;
           #2时结束外层循环 2 与 3 之间的访问,直接开始外层3的访问
           if [ $ele1 -eq 2 ];then
               echo 结束外层循环 2 与 3 之间的访问,直接开始外层3的访问;
               continue;
           fi
           #内层循环
           for ele2 in $list2
           do
               echo $ele2
           done
           echo $ele1 ====外结束;
       done
       echo -e "dloc====结束";
   }
#----------------
   #双重循环内 continue【 dlic 】,结束内循环中 j 访问与 j+1 访问之间的内容,开始内循环的 j+1
   function dlic(){
       echo -e "dlic====开始";
       list1="1 2 3";
       list2="a b c";
       for ele1 in $list1
       do
           echo $ele1 ====外开始;
           #内层循环
           for ele2 in $list2
           do
               #a时结束内层循环 a 与 b 之间的访问,直接开始内层b的访问
               if [ $ele2 = 'a' ];then
                   echo $els1 访问的内层循环: 结束该内层循环 a 与 b 之间的访问,直接开始内层b的访问;
                   continue;
               fi
               echo $ele2 与下一个之间的访问;
           done
           echo $ele1 ====外结束;
       done
       echo -e "dlic====结束";
   }
#----------------
   #shforout 循环输出
   function shforout(){
       echo -e "shforout====开始";
       pathReg="./ShellProgramSecond/*";
       shforoutf="./ShellProgramSecond/shforoutf.txt";
       #遍历统配符路径 pathReg 下的所有目录与文件
       for file in $pathReg
       do
           #路径,双引号包裹避免空格的干扰
           if [ -d "$file" ] ; then
               echo 路径:$file;
           #文件
           elif [ -f "$file" ]; then
               echo 文件:$file;
           else
               echo 非路径且非文件:$file;
           fi
       done | sort > $shforoutf
       echo -e "shforout====结束";
   }
#----------------

#----------------

</pre>

</body>

</html>

repeatthink_yuchao

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
shellScript 常用

<html><head>  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>shell脚本常用</title></head><body>...
复制链接

扫一扫