Shell脚本的基本运算符应用

爱被打了一巴掌 2024-04-23 01:54 4阅读 0赞

**记录**：432

**场景**：Shell脚本的基本运算符应用。一般包括算术运算符、关系运算符、布尔运算符、逻辑运算符、字符串运算符、文件检测运算符。

**版本**：CentOS Linux release 7.9.2009。

**1.算术运算符**

**1.1运算符**

算术运算符。

\+：加法。

\-：减法。

\*：乘法。

/：除法。

%：取余。

=：赋值。

==：相等。

!=：不相等。

**1.2脚本**

脚本名称：b2023052401.sh

脚本内容：

#!/bin/bash
    
    echo '使用(())、expr、let执行算术运算: + - * / %'
    echo "请输入两个数字(使用空格分割):"
    read num01 num02
    
    # 1.使用(())、expr、let执行算术运算: + 
    num=`expr ${num01} + ${num02}`
    echo "${num01} + ${num02} = ${num}"
    
    num=$((${num01} + ${num02}))
    echo "${num01} + ${num02} = ${num}"
    
    let num=${num01}+${num02}
    echo "${num01} + ${num02} = ${num}"
    
    # 2.使用(())、expr、let执行算术运算: -
    num=`expr ${num01} - ${num02}`
    echo "${num01} - ${num02} = ${num}"
    
    num=$((${num01} - ${num02}))
    echo "${num01} - ${num02} = ${num}"
    
    let num=${num01}-${num02}
    echo "${num01} - ${num02} = ${num}"
    
    # 3.使用(())、expr、let执行算术运算: *
    num=`expr ${num01} \* ${num02}`
    echo "${num01} * ${num02} = ${num}"
    
    num=$((${num01} * ${num02}))
    echo "${num01} * ${num02} = ${num}"
    
    let num=${num01}*${num02}
    echo "${num01} * ${num02} = ${num}"
    
    # 4.使用(())、expr、let执行算术运算: /
    num=`expr ${num01} / ${num02}`
    echo "${num01} / ${num02} = ${num}"
    
    num=$((${num01} / ${num02}))
    echo "${num01} / ${num02} = ${num}"
    
    let num=${num01}/${num02}
    echo "${num01} / ${num02} = ${num}"
    
    # 5.使用(())、expr、let执行算术运算: %
    num=`expr ${num01} % ${num02}`
    echo "${num01} % ${num02} = ${num}"
    
    num=$((${num01} % ${num02}))
    echo "${num01} % ${num02} = ${num}"
    
    let num=${num01}%${num02}
    echo "${num01} % ${num02} = ${num}"
    
    echo '6.验证: ==和!='
    
    if [ ${num01} == ${num02} ]; then
    echo "输入的两个数相等"
    fi
    
    if [ ${num01} != ${num02} ]; then
    echo "输入的两个数不相等"
    fi

**1.3执行与输出**

执行命令：bash b2023052401.sh

执行结果：

[root@hadoop211 tutorial]# bash b2023052401.sh 
    使用(())、expr、let执行算术运算: + - * / %
    请输入两个数字(使用空格分割):
    100 2
    100 + 2 = 102
    100 + 2 = 102
    100 + 2 = 102
    100 - 2 = 98
    100 - 2 = 98
    100 - 2 = 98
    100 * 2 = 200
    100 * 2 = 200
    100 * 2 = 200
    100 / 2 = 50
    100 / 2 = 50
    100 / 2 = 50
    100 % 2 = 0
    100 % 2 = 0
    100 % 2 = 0
    6.验证: ==和!=
    输入的两个数不相等

**2.关系运算符**

**2.1运算符**

关系运算符，只支持数字，不支持字符串。

\-eq：检测两个数是否相等，如果相等返回true，否则返回false。

\-ne：检测两个数是否不相等，如果不相等返回true，否则返回false。

\-gt：检测左边数是否大于右边的数，如果是返回true，否则返回false。

