【Linux】Vim 编辑器与 Shell 命令脚本

本章学习内容：

• 掌握使用 Vim 编辑器来编写和修改文档；

• 通过配置主机名称、系统网卡以及软件仓库等文件，加深 Vim 编辑器中诸多命令、快捷键与模式的理解；

• 掌握 Linux 命令、逻辑操作符与 Shell 脚本的灵活搭配使用；

• 能够在 Shell 脚本中以多种方式接收用户输入的信息；

• 能够对输入值进行文件、数字、字符串的判断比较；

• 熟练使用“与、或、非”三种逻辑操作符；

• 掌握 if、for、while、case 条件测试语句；

• 编写 10 多个实战脚本，达到在工作中灵活运用的水准；

• 学习使用 at 命令与 crond 计划任务服务来分别实现一次性的系统任务设置和长期性的系统任务设置，在分钟、小时、日期、月份、年份的基础上实现工作的自动化，从而让日常的工作更加高效。

Vim 文本编辑器

初识 Vim

Vim 的发布最早可以追溯到 1991 年，英文全称为 Vi Improved。它也是 Vi 编辑器的提升版本，其中最大的改进当属添加了代码着色功能，在某些编程场景下还能自动修正错误代码。

我们都知道 “在 Linux 系统中一切都是文件，而配置一个服务就是在修改其配置文件的参数。”而且在日常工作中也肯定免不了要编写文档，这些工作都是通过文本编辑器来完成的。

当我们在终端输入vim命令后回车就会进入vim编辑器内：

Vim 之所以能得到广大厂商与用户的认可，原因在于 Vim 编辑器中设置了 3 种模式— 命令模式、末行模式和编辑模式，每种模式分别又支持多种不同的命令快捷键，这大大提高了工作效率。要想高效地操作文本，就必须先搞清这 3 种模式的操作区别以及模式之间的切换方法。

Vim 编辑器模式的切换方法如下图：

在每次运行 Vim 编辑器时，默认进入命令模式，此时需要先切换到输入模式后再进行文档编写工作。而每次在编写完文档后需要先返回命令模式，然后再进入末行模式，执行文档的保存或退出操作。

在命令模式中最常用的一些命令：

命令	作用
dd	删除（剪切）光标所在整行
5dd	删除（剪切）从光标处开始的 5 行
yy	复制光标所在整行
5yy	复制从光标处开始的 5 行
n	显示搜索命令定位到的下一个字符串
N	显示搜索命令定位到的上一个字符串
u	显示搜索命令定位到的上一个字符串
p	将之前删除（dd）或复制（yy）过的数据粘贴到光标后面

末行模式主要用于保存或退出文件，以及设置 Vim 编辑器的工作环境，还可以让用户执行外部的 Linux 命令或跳转到所编写文档的特定行数。要想切换到末行模式，在命令模式中输入一个冒号就可以了。末行模式中常用的命令如表所示。

命令	作用
:w	保存
:q	退出
:q!	强制退出（放弃对文档内容的修改）
:wq!	强制保存退出
:set nu	显示行号
:setnonu	不显示行号
:命令	执行该命令
:整数	跳转到该行
:s/one/two	将当前光标所在行的第一个 one 替换成 two
:s/one/two/g	将当前光标所在行的第一个 one 替换成 two
:%s/one/two/g	将全文中的所有 one 替换成 two
?字符串	在文本中从下至上搜索该字符串
/字符串	在文本中从上至下搜索该字符串

编写简单文档

目前为止，我们已经具备了在 Linux 系统中编写文档的理论基础，接下来我们一起动手编写一个简单的脚本文档。如果忘记了某些快捷键命令的作用，可以再返回前文进行复习。

编写脚本文档的第 1 步就是给文档取个名字，这里将其命名为 practice.txt。如果存在该文档，则是打开它。如果不存在，则是创建一个临时的输入文件。

打开 practice.txt 文档后，默认进入的是 Vim 编辑器的命令模式。此时只能执行该模式下的命令，而不能随意输入文本内容。我们需要切换到输入模式才可以编写文档。 可以分别使用 a、i、o 这 3 个键从命令模式切换到输入模式。

• a 键是在光标后面一位切换到输入模式

• i 键是在光标当前位置切换到输入模式

• o 键则是在光标的下面再创建一个空行

进入输入模式后，可以随意输入文本内容，Vim 编辑器不会把您输入的文本内容当作命令而执行。

在编写完之后，要想保存并退出，必须先敲击键盘的 Esc 键从输入模式返回命令模式。然后再输入“:wq!”切换到末行模式才能完成保存退出操作。当在末行模式中输入“:wq!”命令时，就意味着强制保存并退出文档。然后便可以用 cat 命令查看保存后的文档内容了。

如果已经修改了文本内容，在我们尝试直接退出文档而不保存的时候 Vim 编辑器就会拒绝我们的操作了。此时只能强制退出才能结束本次输入操作或者保存退出。

实战演练

配置主机名称

为了便于在局域网中查找某台特定的主机，或者对主机进行区分，除了要有 IP 地址外， 还要为主机配置一个主机名，主机之间可以通过这个类似于域名的名称来相互访问。

在 Linux 系统中，主机名大多保存在/etc/hostname 文件中，接下来将/etc/hostname 配置文件的内容修改 为“imyjs.com”，步骤如下。

• 使用 Vim 编辑器修改/etc/hostname 主机名称文件。

• 把原始主机名称删除后追加“imyjs.com”。

  注意，使用 Vim 编辑器修改主机名称文件后，要在末行模式下执行“:wq!”命令才能保存并退出文档。

• 保存并退出文档，然后使用 hostname 命令检查是否修改成功。

  补充知识：hostname 命令用于查看当前的主机名称，但有时主机名称的改变不会立即同步到系统中， 所以如果发现修改完成后还显示原来的主机名称，可重启虚拟机后再行查看。

配置网卡信息

