shell脚本编程之使用结构化命令

发表于 | 更新于: | 阅读量 次 | 分类于 | | 热度: ℃ |
字数统计: 4.7k | 阅读时长 ≈ 21

技术交流QQ群:1027579432，欢迎你的加入！

本教程使用Linux发行版Centos7.0系统，请您注意~

  • 结构化命令：许多程序要求对shell脚本中的命令添加一些逻辑流程控制，有一类命令会根据条件使脚本跳过某些命令。这样的一类命令就称为结构化命令。

1.使用if-then语句

  • 最简单的结构化语句是if-then语句，其语法格式如下：

    1
    2
    3
    4
    if 命令
    then
        命令
    fi

  • if-then语句另一种的写法:

    1
    2
    3
    if 命令; then
    命令
    fi

  • 执行流程：

    • 如果if后面那个命令的退出状态码为0，则then之后命令会被执行；
    • 如果if后面那个命令的退出状态码是其他值，则then之后命令不会被执行，bash shell会继续执行脚本中的下一个命令；
    • fi语句用来表示if-then语句到此结束；

  • 实例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #!/bin/bash


    # testing the if statement

    if pwd
    then
      echo "It Worked"
    fi

    # 结果
    [njust@njust tutorials]$ ./curry.sh 
    /home/njust/tutorials
    It Worked

  • 反例如下：[注意]bash shell会跳过then部分的echo语句，同时运行if语句中的那个错误命令所生成的错误消息依然会显示在脚本的输出中。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    #!/bin/bash

    if notCommand
    then
       echo "It worked"
    fi

    echo "skipped 'then' statement"

    # 结果
    [njust@njust tutorials]$ ./durant.sh 
    ./durant.sh:行3: notCommand: 未找到命令
    skipped 'then' statement

  • 在then部分，可以使用不止一条命令。bash shell会将这些命令当成一个语句块。实例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #!/bin/bash

    testuser=njust

    if grep $testuser /etc/passwd  # grep命令在/etc/passwd文件中查找某个用户当前是否在系统上使用
    then
    echo This is my first command
    echo This is my second command
    echo I can even put in other commands besides echo:
    ls -l /home/$testuser/.b*  # 显示一些文本信息并列出该用户HOME目录的bash文件
    fi

    # 结果
    This is my first command
    This is my second command
    I can even put in other commands besides echo:
    -rw-------. 1 njust njust 6013 3月  12 10:50 /home/njust/.bash_history
    -rw-r--r--. 1 njust njust   18 8月   8 2019 /home/njust/.bash_logout
    -rw-r--r--. 1 njust njust  193 8月   8 2019 /home/njust/.bash_profile
    -rw-r--r--. 1 njust njust  231 8月   8 2019 /home/njust/.bashrc

2.if-then-else语句

  • if-then语句中，不管命令是否成功执行，都只有一种选择。如果if后面的命令返回一个非零退出状态码，bash shell就会继续执行脚本中的下一条命令。if-then-else语句就是解决返回非零退出状态码的情况。语法格式：

    1
    2
    3
    4
    5
    6
    if 命令
    then 
        命令
    else
        命令
    fi

  • 执行流程：

    • 当if语句中的命令返回状态码为0时，then部分的命令会被执行；
    • 当if语句中的命令返回状态码非0时，else部分的命令会被执行；
  • 实例如下： 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #!/bin/bash

    testuser=njuster

    if grep $testuser /etc/passwd
    then
    echo This is my first command
    echo This is my second command
    echo I can even put in other commands besides echo:
    ls -l /home/$testuser/.b*
    else
    echo The user $testuser does not exist on this system.
    echo
    fi
    # 结果
    [njust@njust tutorials]$ ./harden.sh 
    The user njuster does not exist on this system.