\-lt：检测左边数是否小于右边的数，如果是返回true，否则返回false。

\-ge：检测左边数是否大于等于右边的数，如果是返回true，否则返回false。

\-le：检测左边数是否小于等于右边的数，如果是返回true，否则返回false。

**2.2脚本**

脚本名称：b2023052402.sh

脚本内容：

#!/bin/bash
    
    echo '使用test命令和[]验证关系运算符.'
    echo '关系运算符: -eq -ne -gt -lt -ge -le '
    echo "请输入两个数字(使用空格分割):"
    read num01 num02
    
    #1.使用-eq,检测两个数是否相等,如果相等返回true,否则返回false.
    echo '1.[]和test命令分别和-eq组合应用'
    if [ ${num01} -eq ${num02} ];then
       echo "${num01} -eq ${num02} : 两数相等."
    else 
       echo "${num01} -eq ${num02} : 两数不相等."
    fi
     
    if test $[num01] -eq $[num02];then
       echo "${num01} -eq ${num02} : 两数相等."
    else 
       echo "${num01} -eq ${num02} : 两数不相等."
    fi 
    
    #2.使用-ne,检测两个数是否不相等,如果不相等返回true,否则返回false.
    echo '2.[]和test命令分别和-ne组合应用'
    if [ ${num01} -ne ${num02} ];then
       echo "${num01} -ne ${num02} : 两数不相等."
    else
       echo "${num01} -ne ${num02} : 两数相等."
    fi
    
    if test $[num01] -ne $[num02];then
       echo "${num01} -ne ${num02} : 两数不相等."
    else
       echo "${num01} -ne ${num02} : 两数相等."
    fi
    
    #3.使用-gt,检测左边数是否大于右边的数,如果是返回true,否则返回false.
    echo '3.[]和test命令分别和-gt组合应用'
    if [ ${num01} -gt ${num02} ];then
       echo "${num01} -gt ${num02} : 左边的数大于右边的数"
    else
       echo "${num01} -gt ${num02} : 左边的数不大于右边的数"
    fi
    
    if test $[num01] -gt $[num02];then
       echo "${num01} -gt ${num02} : 左边的数大于右边的数"
    else
       echo "${num01} -gt ${num02} : 左边的数不大于右边的数"
    fi
    
    #4.使用-lt,检测左边数是否小于右边的数,如果是返回true,否则返回false.
    echo '4.[]和test命令分别和-lt组合应用'
    if [ ${num01} -lt ${num02} ];then
       echo "${num01} -lt ${num02} : 左边的数小于右边的数"
    else
       echo "${num01} -lt ${num02} : 左边的数不小于右边的数"
    fi
    
    if test $[num01] -lt $[num02];then
       echo "${num01} -lt ${num02} : 左边的数小于右边的数"
    else
       echo "${num01} -lt ${num02} : 左边的数不小于右边的数"
    fi
    
    #5.使用-ge,检测左边数是否大于等于右边的数,如果是返回true,否则返回false.
    echo '5.[]和test命令分别和-ge组合应用'
    if [ ${num01} -ge ${num02} ];then
       echo "${num01} -ge ${num02} : 左边的数大于等于右边的数"
    else
       echo "${num01} -ge ${num02} : 左边的数小于右边的数"
    fi
    
    if test $[num01] -ge $[num02];then
       echo "${num01} -ge ${num02} : 左边的数大于等于右边的数"
    else
       echo "${num01} -ge ${num02} : 左边的数小于右边的数"
    fi
    
    #6.使用-le,检测左边数是否小于等于右边的数,如果是返回true,否则返回false.
    echo '6.[]和test命令分别和-le组合应用'
    if [ ${num01} -le ${num02} ];then
       echo "${num01} -le ${num02} : 左边的数小于等于右边的数"
    else
       echo "${num01} -le ${num02} : 左边的数大于右边的数"
    fi
    
    if test $[num01] -le $[num02];then
       echo "${num01} -le ${num02} : 左边的数小于等于右边的数"
    else
       echo "${num01} -le ${num02} : 左边的数大于右边的数"
    fi