网卡 IP 地址配置的是否正确是两台服务器是否可以相互通信的前提。在 Linux 系统中， 一切都是文件，因此配置网络服务的工作其实就是在编辑网卡配置文件。

现在有一个名称为 ifcfg-ens33的网卡设备，将其配置为开机自启动，并且 IP 地址、子 网、网关等信息由人工指定，其步骤如下所示。

• 首先切换到/etc/sysconfig/network-scripts 目录中（存放着网卡的配置文件）。

• 使用 Vim 编辑器修改网卡文件 ifcfg-ens33，逐项写入下面的配置参数并保存退出。由于每台设备的硬件及架构是不一样的，因此请使用 ifconfig 命令自行确认各自网卡的默认名称。

  • TYPE=Ethernet

  • BOOTPROTO=static

  • NAME=ens33

  • ONBOOT=yes

  • IPADDR=192.168.10.10

  • NETMASK=255.255.255.0

  • GATEWAY=192.168.10.1

  • DNS1=192.168.10.1

• 执行重启网卡设备的命令，然后通过 ping 命令测试网络能否连通。

  nmcli connection reload ens33

  ping www.imyjs.cn

  由于在 Linux 系统中 ping 命令不会自动终止，因此需要手动按下 Ctrl+C 组合键来强行结束进程。

配置软件仓库

软件仓库是一种能进一步简化 RPM 管理软件的难度以及自动分析所需软件包及其依赖关系的技术。可以把 Yum 或 DNF 想象成是一个硕大的软件仓库，里面保存有 几乎所有常用的工具，而且只需要说出所需的软件包名称，系统就会自动为您搞定一切。 既然要使用软件仓库，就要先把它搭建起来，然后将其配置规则确定好才行。

Yum 与 DNF 软件仓库的配置文件是通用的，也就是说填写好配置文件信息后，这两个软件仓库的命令都是可以正常使用。建议在 RHEL 8 中使用 dnf 作为软件的安装命令，因为它具备更高的效率，而且支持多线程同时安装软件。

搭建并配置软件仓库的大致步骤如下所示。

• 进入/etc/yum.repos.d/目录中（因为该目录存放着软件仓库的配置文件）。

• 使用 Vim 编辑器创建一个名为 rhel8.repo 的新配置文件（文件名称可随意，但后缀必须为.repo），逐项写入下面的配置参数并保存退出。

  • 仓库名称：具有唯一性的标识名称，不应与其他软件仓库发生冲突。

  • 描述信息（name）:可以是一些介绍性的词，易于识别软件仓库的用处。

  • 仓库位置（baseURL）：软件包的获取方式，可以使用 FTP 或 HTTP 下载，也可以是本地的文件（需要在后面添加 file 参数）。

  • 是否启用（enabled）：设置此源是否可用；1 为可用，0 为禁用。

  • 是否校验（gpgcheck）：设置此源是否校验文件；1 为校验，0 为不校验。

  • 公钥位置（gpgkey）：若上面的参数开启了校验功能，则此处为公钥文件位置。若没有开启，则省略不写。

• 按配置参数中所填写的仓库位置挂载光盘，并把光盘挂载信息写入/etc/fstab 文件中。

• 使用“dnf install httpd -y”命令检查软件仓库是否已经可用。

开始实战！ 进入/etc/yum.repos.d 目录后创建软件仓库的配置文件：

[BaseOS]
name=BaseOS
baseurl=file:///media/cdrom/BaseOS
enabled=1
gpgcheck=0
[AppStream]
name=AppStream
baseurl=file:///media/cdrom/AppStream
enabled=1
gpgcheck=0

创建挂载点后进行挂载操作，并设置成开机自动挂载

 

[root@ansible-control yum.repos.d]# cat my.repo 
[BaseOS]
name=BaseOS
baseurl=file:///media/cdrom/BaseOS
enabled=1
gpgcheck=0
[AppStream]
name=AppStream
baseurl=file:///media/cdrom/AppStream
enabled=1
gpgcheck=0
[root@ansible-control yum.repos.d]# mkdir -p /media/cdrom
[root@ansible-control yum.repos.d]# mount /dev/cdrom  /media/cdrom/
mount: /dev/sr0 is write-protected, mounting read-only
[root@ansible-control yum.repos.d]# vim /etc/fstab
/dev/cdrom /media/cdrom iso9660 defaults 0 0

尝试使用软件仓库的 dnf 命令来安装 Web 服务，软件包名称为httpd，安装后出现“Complete! ” 则代表配置正确。

编写 Shell 脚本

可以将 Shell 终端解释器当作人与计算机硬件（我觉得应该是系统内核）之间的“翻译官”，它作为用户与 Linux 系统内部的通信媒介，除了能够支持各种变量与参数外，还提供了诸如循环、分支等高级编程语言才有的控制结构特性。要想正确使用 Shell 中的这些功能特性，准确下达命令尤为重要。 Shell 脚本命令的工作方式有下面两种。

• 用户每输入一条命令就立即执行。

   [root@ansible-control ~]# echo "hello shell"
   hello shell

• 由用户事先编写好一个完整的 Shell 脚本，Shell 会一次性执行脚本中诸多的命令。

  [root@ansible-control ~]# vim shell.sh
   #!/bin/bash
   # this is my first shell script!
   ​
   echo "hello world by shell code!"
   cd /home
   [root@ansible-control ~]# sh shell.sh
   hello world by shell code!
   [root@ansible-control ~]#

在 Shell 脚本中不仅会用到前面学习过的很多 Linux 命令以及正则表达式、管道符、数据流重定向等语法规则，还需要把内部功能模块化后通过逻辑语句进行处理，最终形成日常所见的 Shell 脚本。 通过查看 SHELL 变量可以发现，当前系统已经默认使用 Bash 作为命令行终端解释器了：

[root@ansible-control ~]# echo $SHELL
/bin/bash
[root@ansible-control ~]# echo $shell

[root@ansible-control ~]#

 

编写简单的脚本