3.嵌套if-then

  • 可以使用elif代替多个if-then语句。具体范例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/bin/bash

    testuser=njuster

    if grep $testuser /etc/passwd
    then
    echo The user $testuser exists on this system.
    elif ls -d /home/$testuser
    then
    echo The user $testuser does not exist on this system.
    echo However, $testuser has a directory.
    else
    echo The user $testuser does not exist on this system.
    echo And,$testuser does not have a directory.
    fi

    # 结果
    [njust@njust tutorials]$ ./harden.sh 
    ls: 无法访问/home/njuster: 没有那个文件或目录
    The user njuster does not exist on this system.
    And,njuster does not have a directory.

  • 可以继续将多个elif命令串起来，形成一个大的if-then-elif嵌套组合。具体形式如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    if 命令
    then
    命令
    elif 命令
    then
    命令
    elif 命令
    then 
    命令
    ......
    fi

  • 尽管elif语句的代码看起来很清晰，但脚本的逻辑不好。后面会使用case命令代替if-then语句的大量嵌套。

4.test命令

  • 目前为止，if语句中看到的都是普通的shell命令。由于if-then语句不能测试命令退出状态码之外的条件。因此，bash shell中有个工具可以帮你通过if-then语句测试其他条件。

  • test命令提供了在if-then语句中测试不同条件的路径。如果test命令中列出的条件成立，test命令就会退出并返回退出状态码；如果条件不成立，test命令就会退出并返回非零的退出状态码。于是，if-then语句就不会被执行。语法格式如下：

    1
    test 测试条件

  • 测试条件是test命令要测试的一系列参数和值。当用在if-then语句中是，形式如下所示：

    1
    2
    3
    4
    if test 测试条件
    then
    命令
    fi

  • 如果不写test语句中的测试条件，它会以非零的退出状态码退出，并执行else语句块，实例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #!/bin/bash

    # Testing the test command

    if test
    then
    echo No expression returns a ture
    else
    echo No expression returns a false
    fi

    # 结果
    [njust@njust tutorials]$ ./james.sh 
    No expression returns a false

  • 当加入一个条件时，test命令会测试该条件。例如，可以使用test命令确定变量中是否有内容，如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #!/bin/bash

    my_variable="Curry"

    if test $my_variable
    then
    echo The $my_variable expression returns a true.
    else 
    echo The $my_variable expression returns a false.
    fi

    # 结果
    [njust@njust tutorials]$ ./tlu.sh 
    The Curry expression returns a true.

  • bash shell 提供了另一种条件测试方法。无需在if-then语句中声明test命令。语法格式如下：

    1
    2
    3
    4
    if [ 测试条件 ]
    then
    命令
    fi

  • 方括号定义了测试条件。注意：测试条件的左右两侧都要留一个空格，否则会出错。test命令可以判断三类条件：

    • 数值比较
    • 字符串比较
    • 文件比较