**2.3执行与输出**

执行命令：bash b2023052402.sh

执行结果：

[root@hadoop211 tutorial]# bash b2023052402.sh 
    使用test命令和[]验证关系运算符.
    关系运算符: -eq -ne -gt -lt -ge -le 
    请输入两个数字(使用空格分割):
    99 888
    1.[]和test命令分别和-eq组合应用
    99 -eq 888 : 两数不相等.
    99 -eq 888 : 两数不相等.
    2.[]和test命令分别和-ne组合应用
    99 -ne 888 : 两数不相等.
    99 -ne 888 : 两数不相等.
    3.[]和test命令分别和-gt组合应用
    99 -gt 888 : 左边的数不大于右边的数
    99 -gt 888 : 左边的数不大于右边的数
    4.[]和test命令分别和-lt组合应用
    99 -lt 888 : 左边的数小于右边的数
    99 -lt 888 : 左边的数小于右边的数
    5.[]和test命令分别和-ge组合应用
    99 -ge 888 : 左边的数小于右边的数
    99 -ge 888 : 左边的数小于右边的数
    6.[]和test命令分别和-le组合应用
    99 -le 888 : 左边的数小于等于右边的数
    99 -le 888 : 左边的数小于等于右边的数

**3.布尔运算符**

**3.1运算符**

布尔运算符一般是与、或、非。

!：非运算，如果表达式为true，否则返回false。

\-o：或运算，只要有一个表达式为true，则返回true，否则返回false。

\-a：与运算，两个表达式都为true，则返回true，否则返回false。

**3.2脚本**

脚本名称：b2023052403.sh

脚本内容：

#!/bin/bash
    
    echo '使用test命令和[]验证布尔运算符.'
    echo '布尔运算符: ! -o -a '
    echo "请输入两个数字(使用空格分割):"
    read num01 num02
    
    #1.使用!,非运算,如果表达式为true,否则返回false.
    echo '1.[]和test命令分别和!组合应用,使用!优先级低且需要空格'
    if [ ! ${num01} -gt ${num02} ];then
       echo "${num01} -gt ${num02} : 左边的数大于右边的数(表达式取!结果)"
    else
       echo "${num01} -gt ${num02} : 左边的数不大于右边的数(表达式取!结果)"
    fi
    
    if test ! $[num01] -gt $[num02];then
       echo "${num01} -gt ${num02} : 左边的数大于右边的数(表达式取!结果)"
    else
       echo "${num01} -gt ${num02} : 左边的数不大于右边的数(表达式取!结果)"
    fi
    
    #2.使用-o,或运算,只要有一个表达式为true,则返回true,否则返回false.
    echo '2.[]和test命令分别和-o组合应用'
    if [ ${num01} -gt 999 -o ${num02} -lt 88  ];then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi
    
    if test  ${num01} -gt 999 -o ${num02} -lt 88 ;then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi
    
    #3.使用-a,与运算,两个表达式都为true,则返回true,否则返回false.
    echo '3.[]和test命令分别和-a组合应用'
    if [ ${num01} -gt 999 -a ${num02} -lt 88  ];then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi
    
    if test  ${num01} -gt 999 -a ${num02} -lt 88 ;then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi

**3.3执行与输出**

执行命令：bash b2023052403.sh

执行结果：

[root@hadoop211 tutorial]# bash b2023052403.sh 
    使用test命令和[]验证布尔运算符.
    布尔运算符: ! -o -a 
    请输入两个数字(使用空格分割):
    800 120
    1.[]和test命令分别和!组合应用,使用!优先级低且需要空格
    800 -gt 120 : 左边的数不大于右边的数(表达式取!结果)
    800 -gt 120 : 左边的数不大于右边的数(表达式取!结果)
    2.[]和test命令分别和-o组合应用
    其它情况,判断表达式返回: false
    其它情况,判断表达式返回: false
    3.[]和test命令分别和-a组合应用
    其它情况,判断表达式返回: false
    其它情况,判断表达式返回: false