使用 Vim 编辑器把 Linux 命令按照顺序依次写入到一个 文件中，就是一个简单的脚本了。 例如，如果想查看当前所在工作路径并列出当前目录下所有的文件及属性信息，实现这个功能的脚本应该类似于下面这样：

 #!/bin/bash
 # this is a demo!
 ​
 # 查看当前所在工作路径
 pwd
 # 列出当前目录下所有的文件及属性信息
 ls -al

 

在上面的这个 exec.sh 脚本中实际上出现了 3 种不同的元素：

• 第一行的脚本声明（#!） 用来告诉系统使用哪种 Shell 解释器来执行该脚本；

• 第二、四、六行的注释信息（#）是对脚本功能和某些命令的介绍信息，使得自己或他人在日后看到这个脚本内容时，可以快速知道该脚本的 作用或一些警告信息；

• 第五、七行的可执行语句也就是我们平时执行的 Linux 命令了。

我们来执行一下看看结果：

[root@ansible-control ~]# vim exec.sh
 [root@ansible-control ~]# sh exec.sh
 /root
 total 60
 dr-xr-x---.  5 root root 4096 Jul 23 10:00 .
 dr-xr-xr-x. 17 root root  224 Jul 15 17:27 ..
 -rw-------.  1 root root 1243 Jul 15 17:28 anaconda-ks.cfg
 drwx------.  4 root root   27 Jul 16 02:39 .ansible
 -rw-------.  1 root root   58 Jul 16 03:18 .ansible-console_history
 -rw-------.  1 root root 3933 Jul 23 09:47 .bash_history
 -rw-r--r--.  1 root root   18 Dec 29  2013 .bash_logout
 -rw-r--r--.  1 root root  176 Dec 29  2013 .bash_profile
 -rw-r--r--.  1 root root  193 Jul 23 09:47 .bashrc
 -rw-r--r--.  1 root root  100 Dec 29  2013 .cshrc
 -rw-r--r--.  1 root root  129 Jul 23 10:00 exec.sh
 drwxr-----.  3 root root   19 Jul 15 23:52 .pki
 -rw-r--r--.  1 root root   89 Jul 22 20:38 shell.sh
 drwx------.  2 root root   57 Jul 16 02:54 .ssh
 -rw-r--r--.  1 root root  157 Jul 16 02:54 ssh-pass.sh
 -rw-r--r--.  1 root root  129 Dec 29  2013 .tcshrc
 -rw-r--r--.  1 root root    6 Jul 22 23:00 test.txt
 -rw-------.  1 root root 4811 Jul 23 10:00 .viminfo
 [root@ansible-control ~]#

 

如果您想在shell脚本中使用别名，可以使用以下方法之一：

1. 直接使用完整的命令：而不是使用别名，直接使用命令的完整路径或者完整命令。

2. 在脚本中定义函数：在脚本中定义一个函数，将函数名设为别名，然后在函数中执行相应的命令。例如：

 ll() {
     ls -l
 }
 ​
 # 调用别名
 ll

这样，在脚本中调用ll()函数时，实际上会执行ls -l命令。

3. 在脚本中使用别名：在脚本中使用别名的方法是在脚本中加载用户的配置文件，例如.bashrc。可以在脚本中添加以下代码：

 source ~/.bashrc
 ​
 # 调用别名
 ll

这样，在脚本中调用ll时，就会执行.bashrc中定义的别名所对应的命令。

请注意，第二种和第三种方法都依赖于用户的配置文件，如果用户的配置文件中没有定义相应的别名，那么这些方法也无法使用别名。

除了上面用 Bash 解释器命令直接运行 Shell 脚本文件外，第二种运行脚本程序的方法是 通过输入完整路径的方式来执行。但默认会因为权限不足而提示报错信息，此时只需要为脚本文件增加执行权限即可。

 [root@ansible-control ~]# chmod o+rx /root
 [root@ansible-control ~]# su - guest
 Last login: Sun Jul 23 10:10:45 CST 2023 on pts/0
 [guest@ansible-control ~]$ . /root/exec.sh
 /home/guest
 total 12
 drwx------. 2 guest guest  62 Jul 23 10:07 .
 drwxr-xr-x. 3 root root   19 Jul 23 10:07 ..
 -rw-r--r--. 1 guest guest  18 Nov 25  2021 .bash_logout
 -rw-r--r--. 1 guest guest 193 Nov 25  2021 .bash_profile
 -rw-r--r--. 1 guest guest 231 Nov 25  2021 .bashrc
 [guest@ansible-control ~]$

 

 

接收用户的参数

但是，像上面这样的脚本程序只能执行一些预先定义好的功能，未免太过死板。为了让 Shell 脚本程序更好地满足用户的一些实时需求，以便灵活完成工作，必须要让脚本程序能够 像之前执行命令时那样，接收用户输入的参数。 比如，当用户执行某一个命令时，加或不加参数的输出结果是不同的：

[root@ansible-control ~]# wc -l exec.sh
 7 exec.sh
 [root@ansible-control ~]# wc -c exec.sh
 129 exec.sh
 [root@ansible-control ~]# wc -w exec.sh
 13 exec.sh
 [root@ansible-control ~]#

 

 

这意味着命令不仅要能接收用户输入的内容，还要有能力进行判断区别，根据不同的输 入调用不同的功能。 其实，Linux 系统中的 Shell 脚本语言早就考虑到了这些，已经内设了用于接收参数的变量，变量之间使用空格间隔。

理论过后再来练习一下。尝试编写一个脚本程序示例，通过引用上面的变量参数来看一 下真实效果：

 [root@ansible-control ~]# vim exec2.sh
 #!/bin/bash
 # this is demo!
 echo "当前脚本名称为$0"
 echo "总共有$#个参数，分别是$*。"
 echo "第 1 个参数为$1，第 5 个为$5。"
 [root@ansible-control ~]# sh exec2.sh a b c d f e g
 当前脚本名称为exec2.sh
 总共有7个参数，分别是a b c d f e g。
 第 1 个参数为a，第 5 个为f。
 [root@ansible-control ~]#

 

 