4.1 数值比较

  • test命令最常见于对两个数值进行比较。测试两个值时可以使用的条件参数如下所示：

    1
    2
    3
    4
    5
    6
    7
    比较                            描述
    num1 -eq num2                   等于
    num1 -ge num2                   大于或等于
    num1 -gt num2                   大于
    num1 -le num2                   小于或等于
    num1 -lt num2                   小于
    num1 -ne num2                   不等于

  • 数值比较测试案例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    #!/bin/bash

    # using numeric test evaluations

    value1=10
    value2=20

    if [ $value1 -gt 5 ]
    then
    echo The test value $value1 is greater than 5.
    fi


    if [ $value1 -eq $value2 ]
    then
    echo The values are equal.
    else
    echo The values are different.
    fi


    # 结果
    [njust@njust tutorials]$ ./num.sh 
    The test value 10 is greater than 5.
    The values are different.

  • 但是，涉及浮动值时，数值条件测试会有一个限制。原因：bash shell只能处理整数，如果你只是要通过echo语句来显示这个结果，那没问题。实例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #!/bin/bash

    value=3.1415926

    echo The test value is $value.

    if [ $value1 -gt 5 ]
    then
    echo The test value $value is greater than 5.
    fi

    # 结果
    [njust@njust tutorials]$ ./num2.sh 
    The test value is 3.1415926.
    ./num2.sh: 第 7 行:[: -gt: 期待一元表达式
4.2 字符串比较

  • 条件测试还允许比较字符串的值。测试两个字符串之间的比较语法如下：

    1
    2
    3
    4
    5
    6
    7
    比较                             描述
    str1 = str2                    检查两者是否相同
    str1 != str2                   检查两者是否不同
    str1 < str2                    检查str1是否小于str2
    str1 > str2                    检查str1是否大于str2
    -n str1                        检查str1的长度是否非0
    -z str1                        检查str1的长度是否为0

  • 比较字符串的相等性时，比较测试会将所有的标点和大小写情况都考虑在内。字符串的相等性案例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/bin/bash

    testuser=njust

    if [ $USER = $testuser ]
    then
    echo welcome $testuser
    fi

    # 结果
    [njust@njust tutorials]$ ./str1.sh 
    welcome njust

  • 字符串的不等条件判断案例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #!/bin/bash

    testuser=baduser

    if [ $USER != $testuser ]
    then
    echo This is not $testuser
    else
    echo welcome $testuser
    fi

    # 结果
    [njust@njust tutorials]$ ./str1.sh 
    This is not baduser

  • 字符串顺序：要测试一个字符串是否比另一个字符串大或小时，经常要考虑下面两个问题：

    • 大于号或小于号必须转义，否则shell会把它们当作重定向符号，把字符串值当作文件名；
    • 大于和小于顺序和sort命令所采用的不同；

  • 字符串比较是常出现的错误案例及解决方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    #!/bin/bash

    value1=baseball
    value2=football

    if [ $value1 > $value2 ]
    then
    echo $value1 is greater than $value2.
    else
    echo $value1 is less than $value2.
    fi

    # 结果
    [njust@njust tutorials]$ ./str2.sh 
    baseball is greater than football.

    # 解决方法：对大于号进行转义
    #!/bin/bash

    value1=baseball
    value2=football

    if [ $value1 \>  $value2 ]
    then
    echo $value1 is greater than $value2.
    else
    echo $value1 is less than $value2.
    fi

    # 结果
    [njust@njust tutorials]$ ./str2.sh 
    baseball is less than football.

  • 原因分析：脚本中的大于号被解释成了输出重定向，因此创建了一个名为football的文件。由于重定向的顺利执行，test命令返回了退出状态码0，if语句误以为所有命令都已经执行完成了。

    1
    2
    [njust@njust tutorials]$ ls -l football 
    -rw-rw-r--. 1 njust njust 0 3月  17 14:33 football

  • 第二个问题一般出现在经常处理大小写的场合。sort命令处理大写字母的方法刚好和test命令相反。具体原因：比较测试中使用的是标准的ASCII顺序，根据每个字符的ASCII数值来决定排序结果。sort命令使用的是系统的本地化语言设置中定义的排序顺序。具体案例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    #!/bin/bash

    value1=Curry
    value2=curry

    if [ $value1 \>  $value2 ]
    then
    echo $value1 is greater than $value2.
    else
    echo $value1 is less than $value2.
    fi

    # 结果
    [njust@njust tutorials]$ ./str2.sh 
    Curry is less than curry.


    ########  sort命令  #########
    [njust@njust tutorials]$ cat testfile 
    Curry
    curry

    # 结果
    [njust@njust tutorials]$ sort testfile 
    curry
    Curry

  • 字符串大小：-n和-z可以检查一个变量中是否为空。具体案例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    #!/bin/bash

    val1=testing
    val2=""


    if [ -n $val1 ]
    then
    echo "The string '$val1' is not empty."
    else
    echo "The string '$val1' is empty."
    fi


    if [ -z $val2 ]
    then
    echo "The string '$val2' is empty."
    else 
    echo "The string '$val2' is not empty."
    fi


    if [ -z $val3 ]
    then 
    echo "The string '$val3' is empty."
    else
    echo "The string '$val3' is not empty."
    fi

    # 结果
    [njust@njust tutorials]$ ./str3.sh 
    The string 'testing' is not empty.
    The string '' is empty.
    The string '' is empty.
4.3 文件比较

  • 文件比较可能是shell编程中最强大、用的最多的比较形式。它允许你测试Linux文件系统上文件和目录的状态。文件比较功能语法如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    比较                               描述
    -d  file                       检查file是否存在并是一个目录
    -e  file                       检查file是否存在
    -f  file                       检查file是否存在并是一个文件
    -r  file                       检查file是否存在并可读
    -s  file                       检查file是否存在并非空
    -w  file                       检查file是否存在并可写
    -x  file                       检查file是否存在并可执行
    -O  file                       检查file是否存在并属于当前用户所有
    -G  file                       检查file是否存在并且默认组与当前组相同
    file1  -nt file2               检查file1是否比file2新
    file1  -ot file2               检查file1是否比file2旧

  • 检查目录：-d测试会检查指定的目录是否存在于系统中。一般用于将文件写入目录或准备切换到某个目录中。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #!/bin/bash

    dst_dir=/home/curry

    if [ -d $dst_dir ]
    then
    echo "The $dst_dir directory exists"
    cd $dst_dir
    ls
    else
    echo "The $dst_dir directory does not exists"
    fi


    # 结果
    [njust@njust tutorials]$ ./file1.sh 
    The /home/curry directory does not exists

  • 检查对象是否存在：-e允许你的脚本代码在使用文件或目录前先检查它们是否存在。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    #!/bin/bash

    location=$HOME

    file_name="sentinel"
    mid_path="tutorials"

    if [ -e $location ]
    then
    echo "OK on the $location directory."
    echo "Now checking on the file, $file_name."
    if [ -e $location/$mid_path/$file_name ]
    then
        echo "OK on the filename"
        echo "Updating Current Date..."
        date >> $location/$mid_path/$file_name
    else
        echo "File does not exist"
        echo "Nothing to update"
    fi

    else 
    echo "The $location directory does not exist."
    echo "Nothing to update"
    fi

    # 结果
    [njust@njust tutorials]$ ./file2.sh 
    OK on the /home/njust directory.
    Now checking on the file, sentinel.
    File does not exist
    Nothing to update

    [njust@njust tutorials]$ ./file2.sh 
    OK on the /home/njust directory.
    Now checking on the file, sentinel.
    OK on the filename
    Updating Current Date...

  • 检查文件：-e可用于文件和目录。要确定指定对象为文件，必须用-f。实例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    #!/bin/bash

    item_name=$HOME

    echo 
    echo "The item being checked: $item_name"
    echo

    if [ -e $item_name ]
    then
    echo "The item, $item_name, does exist."
    echo "But is it a file?"
    echo

    if [ -f $item_name ]
    then
        echo "Yes, $item_name is a file."
    else
        echo "No, $item_name is not a file."
    fi
    else
    echo "The item, $item_name, does not exist."
    echo "Nothing to update"
    fi

    # 结果
    [njust@njust tutorials]$ ./file3.sh 

    The item being checked: /home/njust

    The item, /home/njust, does exist.
    But is it a file?

    No, /home/njust is not a file.

  • 对上述程序进行小修改，可以观察出结果的不同：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    #!/bin/bash

    item_name=$HOME/tutorials/sentinel   # 注意此句！！！

    echo 
    echo "The item being checked: $item_name"
    echo

    if [ -e $item_name ]
    then
    echo "The item, $item_name, does exist."
    echo "But is it a file?"
    echo

    if [ -f $item_name ]
    then
        echo "Yes, $item_name is a file."
    else
        echo "No, $item_name is not a file."
    fi
    else
    echo "The item, $item_name, does not exist."
    echo "Nothing to update"
    fi

    # 结果
    [njust@njust tutorials]$ ./file3.sh 

    The item being checked: /home/njust/tutorials/sentinel

    The item, /home/njust/tutorials/sentinel, does exist.
    But is it a file?

    Yes, /home/njust/tutorials/sentinel is a file.

  • 检查是否可读：在尝试从文件中读取数据之前，最好先测试一下文件是否可读。可以使用-r比较测试。实例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #!/bin/bash


    pwfile=/etc/shadow

    if [ -f $pwfile ]
    then
    if [ -r $pwfile ]
    then
        tail $pwfile
    else
        echo "Sorry,I am unable to read the $pwfile file."
    fi
    else
    "Sorry, the file $pwfile does not exist"
    fi

    # 结果
    njust@njust tutorials]$ ./file4.sh 
    Sorry,I am unable to read the /etc/shadow file.

  • 检查空文件：用-s比较来检查文件是否为空，尤其是在不想删除非空文件的时候。注意：当-s比较成功时，说明文件中有数据。实例如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    #!/bin/bash

    file_name=$HOME/tutorials/sentinel

    if [ -f $file_name ]
    then
    if [ -s $file_name ]
    then
        echo "The $file_name file exists and has data in it."
        echo "Will not remove this file."
    else
        echo "The $file_name file exists, but is empty."
        echo "Deleting empty file."
        rm $file_name
    fi

    else 
    echo "File,$file_name, does not exist."
    fi

    # 结果
    [njust@njust tutorials]$ ./file5.sh 
    The /home/njust/tutorials/sentinel file exists and has data in it.
    Will not remove this file.

  • 检查文件是否可写：-w比较会判断你对文件是否有写的权限。具体实例如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    #!/bin/bash

    item_name=$HOME/tutorials/sentinel

    echo 
    echo "The item being checked: $item_name."
    echo

    if [ -e $item_name ]
    then
    echo "The item, $item_name, does exist."
    echo "But is it a file?"
    echo
    if [ -f $item_name ]
    then 
        echo "Yes, $item_name is a file."
        echo "But is it writable?"
        if [ -w $item_name ]
        then
        echo "Writing current time to $item_name."
        date +%H%M >> $item_name
        else
        echo "Unable to write to $item_name."
        fi
    else
        echo "No, $item_name is not a file."
    fi
    else
    echo "The item,$item_name, does not exist."
    echo "Nothing to update."
    fi

    # 结果
    [njust@njust tutorials]$ ./file6.sh 

    The item being checked: /home/njust/tutorials/sentinel.

    The item, /home/njust/tutorials/sentinel, does exist.
    But is it a file?

    Yes, /home/njust/tutorials/sentinel is a file.
    But is it writable?
    Writing current time to /home/njust/tutorials/sentinel.

  • 检查文件是否可执行：-x比较是判断特定文件是否有执行权限的一个简单方法。如果你需要在shell脚本中运行大量脚本，它就能发挥作用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #!/bin/bash

    if [ -x file5.sh ]
    then
    echo "You can run the script: "
    ./file5.sh
    else
    echo "Sorry, you are unable to execute the script"
    fi

    # 结果
    [njust@njust tutorials]$ ./file7.sh 
    You can run the script: 
    The /home/njust/tutorials/sentinel file exists and has data in it.
    Will not remove this file.

  • 检查所属关系：-O可以测试你是否是文件的拥有者。实例如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/bin/bash

    if [ -O /etc/passwd ]
    then
    echo "You are the owner of the /etc/passwd file."
    else
    echo "Sorry,you are not the owner of the /etc/passwd file."
    fi

    # 结果
    [njust@njust tutorials]$ ./file8.sh 
    Sorry,you are not the owner of the /etc/passwd file.

  • 检查默认属组关系：-G比较会检查文件的默认组。如果它匹配了用户的默认组，则测试成功。-G比较只会检查默认组而非用户所属的所有组。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/bin/bash

    if [ -G $HOME/tutorials/sentinel ]
    then
    echo "You are in the same group as the file."
    else
    echo "The file is not owned by your group."
    fi

    # 结果
    [njust@njust tutorials]$ ./file9.sh 
    You are in the same group as the file.

  • 检查文件日期：主要用于对两个文件的创建日期进行比较。通常用于编写软件安装脚本时非常有用。-nt比较会判定一个文件是否比另一个文件新；如果文件较新，则它的文件创建日期更近。-ot比较会判断一个文件是否比另一文件旧。如果文件较旧，意味着它的创建日期更早。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #!/bin/bash

    if [ file9.sh -nt file1.sh ]
    then
    echo "The file9 file is newer than file1."
    else
    echo "The file1 file is newer than file9."
    fi

    if [ file7.sh -ot file9.sh ]
    then
    echo "The file7 file is older than the file9 file."
    fi

    # 结果
    [njust@njust tutorials]$ ./file10.sh 
    The file9 file is newer than file1.
    The file7 file is older than the file9 file.

  • 注意：使用-nt或-ot比较文件之前，必须先确认文件是存在的。因为-nt或-ot都不会先检查文件是否存在！

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #!/bin/bash

    if [ file9.sh -nt file1.sh ]
    then
    echo "The file9 file is newer than file1."
    else
    echo "The file1 file is newer than file9."
    fi

    if [ file7.sh -ot file9.sh ]
    then
    echo "The file7 file is older than the file9 file."
    fi

    # 错误的结果，因为badfile1和badfile2文件根本就不存在！
    [njust@njust tutorials]$ ./error.sh 
    The badfile2 file is newer than badfile1.