**4.逻辑运算符**

**4.1运算符**

逻辑运算符包括&&和||。

&&：逻辑与运算，全部为true，则为true，否则返回false。

||：逻辑或运算，有一个为true，则为true，否则返回false。

**4.2脚本**

脚本名称：b2023052404.sh

脚本内容：

#!/bin/bash
    
    echo '使用test命令和[]验证逻辑运算符.'
    echo '逻辑运算符: || && '
    echo "请输入两个数字(使用空格分割):"
    read num01 num02
    
    #1.使用||,逻辑或运算,有一个为true,则为true,否则返回false.
    echo '1.[]和test命令分别和||组合应用'
    if [[ ${num01} -gt 999 || ${num02} -lt 88 ]];then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi
    
    if test  ${num01} -gt 999 || test ${num02} -lt 88 ;then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi
    
    #2.使用&&,逻辑与运算,全部为true,则为true,否则返回false.
    echo '2.[]和test命令分别和&&组合应用'
    if [[ ${num01} -gt 999 && ${num02} -lt 88 ]];then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi
    
    if test ${num01} -gt 999 && test ${num02} -lt 88 ;then
       echo "${num01}大于999或者${num02}小于88,判断表达式返回: true"
    else
       echo "其它情况,判断表达式返回: false"
    fi

**4.3执行与输出**

执行命令：bash b2023052404.sh

执行结果：

[root@hadoop211 tutorial]# bash b2023052404.sh 
    使用test命令和[]验证逻辑运算符.
    逻辑运算符: || && 
    请输入两个数字(使用空格分割):
    800 60
    1.[]和test命令分别和||组合应用
    800大于999或者60小于88,判断表达式返回: true
    800大于999或者60小于88,判断表达式返回: true
    2.[]和test命令分别和&&组合应用
    其它情况,判断表达式返回: false
    其它情况,判断表达式返回: false

**5.字符串运算符**

**5.1运算符**

字符串运算符，检测字符串相关功能。

=：检测两个字符串是否相等，相等则为true，否则返回false。

!=：检测两个字符串是否不相等，不相等则为true，否则返回false。

\-z：检测字符串长度是否为0，为0则返回true，否则返回false。

\-n：检测字符串长度是否不为0，不为0则返回true，否则返回false。

$：检测字符串是否不为空，不为空返回true，否则返回false。

**5.2脚本**

脚本名称：b2023052405.sh

脚本内容：

#!/bin/bash
    
    echo '字符串运算符: = != -z -n $ '
    echo "请输入3个字符串(使用空格分割):"
    read str01 str02 str03
    
    #1.使用=,检测两个字符串是否相等,相等则为true,否则返回false.建议使用[[]]
    if [[ ${str01} = ${str02} ]];then
      echo "${str01} 和 ${str02} 相等"
    else 
      echo "${str01} 和 ${str02} 不相等"
    fi
    
    #2.使用!=,检测两个字符串是否不相等,不相等则为true,否则返回false.建议使用[[]]
    if [[ ${str01} != ${str02} ]];then
      echo "${str01} 和 ${str02} 不相等"
    else
      echo "${str01} 和 ${str02} 相等"
    fi
    
    #3.使用-z,检测字符串长度是否为0,为0则返回true,否则返回false.
    if [ -z ${str03} ];then
      echo "${str03}: 字符串长度为 0"
    else
      echo "${str03}: 字符串长度不为 0"
    fi
    
    #4.使用-n,检测字符串长度是否不为0,不为0则返回true,否则返回false.
    if [ -n "${str03}" ];then
      echo "${str03}: 字符串长度不为 0"
    else
      echo "${str03}: 字符串长度为 0"
    fi
    
    #5.使用$,检测字符串是否不为空,不为空返回true,否则返回false.
    if [ ${str03} ];then
      echo "${str03}: 字符串不为空"
    else
      echo "${str03}: 字符串为空"
    fi