判断用户的参数

学习是一个登堂入室、由浅入深的过程。在学习完 Linux 命令，掌握 Shell 脚本语法变量和接收用户输入的信息之后，就要踏上新的高度—能够进一步处理接收到的用户参数。

系统在执行 mkdir 命令时会判断用户输入的信息，即判断用户指定的文件夹名称是否已经存在，如果存在则提示报错；反之则自动创建。Shell 脚本中的条件测试语法可以判断表达式是否成立，若条件成立则返回数字 0，否则便返回非零值。条件测试语法的执行格式如图所示。切记，条件表达式两边均应有一个空格。

按照测试对象来划分，条件测试语句可以分为 4 种：

• 文件测试语句；

• 逻辑测试语句；

• 整数值比较语句；

• 字符串比较语句。

文件测试即使用指定条件来判断文件是否存在或权限是否满足等情况的运算符，具体的参数如表所示。

参数	作用
-d	测试文件是否为目录类型
-e	测试文件是否存在
-f	判断是否为一般文件
-r	测试当前用户是否有权限读取
-w	测试当前用户是否有权限写入
-x	测试当前用户是否有权限执行

下面使用文件测试语句来判断/etc/fstab 是否为一个目录类型的文件，然后通过 Shell 解释器的内设$?变量显示上一条命令执行后的返回值。如果返回值为 0，则目录存在；如果返回值为非零的值，则意味着它不是目录，或这个目录不存在：

 [root@ansible-control ~]# [ /etc/fstab -d ]
 -bash: [: /etc/fstab: unary operator expected
 [root@ansible-control ~]# [ -d /etc/fstab ]
 [root@ansible-control ~]# $?
 -bash: 1: command not found
 [root@ansible-control ~]# echo $?
 127
 [root@ansible-control ~]# [ -d /etc/fstab ]
 [root@ansible-control ~]# echo $?
 1
 [root@ansible-control ~]#

 

 

再使用文件测试语句来判断/etc/fstab 是否为一般文件，如果返回值为 0，则代表文件存在，且为一般文件：

[root@ansible-control ~]# [ -f /etc/fstab ]
[root@ansible-control ~]# echo $?
 0
[root@ansible-control ~]#

判断与查询一定要敲两次命令吗？其实可以一次搞定。 逻辑语句用于对测试结果进行逻辑分析，根据测试结果可实现不同的效果。例如在 Shell 终端中逻辑“与”的运算符号是&&，它表示当前面的命令执行成功后才会执行它后面的命令， 因此可以用来判断/dev/cdrom 文件是否存在，若存在则输出 Exist 字样。

 

 [root@ansible-control ~]# [ -f /dev/cdrom ] && echo "Exist"
 [root@ansible-control ~]# [ -e /dev/cdrom ] && echo "Exist"
 Exist
 [root@ansible-control ~]#

除了逻辑“与”外，还有逻辑“或”，它在 Linux 系统中的运算符号为||，表示当前面的命令执行失败后才会执行它后面的命令，因此可以用来结合系统环境变量 USER 来判断当前登录的用户是否为非管理员身份：

 [root@ansible-control ~]# echo $USER
 root
 [root@ansible-control ~]# [ $USER = root] || echo "user"
 -bash: [: missing `]'
 user
 [root@ansible-control ~]# [ $USER = root ] || echo "user"
 [root@ansible-control ~]# su - guest
 Last login: Sun Jul 23 10:16:22 CST 2023 on pts/0
 [guest@ansible-control ~]$ [ $USER = root ] || echo "user"
 user
 [guest@ansible-control ~]$

第三种逻辑语句是“非”，在 Linux 系统中的运算符号是一个叹号（！），它表示把条件测 试中的判断结果取相反值。也就是说，如果原本测试的结果是正确的，则将其变成错误的； 原本测试错误的结果，则将其变成正确的。 我们现在切换回到 root 管理员身份，再判断当前用户是否为一个非管理员的用户。由于 判断结果因为两次否定而变成正确，因此会正常地输出预设信息：

 [root@ansible-control ~]# [ ! $USER = root ] || echo "administrator"
 administrator
 [root@ansible-control ~]#

叹号应该放到判断语句的前面，代表对整个的测试语句进行取反值操作，而不应该写成 “$USER != root”，因为“!=”代表的是不等于符号（≠），尽管执行效果一样，但缺少了逻辑 关系，这一点还请多加注意。

当前我们正在登录的即为管理员用户—root。下面这个示例的执行顺序是，先判断当前登录用户的 USER 变量名称是否等于 root，然后用逻辑“非”运算符进行取反操作，效果就变成了判断当前登录的用户是否为非管理员用户。最后若条件成立，则会根据逻辑“与”运 算符输出 user 字样；若条件不满足，则会通过逻辑“或”运算符输出 root 字样，而只有在前面的&&不成立时才会执行后面的||符号。

 [root@ansible-control ~]# [ ! $USER = root ] && echo "user" || echo "root"
 root
 [root@ansible-control ~]

整数比较运算符仅是对数字的操作，不能将数字与字符串、文件等内容一起操作，而且不能想当然地使用日常生活中的等号、大于号、小于号等来判断。因为等号与赋值命令符冲突，大于号和小于号分别与输出重定向命令符和输入重定向命令符冲突。因此一定要使用规范的整数比较运算符来进行操作。可用的整数比较运算符如表所示。

运算符	作用
-eq	是否等于
-ne	是否不等于
-gt	是否大于
-lt	是否小于
-le	是否等于或小于
-ge	是否大于或等于

接下来小试牛刀。先测试一下 10 是否大于 10 以及 10 是否等于 10（通过输出的返回值内容来判断）：

 [root@ansible-control ~]# [ 10 -gt 10 ] 
 [root@ansible-control ~]# echo $?
 1
 [root@ansible-control ~]# [ 10 -eq 10 ] 
 [root@ansible-control ~]# echo $?
 0
 [root@ansible-control ~]#

free 命令，它能够用来获取当前系统正在使用及可用的内存量信息。 接下来先使用 free -m 命令查看内存使用量情况（单位为 MB），然后通过“grep Mem:”命令过滤出剩余内存量的行，再用 awk '{print $4}'命令只保留第 4 列。

 [root@ansible-control ~]# free -m | grep Mem: | awk {'print $4'}
 1485
 [root@ansible-control ~]# 

如果想把这个命令写入到 Shell 脚本中，那么建议把输出结果赋值给一个变量，以方便其他命令进行调用：

 [root@ansible-control ~]# FreeMem=free -m | grep Mem: | awk {'print $4'}
 -bash: -m: command not found
 [root@ansible-control ~]# FreeMem=`free -m | grep Mem: | awk {'print $4'}`
 [root@ansible-control ~]# echo $FreeMem
 1485
 [root@ansible-control ~]# 

接下来才是重点，我们使用整数运算符来判断内存可用量的值是否小于 1024，若小于则会提示“Insufficient Memory”（内存不足）的字样：

 [root@ansible-control ~]# [ $FreeMem -lt 1024 ] && echo "Insufficient Memory"
 [root@ansible-control ~]# [ $FreeMem -lt 1500 ] && echo "Insufficient Memory"
 Insufficient Memory
 [root@ansible-control ~]# 

字符串比较语句用于判断测试字符串是否为空值，或两个字符串是否相同。它经常用来判断某个变量是否未被定义（即内容为空值），理解起来也比较简单。字符串比较中常见的运 算符如表所示。

运算符	作用
=	比较字符串内容是否相同
!=	比较字符串内容是否不同
-z	判断字符串内容是否为空
-n	判断字符串内容是否不为空

接下来通过判断 String 变量是否为空值，进而判断是否定义了这个变量：

 [root@ansible-control ~]# [ -z $String ]
 [root@ansible-control ~]# echo $?
 0

再次尝试引入逻辑运算符来试一下。当用于保存当前语系的环境变量值 LANG 不是英语 （en.US）时，则会满足逻辑测试条件并输出“Not en.US”（非英语）的字样：

 [root@ansible-control ~]# echo $LANG
 en_US.UTF-8
 [root@ansible-control ~]# [ ! $LANG = "en.US" ] && echo "Not en.US"
 Not en.US
 [root@ansible-control ~]# 

流程控制语句

尽管此时可以通过使用 Linux 命令、管道符、重定向以及条件测试语句来编写最基本的 Shell 脚本，但是这种脚本并不适用于生产环境。原因是它不能根据真实的工作需求来调整具体的执行命令，也不能根据某些条件实现自动循环执行。通俗来讲，就是不能根据实际情况做出调整。 通常脚本都是从上到下一股脑儿地执行，效率是很高，但一旦某条命令执行失败了，则后面的功能全都会受到影响。

接下来我们通过 if、for、while、case 这 4 种流程控制语句来学习编写难度更大、功能更强 的 Shell 脚本。

if 条件测试语句

if 条件测试语句可以让脚本根据实际情况自动执行相应的命令。从技术角度来讲，if 语句分为单分支结构、双分支结构、多分支结构；其复杂度随着灵活度一起逐级上升。 if 条件语句的单分支结构由 if、then、fi 关键词组成，而且只在条件成立后才执行预设的 命令，相当于口语的“如果……那么……”。单分支的 if 语句属于最简单的一种条件判断结构，语法格式如图所示。

下面使用单分支的 if 条件语句来判断/media/cdrom 目录是否存在，若不存在就创建这个目录，反之则结束条件判断和整个 Shell 脚本的执行。

 #!/bin/bash
 ​
 # 注意：定义变量等号两边不得有空格
 DIR="/media/cdrom"
 if [ ! -d $DIR ]
 # 注意：then关键字不得写在上一行
 then
     mkdir -p $DIR
 fi

 在正常情况下，顺利执行完脚本文件后没有任何输出信息，但是可以使用 ls 命令验证 /media/cdrom 目录是否已经成功创建：

 [root@ansible-control shells]# sh mkcdrom.sh
 [root@ansible-control shells]# ls /media/cdrom/
 [root@ansible-control shells]#

 if 条件语句的双分支结构由 if、then、else、fi 关键词组成，它进行一次条件匹配判断， 如果与条件匹配，则去执行相应的预设命令；反之则去执行不匹配时的预设命令，相当于口 语的“如果……那么……或者……那么……”。if 条件语句的双分支结构也是一种很简单的判断结构，语法格式如图所示。

非零的数字（可能为 1，也可能为 2，取决于系统版本）。因此可以使用整数比较运算符来判断$?变量是否为 0，从而获知那条语句的 最终判断情况。这里的服务器 IP 地址为 192.168.10.10，我们来验证一下脚本的效果：

 root@ansible-control shells]# vim checkhost.sh
 [root@ansible-control shells]# sh checkhost.sh 192.168.10.10
 Host 192.168.10.10 is Off-line.
 [root@ansible-control shells]# sh checkhost.sh www.imyjs.cn
 Host www.imyjs.cn is On-line.
 [root@ansible-control shells]#

if 条件语句的多分支结构由 if、then、else、elif、fi 关键词组成，它进行多次条件匹配判断，这多次判断中的任何一项在匹配成功后都会执行相应的预设命令，相当于口语的“如果……那么……如果……那么……”。if 条件语句的多分支结构是工作中最常使用的一种条件判断结构，尽管相对复杂但是更加灵活，语法格式如图所示。

下面使用多分支的 if 条件语句来判断用户输入的分数在哪个成绩区间内，然后输出如 Excellent、Pass、Fail 等提示信息。在 Linux 系统中，read 是用来读取用户输入信息的命令， 能够把接收到的用户输入信息赋值给后面的指定变量，-p 参数用于向用户显示一些提示信息。

在下面的脚本示例中，只有当用户输入的分数大于等于 85 分且小于等于 100 分时，才输 出 Excellent 字样；若分数不满足该条件（即匹配不成功），则继续判断分数是否大于等于 70 分且小于等于 84 分，如果是，则输出 Pass 字样；若两次都落空（即两次的匹配操作都失败 了），则输出 Fail 字样：

 #!/bin/bash
 read -p "请输入你的成绩（0-100：）" GRADE
 if [ $GRADE -ge 85 ] && [ $GRADE -le 100 ]; then
      echo "$GRADE 是优秀"
 elif [ $GRADE -ge 70 ] && [ $GRADE -le 84 ]; then
      echo "$GRADE 是通过"
 else
      echo "$GRADE 未通过"
 fi

下面执行该脚本。当用户输入的分数分别为 30 和 80 时，其结果如下：

 [root@ansible-control shells]# vim checkscore.sh
 [root@ansible-control shells]# sh checkscore.sh
 请输入你的成绩（0-100：）20
 20 未通过
 [root@ansible-control shells]# sh checkscore.sh
 请输入你的成绩（0-100：）80
 80 是通过
 [root@ansible-control shells]# sh checkscore.sh
 请输入你的成绩（0-100：）200
 200 未通过
 [root@ansible-control shells]#

为什么输入的分数为 200 时，依然显示 Fail 呢？原因很简单—没有成功匹配脚本中的两个条件判断语句，因此自动执行了最终的兜底策略。应该使得用户在输入大于 100 或小于 0 的分数时，给予 Error 报错字样的提示。

 #!/bin/bash
 read -p "请输入你的成绩（0-100：）" GRADE
 if [ $GRADE -lt 0 ] || [ $GRADE -gt 100 ]
 then
     echo "输入成绩有误"
     exit 0
 fi
 ​
 if [ $GRADE -ge 85 ] && [ $GRADE -le 100 ]; then
      echo "$GRADE 是优秀"
 elif [ $GRADE -ge 70 ] && [ $GRADE -le 84 ]; then
      echo "$GRADE 是通过"
 else
      echo "$GRADE 未通过"
 fi

for 循环语句

for 循环语句允许脚本一次性读取多个信息，然后逐一对信息进行操作处理。当要处理的数据有范围时，使用 for 循环语句就再适合不过了。for 循环语句的语法格式如图所示。

下面使用 for 循环语句从列表文件中读取多个用户名，然后为其逐一创建用户账户并设置密码。首先创建用户名称的列表文件 users.txt，每个用户名称单独一行。读者可以自行决定具体的用户名称和个数

[root@ansible-control shells]# vim users.txt
 [root@ansible-control shells]# cat users.txt
 apple
 orange
 banana
 [root@ansible-control shells]#

接下来编写 Shell 脚本 addusers.sh。在脚本中使用 read 命令读取用户输入的密码值，然后赋值给 PASSWD 变量，并通过-p 参数向用户显示一段提示信息，告诉用户正在输入的内容即将作为账户密码。在执行该脚本后，会自动使用从列表文件 users.txt 中获取到所有的用户名称，然后逐一使用“id 用户名”命令查看用户的信息，并使用$?判断这条命令是否执行成功，也就是判断该用户是否已经存在。

 #!/bin/bash
 read -p "请输入用户密码：" PASSWD
 for UNAME in `cat users.txt`
 do
    id $UNAME &> /dev/null
     if [ $? -eq 0 ]
     then
         echo "$UNAME, Already exists"
     else
        useradd $UANME &> /dev/null
         echo "$PASSWD" | passwd --stdin $UNAME &> /dev/null
         echo "$UNAME, Create success"
     fi
 done

执行批量创建用户的 Shell 脚本 addusers.sh，在输入为账户设定的密码后将由脚本自动检查并创建这些账户。由于已经将多余的信息通过输出重定向符转移到了/dev/null 黑洞文件中，因此在正常情况下屏幕窗口除了“用户账户创建成功”（Create success）的提示后不会有其他内容。 在 Linux 系统中，/etc/passwd 是用来保存用户账户信息的文件。如果想确认这个脚本是否成功创建了用户账户，可以打开这个文件，看其中是否有这些新创建的用户信息。

 [root@ansible-control shells]# vim addusers.sh
 [root@ansible-control shells]# sh addusers.sh
 请输入用户密码：310550
 apple, Create success
 orange, Create success
 banana, Create success
 [root@ansible-control shells]#

 上面在学习双分支 if 条件语句时，用到了那个测试主机是否在线的脚本。既然我们现在已经掌握了 for 循环语句，不妨做些更酷的事情，比如尝试让脚本从文本中自动读取主机列表，然后自动逐个测试这些主机是否在线。 首先创建一个主机列表文件 ipaddrs.txt：

 [root@ansible-control shells]# vim ipaddrs.txt
 [root@ansible-control shells]# cat ipaddrs.txt
 192.168.10.10
 www.imyjs.cn
 www.baidu.com
 [root@ansible-control shells]#

 然后将前面的双分支 if 条件语句与 for 循环语句相结合，让脚本从主机列表文件 ipaddrs.txt 中自动读取 IP 地址（用来表示主机）并将其赋值给 HLIST 变量，从而通过判断 ping 命令执行后的返回值来逐个测试主机是否在线。脚本中出现的“$（命令）”是一种完全类似于转义字符中反引号`命令`的 Shell 操作符，效果同样是执行括号或双引号括起来的字符串中的命令。大家在编写脚本时，多学习几种类似的新方法，可在工作中大显身手：

 #!/bin/bash
 HLIST=$(cat ipaddrs.txt)
 for IP in $HLIST
 do
     ping -c 2 -i 0.2 -W 3 $IP &> /dev/null
     if [ $? -eq 0 ]
     then
         echo "Host $IP is On-line"
     else
         echo "Host $IP is Off-line"
     fi
 done

细心的读者应该发现了，Shell 脚本中的代码缩进格式会根据不同的语句而改变。这是由 Vim 编辑器自动完成的，用户无须进行额外操作。但是，如果您使用的是 RHEL 7 以前的版 本，则没有这个自动缩进功能，不过功能不受影响，只是会影响阅读体验而已。

while 条件循环语句

while 条件循环语句是一种让脚本根据某些条件来重复执行命令的语句，它的循环结构往往在执行前并不确定最终执行的次数，完全不同于 for 循环语句中有目标、有范围的使用场景。 while 循环语句通过判断条件测试的真假来决定是否继续执行命令，若条件为真就继续执行， 为假就结束循环。while 语句的语法格式如图所示。

接下来结合使用多分支的 if 条件测试语句与 while 条件循环语句，编写一个用来猜测数值大小的脚本 Guess.sh。

 #!/bin/bash
 PRICE=$(expr $RANDOM % 1000)
 TIMES=0
 echo "商品实际价格为0-999之间，猜猜看是多少？"
 while true
 do
        read -p "请输入您猜测的价格数目：" INT
        let TIMES++
         if [ $INT -eq $PRICE ] ; then
                 echo "恭喜您答对了，实际价格是 $PRICE"
                 echo "您总共猜测了 $TIMES 次"
                 exit
         elif [ $INT -gt $PRICE ] ; then
                 echo "太高了！"
         else
                 echo "太低了！"
         fi
 done

在这个 Guess.sh 脚本中，我们添加了一些交互式的信息，从而使得用户与系统的互动性 得以增强。而且每当循环到 let TIMES++命令时都会让 TIMES 变量内的数值加 1，用来统计 循环总计执行了多少次。这可以让用户得知在总共猜测了多少次之后，才猜对价格。

[root@ansible-control shells]# sh Guess.sh
 商品实际价格为0-999之间，猜猜看是多少？
 请输入您猜测的价格数目：500
 太高了！
 请输入您猜测的价格数目：250
 太高了！
 请输入您猜测的价格数目：120
 太低了！
 请输入您猜测的价格数目：125
 太低了！
 请输入您猜测的价格数目：128
 太低了！
 请输入您猜测的价格数目：150
 太低了！
 请输入您猜测的价格数目：200
 太高了！
 请输入您猜测的价格数目：180
 太低了！
 请输入您猜测的价格数目：190
 太高了！
 请输入您猜测的价格数目：185
 太高了！
 请输入您猜测的价格数目：184
 恭喜您答对了，实际价格是 184
 您总共猜测了 11 次
 [root@ansible-control shells]#

当条件为 true（真）的时候，while 语句会一直循环下去，只有碰到 exit 才会结束，所以 同学们一定要记得加上 exit 哦。

case 条件测试语句

case 语句是在多个范围内匹配数据，若匹配成功则执行相关命令并结束整个条件测试；如果数据不在所列出的范围内， 则会去执行星号（*）中所定义的默认命令。case 语句的语法结构如图所示。

case "变量值" in
匹配值1)
命令序列1
;;
匹配值2)
命令序列2
;;
*)
默认命令序列
esac

 

 

在前文介绍的 Guess.sh 脚本中有一个致命的弱点—只能接受数字！您可以尝试输入一个字母，会发现脚本立即就崩溃了。原因是字母无法与数字进行大小比较，例如，“a 是否大于等于 3”这样的命题是完全错误的。必须有一定的措施来判断用户输入的内容，当用户输入 的内容不是数字时，脚本能予以提示，从而免于崩溃。 通过在脚本中组合使用 case 条件测试语句和通配符，完全可以满足这里的需求。接下来我们编写脚本 Checkkeys.sh，提示用户输入一个字符并将其赋值给变量 KEY， 然后根据变量 KEY 的值向用户显示其值是字母、数字还是其他字符。

 [root@ansible-control shells]# vim checkKey.sh
 #!/bin/bash
 read -p "请输入一个字符，并按Enter键确认：" KEY
 case "$KEY" in
        [a-z]|[A-Z])
                 echo "您输入的是 字母。"
                ;;
        [0-9])
                 echo "您输入的是 数字。"
                ;;
        *)
                 echo "您输入的是 空格、功能键或其他控制字符。"
 esac
 [root@ansible-control shells]# sh checkKey.sh
 请输入一个字符，并按Enter键确认：6
 您输入的是 数字。
 [root@ansible-control shells]# sh checkKey.sh
 请输入一个字符，并按Enter键确认：a
 您输入的是 字母。
 [root@ansible-control shells]# sh checkKey.sh
 请输入一个字符，并按Enter键确认：^C
 [root@ansible-control shells]# sh checkKey.sh
 请输入一个字符，并按Enter键确认：^V^B
 您输入的是 空格、功能键或其他控制字符。
 [root@ansible-control shells]#

计划任务服务程序

经验丰富的系统运维工程师可以使得Linux在无须人为介入的情况下，在指定的时间段自动启用或停止某些服务或命令，从而实现运维的自动化。尽管我们现在已经有了功能彪悍的脚本程序来执行一些批处理工作，但是，如果仍然需要在每天凌晨两点敲击键盘回车键来执行这个脚本程序，就太痛苦了。接下来，将向大家讲解如何设置服务器的计划任务服务，把周期性、规律性的工作交给系统自动完成。

计划任务分为一次性计划任务与长期性计划任务，大家可以按照如下方式理解。

顾名思义，一次性计划任务只执行一次，一般用于临时的工作需求。可以用at命令实现这种功能，只需要写成“at 时间”的形式就行。如果想要查看已设置好但还未执行的一次性计划任务，可以使用at -l命令；要想将其删除，可以使用“atrm 任务序号”。at命令中的参数及其作用如表所示。

参数	作用
-f	指定包含命令的任务文件
-q	指定新任务名称
-l	显示待执行任务列表
-d	删除指定待执行任务
-m	任务执行后给用户发邮件

在使用at命令来设置一次性计划任务时，默认采用的是交互式方法。

 [root@ansible-control shells]# at 21:08
 -bash: at: command not found
 [root@ansible-control shells]# which at
 /usr/bin/which: no at in (/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin)
 [root@ansible-control shells]# yum -y install at
 [root@ansible-control shells]# at 21:11
 at> echo "hello"
 at> 此处请同时按下<Ctrl>+<d>键来结束编写计划任务
 job 1 at Mon Jul 24 21:11:00 2023
 Can't open /var/run/atd.pid to signal atd. No atd running?

 执行at命令提示Can't open /var/run/atd.pid to signal atd. No atd running?

这个错误提示意味着at命令无法找到运行中的atd守护进程。atd是at命令的后台进程，负责管理和执行计划任务。

要解决这个问题，您可以按照以下步骤进行操作：

1. 检查atd守护进程是否正在运行。可以在终端中运行以下命令来检查：

    sudo systemctl status atd

   如果atd守护进程没有运行，您可以尝试启动它：

    sudo systemctl start atd

   如果启动成功，您可以继续使用at命令了。

2. 如果atd守护进程已经在运行，但仍然遇到这个错误提示，可能是由于权限问题导致无法访问/var/run/atd.pid文件。您可以尝试更改该文件的权限：

    sudo chmod 666 /var/run/atd.pid

   然后再次尝试使用at命令。

如果上述步骤都没有解决问题，您可以尝试重新安装at和atd。具体操作可以根据您使用的Linux发行版来确定，一般可以使用包管理器来安装或重新安装at和atd。

另外，可以把管道符放到两条命令之间，让at命令接收前面echo命令的输出信息，以达到通过非交互式的方式创建计划一次性任务的目的。

 [root@ansible-control mail]# echo "systemctl restart httpd" | at 23:30
 job 6 at Mon Jul 24 23:30:00 2023
 [root@ansible-control mail]# at -l
 6       Mon Jul 24 23:30:00 2023 a root
 [root@ansible-control mail]#

 上面设置了两条一样的计划任务，可以使用atrm命令轻松删除其中一条：

 [root@ansible-control mail]# at -l
 5       Mon Jul 24 23:30:00 2023 a root
 6       Mon Jul 24 23:30:00 2023 a root
 [root@ansible-control mail]# at -d 5
 [root@ansible-control mail]# at -l
 6       Mon Jul 24 23:30:00 2023 a root
 [root@ansible-control mail]# atrm 6
 [root@ansible-control mail]# at -l
 [root@ansible-control mail]#

 这里还有一种特殊场景—把计划任务写入Shell脚本中，当用户激活该脚本后再开始倒计时执行，而不是像上面那样在固定的时间（“at 23:30”命令）进行。这该怎么办呢？

一般我们会使用“at now +2 MINUTE”的方式进行操作，这表示2分钟（MINUTE）后执行这个任务，也可以将其替代成小时（HOUR）、日（DAY）、月（MONTH）等词汇：

[root@ansible-control mail]# at now +2 MINUTE
 at> systemctl stop firewalld
 at> 此处请同时按下<Ctrl>+<d>键来结束编写计划任务
 job 7 at Mon Jul 24 21:24:00 2023

 ​还有些时候，我们希望Linux系统能够周期性地、有规律地执行某些具体的任务，那么Linux系统中默认启用的crond服务简直再适合不过了。创建、编辑计划任务的命令为crontab -e，查看当前计划任务的命令为crontab -l，删除某条计划任务的命令为crontab -r。另外，如果您是以管理员的身份登录的系统，还可以在crontab命令中加上-u参数来编辑他人的计划任务。crontab命令中的参数及其作用如表所示。

参数	作用
-e	编辑计划任务
-u	指定用户名称
-l	列出任务列表
-r	删除计划任务

在正式部署计划任务前，请念一下口诀“分、时、日、月、星期 命令”。这是使用crond服务设置任务的参数格式。需要注意的是，如果有些字段没有被设置，则需要使用星号（*）占位，如图所示。

字段	说明
分钟	取值为0～59的整数
小时	取值为0～23的任意整数
日期	取值为1～31的任意整数
月份	取值为1～12的任意整数
星期	取值为0～7的任意整数，其中0与7均为星期日
命令	要执行的命令或程序脚本

假设在每周一、三、五的凌晨3:25，都需要使用tar命令把某个网站的数据目录进行打包处理，使其作为一个备份文件。我们可以使用crontab -e命令来创建计划任务，为自己创建计划任务时无须使用-u参数。crontab –e命令的具体实现效果和crontab -l命令的结果如下所示：

 [root@linuxprobe ~]# crontab -e
 no crontab for root - using an empty one
 crontab: installing new crontab
 [root@linuxprobe ~]# crontab -l
 25 3 * * 1,3,5 /usr/bin/tar -czvf backup.tar.gz /home/wwwroot

 

如果在crond服务中需要同时包含多条计划任务的命令语句，应每行仅写一条。例如我们再添加一条计划任务，它的功能是每周一至周五的凌晨1点自动清空/tmp目录内的所有文件。尤其需要注意的是，在crond服务的计划任务参数中，所有命令一定要用绝对路径的方式来写，如果不知道绝对路径，请用whereis命令进行查询。

[root@linuxprobe ~]# whereis rm
 rm: /usr/bin/rm /usr/share/man/man1/rm.1.gz /usr/share/man/man1p/rm.1p.gz
 [root@linuxprobe ~]# crontab -e
 crontab: installing new crontab
 [root@linuxprobe ~]# crontab -l
 25 3 * * 1,3,5 /usr/bin/tar -czvf backup.tar.gz /home/wwwroot
 0  1 * * 1-5   /usr/bin/rm -rf /tmp/*

总结一下使用计划服务的注意事项。

删除crond计划任务则非常简单，直接使用crontab -e命令进入编辑界面，删除里面的文本信息即可。也可以使用crontab -r命令直接进行删除。

微信关注