5.复合条件测试

  • if-then语句允许你使用布尔逻辑进行组合测试。有两种布尔运算符可以使用：
    • [ 条件1 ] && [ 条件2 ]
    • [ 条件1 ] || [ 条件2 ]
  • 复合条件测试案例如下所示： 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/bin/bash

    if [ -d $HOME ] && [ -w $HOME/tutorials/sentinel ]
    then 
    echo "The file exists and you can write to it"
    else
    echo "I cannot write to the file"
    fi

    # 结果
    [njust@njust tutorials]$ ./file11.sh 
    The file exists and you can write to it

6.if-then的高级特性

  • bash shell提供了两种可在if-then语句中使用的高级特性：
    • 用于数学表达式的双括号；
    • 用于高级字符串处理功能的双方括号；
6.1 使用双括号

  • 双括号命令允许你在比较的过程中使用高级数学表达式。test命令只能在比较的过程中使用简单的算术操作。双括号提供了更多的数学符号，双括号命令的格式如下：

    1
    (( 表达式 ))

  • 其中，表达式可以是任意的数学赋值或比较表达式。双括号命令符号如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    符号                                  说明
    val++                                后置加加
    val--                                后置减减
    ++val                                前置加加
    --val                                前置减减
    !                                     取反
    ~                                    按位取反
    **                                    幂运算
    <<                                   左移
    >>                                   右移
    &                                    按位与
    |                                    按位或
    &&                                   逻辑与
    ||                                   逻辑或

  • 可以在if语句中使用双括号命令，也可以在脚本中的普通命令里使用来赋值。实例如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/bin/bash

    val1=10
    if (( $val1 ** 2 > 90 ))
    then
    (( val2 = $val1 ** 2 ))
    echo "The square of $val1 is $val2"
    fi

    # 结果
    [njust@njust tutorials]$ ./file12.sh
    The square of 10 is 100