**5.3执行与输出**

执行命令：bash b2023052405.sh

执行结果：

[root@hadoop211 tutorial]# bash b2023052405.sh 
    字符串运算符: = != -z -n $ 
    请输入3个字符串(使用空格分割):
    suzhou hangzhou shanghai
    suzhou 和 hangzhou 不相等
    suzhou 和 hangzhou 不相等
    shanghai: 字符串长度不为 0
    shanghai: 字符串长度不为 0
    shanghai: 字符串不为空

**6.文件检测运算符**

**6.1运算符**

文件检测运算符检测文件属性，file，表示文件名或者目录名。

\-b file：检测文件是否是块设备文件，如果是，则返回true，否则返回false。

\-c file：检测文件是否是字符设备文件，如果是，则返回true，否则返回false。

\-d file：检测文件是否是目录，如果是，则返回true，否则返回false。

\-f file：检测文件是否是普通文件，如果是，则返回true，否则返回false。

\-g file：检测文件是否设置了SGID位，如果是，则返回true，否则返回false。

\-k file：检测文件是否设置了粘着位(Sticky Bit)，如果是，则返回true，否则返回false。

\-p file：检测文件是否是有名管道，如果是，则返回true，否则返回false。

\-u file：检测文件是否是设置了SUID位，如果是，则返回true，否则返回false。

\-r file：检测文件是否可读，如果是，则返回true，否则返回false。

\-w file：检测文件是否可写，如果是，则返回true，否则返回false。

\-x file：检测文件是否可执行，如果是，则返回true，否则返回false。

\-s file：检测文件是否为空(文件大小是否大于0)，如果不为空，则返回true，否则返回false。

\-e file：检测文件(包括目录)是否存在，如果是，则返回true，否则返回false。

\-S file：判断文件是否为socket，如果是，则返回true，否则返回false。

\-L file：检测文件是否存在且是一个符号连接。

可以使用命令：ll，查看文件类型。

**6.2脚本**

脚本名称：b2023052406.sh

脚本内容：

#!/bin/bash
    
    file01=/dev/sda1
    file02=/dev/mem
    file03=/dev/net
    file04=/home/tutorial/t2023052402.txt
    #增加sgid权限(针对目录)
    #chmod 2755 /home/tutorial/t2023052405/
    file05=/home/tutorial/t2023052405/
    #增加sticky bit权限
    #chmod -R 1777 /home/tutorial/t2023052406
    file06=/home/tutorial/t2023052406
    #增加有名管道
    #mkfifo /home/tutorial/t2023052403
    file07=/home/tutorial/t2023052403
    #增加suid权限(针对可执行文件)
    #chmod 4755 /home/tutorial/t2023052408.sh
    file08=/home/tutorial/t2023052408.sh
    file09=/home/tutorial/t2023052401.sh
    file10=/home/tutorial/t2023052401.sh
    file11=/home/tutorial/t2023052401.sh
    file12=/home/tutorial/t2023052401.sh
    file13=/home/tutorial/t2023052401.sh
    file14=/dev/log
    file15=/dev/stdin
    
    #1.使用-b file,检测文件是否是块设备文件,如果是,则返回true,否则返回false.
    if [ -b $file01 ] ;then
      echo "$file01 :是块设备文件"
    else
      echo "$file01 :不是块设备文件"
    fi 
    
    #2.使用-c file,检测文件是否是字符设备文件,如果是,则返回true,否则返回false.
    if [ -c $file02 ] ;then
      echo "$file02 :是字符设备文件"
    else
      echo "$file02 :不是字符设备文件"
    fi
    
    #3.使用-d file,检测文件是否是目录,如果是,则返回true,否则返回false.
    if [ -d $file03 ] ;then
      echo "$file03 :是目录"
    else
      echo "$file03 :不是目录"
    fi
    
    #4.使用-f file,检测文件是否是普通文件,如果是,则返回true,否则返回false.
    if [ -f $file04 ] ;then
      echo "$file04 :是普通文件"
    else
      echo "$file04 :不是普通文件"
    fi
    
    #5.使用-g file,检测文件是否设置了SGID位,如果是,则返回true,否则返回false.
    if [ -g $file05 ] ;then
      echo "$file05 :设置了SGID位"
    else
      echo "$file05 :没设置SGID位"
    fi
    
    #6.使用-k file,检测文件是否设置了粘着位(Sticky Bit),如果是,则返回true,否则返回false.
    if [ -k $file06 ] ;then
      echo "$file06 :设置了粘着位(Sticky Bit)"
    else
      echo "$file06 :没设置粘着位(Sticky Bit)"
    fi
    #7.使用-p file,检测文件是否是有名管道,如果是,则返回true,否则返回false.
    if [ -p $file07 ] ;then
      echo "$file07 :是有名管道"
    else
      echo "$file07 :不是有名管道"
    fi
    #8.使用-u file,检测文件是否是设置了SUID位,如果是,则返回true,否则返回false.
    if [ -u $file08 ] ;then
      echo "$file08 :设置了SUID位"
    else
      echo "$file08 :没设置SUID位"
    fi
    #9.使用-r file,检测文件是否可读,如果是,则返回true,否则返回false.
    if [ -r $file09 ] ;then
      echo "$file09 :文件有可读权限"
    else
      echo "$file09 :文件没有可读权限"
    fi
    #10.使用-w file,检测文件是否可写,如果是,则返回true,否则返回false.
    if [ -w $file10 ] ;then
      echo "$file10 :文件有写权限"
    else
      echo "$file10 :文件没有写权限"
    fi
    #11.使用-x file,检测文件是否可执行,如果是,则返回true,否则返回false.
    if [ -x $file11 ] ;then
      echo "$file11 :文件是可执行权限"
    else
      echo "$file11 :文件没有可执行权限"
    fi
    #12.使用-s file,检测文件是否为空(文件大小是否大于0),如果不为空,则返回true,否则返回false.
    if [ -s $file12 ] ;then
      echo "$file12 :文件大小大于0"
    else
      echo "$file12 :是一个空文件"
    fi
    #13.使用-e file,检测文件(包括目录)是否存在,如果是,则返回true,否则返回false.
    if [ -e $file13 ] ;then
      echo "$file13 :文件存在"
    else
      echo "$file13 :文件不存在"
    fi
    #14.使用-S file,判断文件是否为socket,如果是,则返回true,否则返回false.
    if [ -S $file14 ] ;then
      echo "$file14 :是socket"
    else
      echo "$file14 :不是否为socket"
    fi
    #15.使用-L file,检测文件是否存在且是一个符号连接.
    if [ -L $file15 ] ;then
      echo "$file15 :是一个符号连接"
    else
      echo "$file15 :不是一个符号连接"
    fi

**6.3执行与输出**

执行命令：bash b2023052406.sh

执行结果：

[root@hadoop211 tutorial]# bash b2023052406.sh 
    /dev/sda1 :是块设备文件
    /dev/mem :是字符设备文件
    /dev/net :是目录
    /home/tutorial/t2023052402.txt :是普通文件
    /home/tutorial/t2023052405/ :设置了SGID位
    /home/tutorial/t2023052406 :设置了粘着位(Sticky Bit)
    /home/tutorial/t2023052403 :是有名管道
    /home/tutorial/t2023052408.sh :设置了SUID位
    /home/tutorial/t2023052401.sh :文件有可读权限
    /home/tutorial/t2023052401.sh :文件有写权限
    /home/tutorial/t2023052401.sh :文件是可执行权限
    /home/tutorial/t2023052401.sh :文件大小大于0
    /home/tutorial/t2023052401.sh :文件存在
    /dev/log :是socket
    /dev/stdin :是一个符号连接

以上，感谢。

2023年5月27日