6.2 使用双方括号

  • 双方括号命令提供了针对字符串比较的高级特性。双方括号的语法格式如下：

    1
    [[ 表达式 ]]

  • 注意：双方括号中的表达式使用了test命令中采用的标准字符串比较，但它额外还提供了test命令不具有的特性即模式匹配。同时，值得注意的是并不是所有的shell等支持方双括号。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/bin/bash

    if [[ $USER == n* ]]
    then
    echo "Hello $USER"
    else
    echo "Sorry, I do not know you"
    fi

    # 结果
    [njust@njust tutorials]$ ./file13.sh 
    Hello njust

7.case命令

  • 使用case命令可以有效的减少使用if-then-else语句的出现次数，简化代码结构。case命令的语法结构如下所示：

    1
    2
    3
    4
    5
    case 变量 in
    变量可能取值1 | 变量可能取值2) 命令1;;
    变量可能取值3) 命令2;;
    *) default 命令3;;
    esac

  • case命令的具体实例如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #!/bin/bash

    case $USER in
    njust | bar)
    echo "Welcome, $USER"
    echo "Please enjoy your visit";;
    testing)
    echo "Special testing account";;
    jessica)
    echo "Do not forget to log off when you're done.";;
    *)
    echo "Sorry,you are not allowed here";;
    esac

    # 结果
    [njust@njust tutorials]$ ./case.sh 
    Welcome, njust
    Please enjoy your visit

8.资料下载

本文标题:shell脚本编程之使用结构化命令

文章作者:Curry_Coder

发布时间:2020年03月18日 - 13:38:44

最后更新:2020年03月18日 - 13:39:58

原始链接:https://cdlwhm1217096231.github.io/shell脚本编程/shell脚本编程之使用结构化命令/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

-------------本文结束感谢您的阅读-------------
觉得对您有所帮助，请我喝杯可乐吧!
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多