Vim编辑器与Shell命令脚本

fudyou

章节简述：
: q& Y* t3 Z# D. \$ Y6 L: K% P本章首先介绍如何使用Vim编辑器来编写和修改文档，然后通过逐步配置主机名称、系统网卡以及软件仓库等文件，帮助大家加深Vim编辑器中诸多命令、快捷键与模式的理解。然后会带领大家重温第2章和第3章中的重点知识，做到Linux命令、逻辑操作符与Shell脚本的灵活搭配使用。
本章还要求大家能够在Shell脚本中以多种方式接收用户输入的信息，能够对输入值进行文件、数字、字符串的判断比较。在熟练使用“与、或、非”三种逻辑操作符的基础上，大家还要充分学习if、for、while、case条件测试语句，并通过10多个实战脚本的实操练习，达到在工作中灵活运用的水准。
本章最后通过实战的方式演示了使用at命令与crond计划任务服务来分别实现一次性的系统任务设置和长期性的系统任务设置，在分钟、小时、日期、月份、年份的基础上实现工作的自动化，从而让日常的工作更加高效，可以让大家早点下班陪孩子。
2 I, Z9 D0 m/ u; T1 J* I: B5 M

本章目录结构

• 4.1 Vim文本编辑器
  ; @+ a$ k+ Y. V/ y, j6 I
  • 4.1.1 编写简单文档
  • 4.1.2 配置主机名称
  • 4.1.3 配置网卡信息
  • 4.1.4 配置软件仓库
    : F- u$ G+ o& m9 }9 F
• 4.2 编写Shell脚本
  6 E& G- M$ f) @7 ~
  • 4.2.1 编写简单的脚本
  • 4.2.2 接收用户的参数
  • 4.2.3 判断用户的参数
    
• 4.3 流程控制语句
  4 u7 k; Z' B1 k1 I- t6 S2 G/ P  b
  • 4.3.1 if条件测试语句
  • 4.3.2 for条件循环语句
  • 4.3.3 while条件循环语句
  • 4.3.4 case条件测试语句
    
• 4.4 计划任务服务程序
  & M' D% h/ @1 ~6 j' v6 X

+ E# v, {) Z9 J" f6 S) N4.1 Vim文本编辑器Vim的发布最早可以追溯到1991年，英文全称为Vi Improved。它也是Vi编辑器的提升版本，其中最大的改进当属添加了代码着色功能，在某些编程场景下还能自动修正错误代码。
每当在讲课时遇到需要让学生记住的知识点时，为了能让他们打起精神来，我都会突然提高嗓门，因此有句话他们记得尤其深刻：“在Linux系统中一切都是文件，而配置一个服务就是在修改其配置文件的参数。”而且在日常工作中大家也肯定免不了要编写文档，这些工作都是通过文本编辑器来完成的。刘遄老师写作本书的目的是让读者切实掌握Linux系统的运维方法，而不是仅仅停留在“会用某个操作系统”的层面上，所以我们这里选择使用Vim文本编辑器，它默认会安装在当前所有的Linux操作系统上，是一款超棒的文本编辑器。
Vim之所以能得到广大厂商与用户的认可，原因在于Vim编辑器中设置了3种模式—命令模式、末行模式和编辑模式，每种模式分别又支持多种不同的命令快捷键，这大大提高了工作效率，而且用户在习惯之后也会觉得相当顺手。要想高效地操作文本，就必须先搞清这3种模式的操作区别以及模式之间的切换方法（见图4-1）。

命令模式：控制光标移动，可对文本进行复制、粘贴、删除和查找等工作。
$ ]( k/ Z3 w) V输入模式：正常的文本录入。
: T1 O- J+ o% m% |末行模式：保存或退出文档，以及设置编辑环境。
6 i6 e. @$ r2 i& s

图4-1  Vim编辑器模式的切换方法

在每次运行Vim编辑器时，默认进入命令模式，此时需要先切换到输入模式后再进行文档编写工作。而每次在编写完文档后需要先返回命令模式，然后再进入末行模式，执行文档的保存或退出操作。在Vim中，无法直接从输入模式切换到末行模式。Vim编辑器中内置的命令有成百上千种用法，为了能够帮助读者更快地掌握Vim编辑器，表4-1总结了在命令模式中最常用的一些命令。
表4-1                                                    命令模式中最常用的一些命令

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

末行模式主要用于保存或退出文件，以及设置Vim编辑器的工作环境，还可以让用户执行外部的Linux命令或跳转到所编写文档的特定行数。要想切换到末行模式，在命令模式中输入一个冒号就可以了。末行模式中常用的命令如表4-2所示。
0 w% l% v$ Q) T+ H表4-2                                                   末行模式中最常用的一些命令
" G4 T" B) J- i: e3 D

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

大家在平日里一定要多使用Vim编辑器，一旦把Vim的各种命令练熟，后面在编辑配置文件时，效率就会有很大的提升。在2011年，有一位名为Aleksandr Levchuk的极客，他就为了追求极致的效率，发起了一个名为VIM Clutch的实验项目。他买了一对类似于汽车油门和刹车的离合器，改装后再用USB与电脑相连，左脚踩刹车是进入编辑模式（i），右脚踩油门是保存文件（wq!）。他对Linux和Vim的热爱真是强大！
4.1.1 编写简单文档目前为止，大家已经具备了在Linux系统中编写文档的理论基础，接下来我们一起动手编写一个简单的脚本文档。刘遄老师会尽力把所有操作步骤和按键过程都标注出来，如果忘记了某些快捷键命令的作用，可以再返回前文进行复习。
# o! q) g5 s, ~; C+ `# ^0 R编写脚本文档的第1步就是给文档取个名字，这里将其命名为practice.txt。如果存在该文档，则是打开它。如果不存在，则是创建一个临时的输入文件，如图4-2所示。
' d/ ?% x& U7 U0 m; E) N4 L

图4-2  尝试编写文本文档

打开practice.txt文档后，默认进入的是Vim编辑器的命令模式。此时只能执行该模式下的命令，而不能随意输入文本内容，我们需要切换到输入模式才可以编写文档。
1 e$ m0 A. }# X2 x2 Q在图4-1中提到，可以分别使用a、i、o三个键从命令模式切换到输入模式。其中，a键与i键分别是在光标后面一位和光标当前位置切换到输入模式，而o键则是在光标的下面再创建一个空行，此时可敲击a键进入到编辑器的输入模式，如图4-3所示。
$ V, e5 |: K4 g7 D0 p: d) u

图4-3  切换至编辑器的输入模式

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

图4-4  在编辑器中输入文本内容

在编写完之后，要想保存并退出，必须先敲击键盘的Esc键从输入模式返回命令模式，如图4-5所示。然后再输入“:wq!”切换到末行模式才能完成保存退出操作，如图4-6所示。
9 F! P6 v+ S8 v; f4 z) Q. O7 J  O

图4-5 切换至编辑器的命令模式

图4-6 切换至编辑器的末行模式

Tips
; ?: a  V4 ~/ ~请各位同学仔细观察图4-4～图4-6中左下角的提示信息，在不同模式下有不同的提示字样。

$ A& ^0 y& k! P* Z5 U# W* L当在末行模式中输入“:wq!”命令时，就意味着强制保存并退出文档。然后便可以用cat命令查看保存后的文档内容了，如图4-7所示。
, B9 ^/ k# P7 T% y

图4-7 查看文档的内容

是不是很简单？！继续编辑这个文档。因为要在原有文本内容的下面追加内容，所以在命令模式中敲击o键进入输入模式更会高效，操作如图4-8～图4-10所示。

图4-8  再次通过Vim编辑器编写文档

图4-9  进入Vim编辑器的输入模式

图4-10  追加写入一行文本内容

因为此时已经修改了文本内容，所以Vim编辑器在我们尝试直接退出文档而不保存的时候就会拒绝我们的操作了。此时只能强制退出才能结束本次输入操作，如图4-11～图4-13所示。
' m5 q1 y% N) A4 J* p

图4-11  退出文本编辑器

图4-12  因文件已被修改而拒绝退出操作

图4-13  强制退出文本编辑器

现在大家也算是具有了一些Vim编辑器的实战经验了，应该也感觉到没有想象中那么难吧。现在查看文本的内容，果然发现追加输入的内容并没有被保存下来，如图4-14所示。

图4-14  查看最终编写成的文本内容

大家在学完了理论知识之后又自己动手编写了一个文本，现在是否感觉成就满满呢？接下来将会由浅入深地为读者安排3个小任务。为了彻底掌握Vim编辑器的使用，大家一定要逐个完成不许偷懒，如果在完成这3个任务期间忘记了相关命令，可返回前文进一步复习掌握。
6 m1 {& J. `2 ?5 x6 P) JTips
: S7 V4 A7 y5 M* B9 c' n* _下面的实验如果做不成功也很正常，请大家把重心放到Vim编辑器上面，能成功修改配置文件就已经很棒啦！
" B$ `5 L. r( e4 t
4.1.2 配置主机名称为了便于在局域网中查找某台特定的主机，或者对主机进行区分，除了要有IP地址外，还要为主机配置一个主机名，主机之间可以通过这个类似于域名的名称来相互访问。在Linux系统中，主机名大多保存在/etc/hostname文件中，接下来将/etc/hostname配置文件的内容修改为“linuxprobe.com”，步骤如下。

第1步：使用Vim编辑器修改/etc/hostname主机名称文件。
第2步：把原始主机名称删除后追加“linuxprobe.com”。注意，使用Vim编辑器修改主机名称文件后，要在末行模式下执行“:wq!”命令才能保存并退出文档。
# z3 s; Q8 ~+ B4 {+ K第3步：保存并退出文档，然后使用hostname命令检查是否修改成功。
, |6 X: D- V* m

: }* U1 d2 A& y8 V6 x$ I/ B& l' \

1. [root@linuxprobe ~]# vim /etc/hostname
   2 g$ l3 Q7 A3 f1 p+ r4 T
2. linuxprobe.com
   
3. 
   
4. hostname命令用于查看当前的主机名称，但有时主机名称的改变不会立即同步到系统中，所以如果发现修改完成后还显示原来的主机名称，可重启虚拟机后再行查看：
   
5. 
   
6. [root@linuxprobe ~]# hostname
   
7. linuxprobe.com
   ! E/ R5 V, b0 u7 i9 F8 N" Q/ t. w

复制代码

4.1.3 配置网卡信息网卡IP地址配置的是否正确是两台服务器是否可以相互通信的前提。在Linux系统中，一切都是文件，因此配置网络服务的工作其实就是在编辑网卡配置文件。这个小任务不仅可以帮助您练习使用Vim编辑器，而且也为后面学习Linux中的各种服务配置打下了坚实的基础。当您认真学习完本书后，一定会特别有成就感，因为本书前面的基础部分非常扎实，而后面内容则具有几乎一致的网卡IP地址和运行环境，从而确保您全身心地投入到各类服务程序的学习上，而不用操心系统环境的问题。
: d2 }  X3 o0 E) x如果您具备一定的运维经验或者熟悉早期的Linux系统，则在学习本书时会遇到一些不容易接受的差异变化。在RHEL 5、RHEL 6中，网卡配置文件的前缀为eth，第1块网卡为eth0，第2块网卡为eth1；以此类推。在RHEL 7中，网卡配置文件的前缀则以ifcfg开始，再加上网卡名称共同组成了网卡配置文件的名字，例如ifcfg-eno16777736。而在RHEL 8中，网卡配置文件的前缀依然为ifcfg，区别是网卡名称改成了类似于ens160的样子，不过好在除了文件名发生变化外，网卡参数没有其他大的区别。
现在有一个名称为ifcfg-ens160的网卡设备，将其配置为开机自启动，并且IP地址、子网、网关等信息由人工指定，其步骤如下所示。
5 L7 I( M+ d+ i% X第1步：首先切换到/etc/sysconfig/network-scripts目录中（存放着网卡的配置文件）。
; `0 R; F5 h6 P* j' Y第2步：使用Vim编辑器修改网卡文件ifcfg-ens160，逐项写入下面的配置参数并保存退出。由于每台设备的硬件及架构是不一样的，因此请读者使用ifconfig命令自行确认各自网卡的默认名称。
  Y0 Y8 O& u) c6 z

1. 设备类型：TYPE=Ethernet
   ( r5 {! z- [$ R+ \
2. 地址分配模式：BOOTPROTO=static
   
3. 网卡名称：NAME=ens160
   
4. 是否启动：ONBOOT=yes
   4 ~9 n& ?" S& E8 W" l
5. IP地址：IPADDR=192.168.10.10
   
6. 子网掩码：NETMASK=255.255.255.0
   
7. 网关地址：GATEWAY=192.168.10.1
   
8. DNS地址：DNS1=192.168.10.1

复制代码

第3步：重启网络服务并测试网络是否连通。
! s$ B- ]" A# ~: t) n下面正式开干！
! c9 S2 s8 v$ Y: _进入到网卡配置文件所在的目录，然后编辑网卡配置文件，在其中填入下面的信息：

1. [root@linuxprobe ~]# cd /etc/sysconfig/network-scripts/
   
2. [root@linuxprobe network-scripts]# vim ifcfg-ens160
   / `, D5 z8 ?: ?
3. TYPE=Ethernet
   7 D6 K2 C0 g/ i" X& C% z, C
4. BOOTPROTO=static
   + ~7 L3 V( X8 ^' n# h0 T
5. NAME=ens160
   
6. ONBOOT=yes
   + ?8 J' z$ p; o. V4 }- ]
7. IPADDR=192.168.10.10
   
8. NETMASK=255.255.255.0
   
9. GATEWAY=192.168.10.1
   ! O& e4 X8 g; A' ]9 T+ n
10. DNS1=192.168.10.1

复制代码

+ d! @6 H5 I/ m7 o# U! v执行重启网卡设备的命令，然后通过ping命令测试网络能否连通。由于在Linux系统中ping命令不会自动终止，因此需要手动按下Ctrl+C组合键来强行结束进程。
. V; \5 {  f1 M& }' C$ D8 s- u" L

1. [root@linuxprobe network-scripts]# nmcli connection reload ens160
     K2 L; O& z) B# D* A. P) l$ F
2. [root@linuxprobe network-scripts]# ping 192.168.10.10
   ) ]6 y; w5 v: F
3. PING 192.168.10.10 (192.168.10.10) 56(84) bytes of data.
   
4. 64 bytes from 192.168.10.10: icmp_seq=1 ttl=64 time=0.083 ms
   
5. 64 bytes from 192.168.10.10: icmp_seq=2 ttl=64 time=0.110 ms
   
6. 64 bytes from 192.168.10.10: icmp_seq=3 ttl=64 time=0.106 ms
   
7. 64 bytes from 192.168.10.10: icmp_seq=4 ttl=64 time=0.035 ms
   
8. ^C
   * J: i/ K& y6 ?3 N- t3 Q
9. --- 192.168.10.10 ping statistics ---
     |& m6 P8 R- Z8 p" P
10. 4 packets transmitted, 4 received, 0% packet loss, time 84ms
    
11. rtt min/avg/max/mdev = 0.035/0.083/0.110/0.031 ms
    ! A! v: X* H0 U+ A" u
12. [root@linuxprobe network-scripts]#

复制代码

是不是感觉很有意思？！当然如果这个实验失败了也不用气馁，后面会有相应的章节专门讲解，请大家把关注点继续放回到Vim编辑器上就好。
$ A, k: S9 l" I! K3 |, `7 g4.1.4 配置软件仓库本书前面讲到，软件仓库是一种能进一步简化RPM管理软件的难度以及自动分析所需软件包及其依赖关系的技术。可以把Yum或DNF想象成是一个硕大的软件仓库，里面保存有几乎所有常用的工具，而且只需要说出所需的软件包名称，系统就会自动为您搞定一切。
既然要使用软件仓库，就要先把它搭建起来，然后将其配置规则确定好才行。鉴于第6章才会讲解Linux的存储结构和设备挂载操作，所以当前还是将重心放到Vim编辑器的学习上。如果遇到看不懂的参数也不要紧，后面章节会单独讲解。
Yum与DNF软件仓库的配置文件是通用的，也就是说填写好配置文件信息后，这两个软件仓库的命令都是可以正常使用。建议在RHEL 8中使用dnf作为软件的安装命令，因为它具备更高的效率，而且支持多线程同时安装软件。
搭建并配置软件仓库的大致步骤如下所示。
第1步：进入/etc/yum.repos.d/目录中（因为该目录存放着软件仓库的配置文件）。
第2步：使用Vim编辑器创建一个名为rhel8.repo的新配置文件（文件名称可随意，但后缀必须为.repo），逐项写入下面的配置参数并保存退出。

仓库名称：具有唯一性的标识名称，不应与其他软件仓库发生冲突。
描述信息（name）：可以是一些介绍性的词，易于识别软件仓库的用处。
  ?& H. |$ j! E! ^仓库位置（baseurl）：软件包的获取方式，可以使用FTP或HTTP下载，也可以是本地的文件（需要在后面添加file参数）。
是否启用（enabled）：设置此源是否可用；1为可用，0为禁用。
; l3 ~' E' G$ S* b2 [! j; I8 N是否校验（gpgcheck）：设置此源是否校验文件；1为校验，0为不校验。
" \5 ]  Q. Q: `# s6 z9 y8 ?公钥位置（gpgkey）：若上面的参数开启了校验功能，则此处为公钥文件位置。若没有开启，则省略不写。
, [# ^  V- J# \$ M

第3步：按配置参数中所填写的仓库位置挂载光盘，并把光盘挂载信息写入/etc/fstab文件中。
  K/ D. y$ a( A& y第4步：使用“dnf install httpd -y”命令检查软件仓库是否已经可用。
开始实战！
进入/etc/yum.repos.d目录后创建软件仓库的配置文件：

1. [root@linuxprobe ~]# cd /etc/yum.repos.d/
   $ r* c+ E  R2 P9 ?3 b! |. _
2. [root@linuxprobe yum.repos.d]# vim rhel8.repo
   - [1 B7 ]2 g- x) i2 x) j
3. [BaseOS]
   2 N0 a4 O+ e- t6 W5 c
4. name=BaseOS
   
5. baseurl=file:///media/cdrom/BaseOS
   
6. enabled=1
   
7. gpgcheck=0
   1 g6 C' n- a6 G
8. [AppStream]
   
9. name=AppStream
   
10. baseurl=file:///media/cdrom/AppStream
    1 e0 }7 ]7 u  k- R; N, d/ s
11. enabled=1
    8 h* Q# z3 S; Z
12. gpgcheck=0

复制代码

/ f5 h$ {, q6 S
7 y6 G6 W0 R8 a- P5 J创建挂载点后进行挂载操作，并设置成开机自动挂载（详见第6章）：

1. [root@linuxprobe yum.repos.d]# mkdir -p /media/cdrom
   
2. [root@linuxprobe yum.repos.d]# mount /dev/cdrom /media/cdrom
   & r4 y% ?8 a: j& u, P# F
3. mount: /media/cdrom: WARNING: device write-protected, mounted read-only.
   + A+ S" u  N, _/ e4 e) d' n
4. [root@linuxprobe yum.repos.d]# vim /etc/fstab
   
5. /dev/cdrom /media/cdrom iso9660 defaults 0 0

复制代码

; @# _% F5 H) V4 z- I1 s+ v尝试使用软件仓库的dnf命令来安装Web服务，软件包名称为httpd，安装后出现“Complete!”则代表配置正确：

1. <pre>[root@linuxprobe ~]# dnf install httpd -y
   ! o3 ~" x  x' Y6 ^& ]! l% b0 m9 h
2. Updating Subscription Management repositories.
   6 ^: X& Y1 `, R
3. Unable to read consumer identity
   
4. This system is not registered to Red Hat Subscription Management. You can use subscription-manager to register.
   
5. AppStream 3.1 MB/s | 3.2 kB 00:00
   
6. BaseOS 2.7 MB/s | 2.7 kB 00:00
   
7. Dependencies resolved.
   
8. ………………省略部分输出信息………………
   9 {, c  y1 o+ K& m: i/ P* Y& @
9. Installed:
   
10. httpd-2.4.37-10.module+el8+2764+7127e69e.x86_64
    ' D  \) e$ s& T0 r
11. apr-util-bdb-1.6.1-6.el8.x86_64
    
12. apr-util-openssl-1.6.1-6.el8.x86_64
    
13. apr-1.6.3-9.el8.x86_64
    3 y1 j1 u) Q/ v, C  \: \
14. apr-util-1.6.1-6.el8.x86_64
    9 l8 X8 ]7 @  y. Z. O2 _( {! a
15. httpd-filesystem-2.4.37-10.module+el8+2764+7127e69e.noarch
    
16. httpd-tools-2.4.37-10.module+el8+2764+7127e69e.x86_64
    0 N- w& m( m, U4 K& @, c
17. mod_http2-1.11.3-1.module+el8+2443+605475b7.x86_64
    7 T9 p  O3 s8 F2 V- [( Z
18. redhat-logos-httpd-80.7-1.el8.noarch
    
19. 
    
20. Complete!</pre>

复制代码

对于习惯使用yum命令来安装软件的同学，也不需要有压力，因为您依然可以使用yum install httpd命令来安装软件，只是将dnf替换成yum。可见，RHEL 8版本很好地兼容了用户习惯。
" [$ d. R6 w; |" t, |4.2 编写Shell脚本
0 ?' O8 z3 U0 |8 u9 a4 ^可以将Shell终端解释器当作人与计算机硬件之间的“翻译官”，它作为用户与Linux系统内部的通信媒介，除了能够支持各种变量与参数外，还提供了诸如循环、分支等高级编程语言才有的控制结构特性。要想正确使用Shell中的这些功能特性，准确下达命令尤为重要。Shell脚本命令的工作方式有下面两种。

交互式（Interactive）：用户每输入一条命令就立即执行。
) n! U+ y! f: L) }批处理（Batch）：由用户事先编写好一个完整的Shell脚本，Shell会一次性执行脚本中诸多的命令。
. ]4 u1 M4 @1 b8 ^+ o3 s9 u

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

1. [root@linuxprobe ~]# echo $SHELL
   
2. /bin/bash

复制代码

4.2.1 编写简单的脚本估计读者在看完上文中有关Shell脚本的复杂描述后，会累觉不爱吧。但是，上文指的是一个高级Shell脚本的编写原则，其实使用Vim编辑器把Linux命令按照顺序依次写入到一个文件中，就是一个简单的脚本了。
4 {8 R4 w& F$ K+ O0 T5 _' s例如，如果想查看当前所在工作路径并列出当前目录下所有的文件及属性信息，实现这个功能的脚本应该类似于下面这样：
( \/ _% t! |& H5 B  {  X

1. [root@linuxprobe ~]# vim example.sh
   
2. #!/bin/bash
   
3. #For Example BY linuxprobe.com
   ! F/ d; k' ]/ Q7 g4 ^4 E
4. pwd
   
5. ls -al

复制代码

Shell脚本文件的名称可以任意，但为了避免被误以为是普通文件，建议将.sh后缀加上，以表示是一个脚本文件。
. D% m% b/ x1 b7 K在上面的这个example.sh脚本中实际上出现了3种不同的元素：第一行的脚本声明（#!）用来告诉系统使用哪种Shell解释器来执行该脚本；第二行的注释信息（#）是对脚本功能和某些命令的介绍信息，使得自己或他人在日后看到这个脚本内容时，可以快速知道该脚本的作用或一些警告信息；第三、四行的可执行语句也就是我们平时执行的Linux命令了。你们不相信这么简单就编写出来了一个脚本程序？！那我们来执行一下看看结果：

1. [root@linuxprobe ~]# bash example.sh
   
2. /root
     c( o$ Y! [- @& P( }0 M6 E
3. total 60
   
4. dr-xr-x---. 15 root root  4096 Oct 12 00:41 .
   " N/ E. O- k* H' ]9 ~& U$ v6 {; p
5. dr-xr-xr-x. 17 root root   224 Jul 21 05:04 ..
   / @( [9 N1 n* w2 m% e& w) `
6. -rw-------.  1 root root  1407 Jul 21 05:09 anaconda-ks.cfg
   
7. -rw-------.  1 root root   335 Jul 24 06:33 .bash_history
   7 w% R  x! A- p8 P8 L8 x5 s
8. -rw-r--r--.  1 root root    18 Aug 13  2018 .bash_logout
   : q: q6 |& {+ z" N$ c, B
9. -rw-r--r--.  1 root root   176 Aug 13  2018 .bash_profile
   : H  n* |4 Z6 b% g- q# G8 {3 r  z1 Z
10. ………………省略部分输出信息………………

复制代码

9 A$ z' m# H' ?; I0 b
除了上面用Bash解释器命令直接运行Shell脚本文件外，第二种运行脚本程序的方法是通过输入完整路径的方式来执行。但默认会因为权限不足而提示报错信息，此时只需要为脚本文件增加执行权限即可（详见第5章）。初次学习Linux系统的读者不用心急，等下一章学完用户身份和权限后再来做这个实验也不迟：
# x4 G/ T0 |) Q6 G8 J* l' @

1. [root@linuxprobe ~]# ./example.sh
   
2. bash: ./Example.sh: Permission denied
   
3. [root@linuxprobe ~]# chmod u+x example.sh
   0 P$ l- C' D1 a: W2 F, X  b: P: x
4. [root@linuxprobe ~]# ./example.sh
   
5. /root
   
6. total 60
   
7. dr-xr-x---. 15 root root  4096 Oct 12 00:41 .
   
8. dr-xr-xr-x. 17 root root   224 Jul 21 05:04 ..
   $ q! s# x. A% o7 \2 _
9. -rw-------.  1 root root  1407 Jul 21 05:09 anaconda-ks.cfg
   % I. H% k) p0 T; F8 ]7 y' I
10. -rw-------.  1 root root   335 Jul 24 06:33 .bash_history
    $ I  X$ Z! q$ l
11. -rw-r--r--.  1 root root    18 Aug 13  2018 .bash_logout
    
12. -rw-r--r--.  1 root root   176 Aug 13  2018 .bash_profile
    
13. ………………省略部分输出信息………………

复制代码

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

1. [root@linuxprobe ~]# wc -l anaconda-ks.cfg
   
2. 44 anaconda-ks.cfg
     X& e' n3 J4 t7 `+ t  O
3. [root@linuxprobe ~]# wc -c anaconda-ks.cfg
   ( H, o9 ~9 A& a1 j' L9 E* C
4. 1407 anaconda-ks.cfg
   ; ^" \: c8 S/ h% Y
5. [root@linuxprobe ~]# wc -w anaconda-ks.cfg
   " \; ^$ [" A- W0 t) l3 s) k
6. 121 anaconda-ks.cfg

复制代码

  x0 {2 j7 x) q8 r: y9 o3 J这意味着命令不仅要能接收用户输入的内容，还要有能力进行判断区别，根据不同的输入调用不同的功能。
其实，Linux系统中的Shell脚本语言早就考虑到了这些，已经内设了用于接收参数的变量，变量之间使用空格间隔。例如，$0对应的是当前Shell脚本程序的名称，$#对应的是总共有几个参数，$*对应的是所有位置的参数值，$?对应的是显示上一次命令的执行返回值，而$1、$2、$3……则分别对应着第N个位置的参数值，如图4-15所示。
6 y2 W! O* b% F# r

图4-15  Shell脚本程序中的参数位置变量

理论过后再来练习一下。尝试编写一个脚本程序示例，通过引用上面的变量参数来看一下真实效果：
2 @; F' f# ~6 _. K( q+ \

1. [root@linuxprobe ~]# vim example.sh
   
2. #!/bin/bash
   5 V& O3 w( T% n$ i, e4 z2 r
3. echo "当前脚本名称为$0"
   
4. echo "总共有$#个参数，分别是$*。"
   
5. echo "第1个参数为$1，第5个为$5。"
   1 o9 ]7 F" R6 g6 a: w) b, j
6. [root@linuxprobe ~]# bash example.sh one two three four five six
   
7. 当前脚本名称为example.sh
   , z& I: U' j: a
8. 总共有6个参数，分别是one two three four five six。
   ) d$ K1 b; K# Q
9. 第1个参数为one，第5个为five。

复制代码

8 O" j/ e% h8 m8 N: t1 p/ K
7 z5 _6 _" a  D! e" l6 ^3 h4.2.3 判断用户的参数学习是一个登堂入室、由浅入深的过程。在学习完Linux命令，掌握Shell脚本语法变量和接收用户输入的信息之后，就要踏上新的高度—能够进一步处理接收到的用户参数。
  q+ I* Z. J) J% V- a本书在前面章节中讲到，系统在执行mkdir命令时会判断用户输入的信息，即判断用户指定的文件夹名称是否已经存在，如果存在则提示报错；反之则自动创建。Shell脚本中的条件测试语法可以判断表达式是否成立，若条件成立则返回数字0，否则便返回非零值。条件测试语法的执行格式如图4-16所示。切记，条件表达式两边均应有一个空格。
5 q  @  r$ L8 h2 \0 D/ G5 Z! N4 v

图4-16  条件测试语句的执行格式

---

按照测试对象来划分，条件测试语句可以分为4种：
: W8 `7 Z# _  b+ t% P; F* a

文件测试语句；
5 K' V0 I+ J& ?; o( h逻辑测试语句；
整数值比较语句；
字符串比较语句。
# B8 O  j5 ]# N3 T( s

文件测试即使用指定条件来判断文件是否存在或权限是否满足等情况的运算符，具体的参数如表4-3所示。
表4-3                                                    文件测试所用的参数
! d8 M/ W& P6 E& T. F, A( n

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

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

- {% J& c, s+ k- O; t) M

1. [root@linuxprobe ~]# [ -d /etc/fstab ]
   8 `* F6 X# G1 t! w2 c
2. [root@linuxprobe ~]# echo $?
   
3. 1
   7 m  d2 |  k4 f9 a- c, s7 _
4. 
   
5. 再使用文件测试语句来判断/etc/fstab是否为一般文件，如果返回值为0，则代表文件存在，且为一般文件：
   % |7 A# r: k& G! V. c  Y: Q
6. 
   
7. [root@linuxprobe ~]# [ -f /etc/fstab ]
   
8. [root@linuxprobe ~]# echo $?
   - @% e4 W: |5 W+ G  W9 j: m
9. 0
   % k- T$ h: y( r, s1 G5 }# n

复制代码

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

1. [root@linuxprobe ~]# [ -e /dev/cdrom ] && echo "Exist"
   0 v: Z& N, Y( G. N, b& J! z
2. Exist

复制代码

( @; V. B# ^+ p3 V, X6 U
除了逻辑“与”外，还有逻辑“或”，它在Linux系统中的运算符号为||，表示当前面的命令执行失败后才会执行它后面的命令，因此可以用来结合系统环境变量USER来判断当前登录的用户是否为非管理员身份：
) F7 g- C9 c# S6 @

1. [root@linuxprobe ~]# echo $USER
   2 {- @1 d5 c& A$ f
2. root
   9 ~  R" ^& C5 @. R9 V; W
3. [root@linuxprobe ~]# [ $USER = root ] || echo "user"
   ( F4 ]' U7 ]* b) V8 t
4. [root@linuxprobe ~]# su - linuxprobe
   
5. [linuxprobe@linuxprobe ~]$ [ $USER = root ] || echo "user"
   8 {3 x& X+ Q0 Q7 \
6. user

复制代码

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

1. [linuxprobe@linuxprobe ~]$ exit
   
2. logout
   
3. [root@linuxprobe ~]# [ ! $USER = root ] || echo "administrator"
   : q' }2 W! F# v  I  C; }  t* P
4. administrator

复制代码

7 s  r. N% T! K& r$ y" _8 t
叹号应该放到判断语句的前面，代表对整个的测试语句进行取反值操作，而不应该写成“$USER != root”，因为“!=”代表的是不等于符号（≠），尽管执行效果一样，但缺少了逻辑关系，这一点还请多加注意。
4 b8 c% O; k2 |) }; KTips
) Q+ X9 H- y: `2 }: C, ]1 J&&是逻辑“与”，只有当前面的语句执行成功的时候才会执行后面的语句。
||是逻辑“或”，只有当前面的语句执行失败的时候才会执行后面的语句。
!是逻辑“非”，代表对逻辑测试结果取反值；之前若为正确则变成错误，若为错误则变成正确。

1 v# [# R/ ?. O, A2 k# S, O
就技术图书的写作来讲，一般有两种套路：让读者真正搞懂技术了；让读者觉得自己搞懂技术了。因此市面上很多浅显的图书会让读者在学完之后感觉进步特别快，这基本上是作者有意为之，目的就是让您觉得“图书很有料，自己收获很大”，但是在步入工作岗位后就露出短板吃大亏。所以刘遄老师决定继续提高难度，为读者增加一个综合的示例，一方面作为前述知识的总结，另一方面帮助读者夯实基础，以便在今后的工作中更灵活地使用逻辑符号。
当前我们正在登录的即为管理员用户—root。下面这个示例的执行顺序是，先判断当前登录用户的USER变量名称是否等于root，然后用逻辑“非”运算符进行取反操作，效果就变成了判断当前登录的用户是否为非管理员用户。最后若条件成立，则会根据逻辑“与”运算符输出user字样；若条件不满足，则会通过逻辑“或”运算符输出root字样，而只有在前面的&&不成立时才会执行后面的||符号。
. H& M& e. G, Q  T2 r7 G7 G

1. [root@linuxprobe ~]# [ ! $USER = root ] && echo "user" || echo "root"
   
2. root

复制代码

---

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

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

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

1. [root@linuxprobe ~]# [ 10 -gt 10 ]
   
2. [root@linuxprobe ~]# echo $?
   8 @* r* S) c" s, K, \) V
3. 1
   
4. [root@linuxprobe ~]# [ 10 -eq 10 ]
   / \% B9 C! g6 P8 `( S6 O  n" {% Z
5. [root@linuxprobe ~]# echo $?
   " e7 Q5 a: g# T0 Q
6. 0

复制代码

" Y$ A. F0 Z. p) q在2.4节曾经讲过free命令，它能够用来获取当前系统正在使用及可用的内存量信息。接下来先使用free -m命令查看内存使用量情况（单位为MB），然后通过“grep Mem:”命令过滤出剩余内存量的行，再用awk '{print $4}'命令只保留第4列。这个演示确实有些难度，但看懂后会觉得很有意思，没准在运维工作中也会用得上。

1. [root@linuxprobe ~]# free -m
   
2.               total        used        free      shared  buff/cache   available
   / `$ K" h7 B* ]/ S/ D* k4 \( H1 N% Q6 K
3. Mem:           1966        1374         128          16         463         397
   * W4 L9 n7 g7 c; _1 K
4. Swap:          2047          66        1981
   & [3 O; ~$ Q% ^
5. [root@linuxprobe ~]# free -m | grep Mem:
   
6. Mem:           1966        1374         128          16         463         397
   
7. [root@linuxprobe ~]# free -m | grep Mem: | awk '{print $4}'
   3 F9 i: V- d+ \( G) C% _
8. 128

复制代码

: U) l3 O- m7 X& h  B如果想把这个命令写入到Shell脚本中，那么建议把输出结果赋值给一个变量，以方便其他命令进行调用：
& U: ~* \: _1 ~3 ?7 O

1. [root@linuxprobe ~]# FreeMem=`free -m | grep Mem: | awk '{print $4}'`
   4 D+ ~6 h' M* b( F
2. [root@linuxprobe ~]# echo $FreeMem
   % j3 G4 i6 k& W
3. 128

复制代码

: g1 y% t: {% C& g* a% o# w+ m
4 b8 m3 U1 ?/ W& a- g上面用于获取内存可用量的命令以及步骤可能有些“超纲”了，如果不能理解领会也不用担心，接下来才是重点。我们使用整数运算符来判断内存可用量的值是否小于1024，若小于则会提示“Insufficient Memory”（内存不足）的字样：
3 t2 Z7 i! V. G: i8 ^+ h: W9 l' P5 n

1. [root@linuxprobe ~]# [ $FreeMem -lt 1024 ] && echo "Insufficient Memory"
   
2. Insufficient Memory

复制代码

- R; e, [( ~- U0 q* s
; T$ C0 j9 I: Z) `/ C. e字符串比较语句用于判断测试字符串是否为空值，或两个字符串是否相同。它经常用来判断某个变量是否未被定义（即内容为空值），理解起来也比较简单。字符串比较中常见的运算符如表4-5所示。
表4-5                                                常见的字符串比较运算符

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

接下来通过判断String变量是否为空值，进而判断是否定义了这个变量：
6 N' R3 P. V0 G% g

1. [root@linuxprobe ~]# [ -z $String ]
   0 k' M! u' V& \1 j/ n
2. [root@linuxprobe ~]# echo $?
   
3. 0

复制代码

$ g- s3 f! A0 W+ G$ m; }" b; \! }1 p
; R& C" L8 H  |: J* ]4 W' W# x( X- e再次尝试引入逻辑运算符来试一下。当用于保存当前语系的环境变量值LANG不是英语（en.US）时，则会满足逻辑测试条件并输出“Not en.US”（非英语）的字样：

1. [root@linuxprobe ~]# echo $LANG
   ; ~+ u8 o' P+ d0 [6 q5 i% E; Z
2. en_US.UTF-8
   
3. [root@linuxprobe ~]# [ ! $LANG = "en.US" ] && echo "Not en.US"
   
4. Not en.US

复制代码

4.3 流程控制语句尽管此时可以通过使用Linux命令、管道符、重定向以及条件测试语句来编写最基本的Shell脚本，但是这种脚本并不适用于生产环境。原因是它不能根据真实的工作需求来调整具体的执行命令，也不能根据某些条件实现自动循环执行。通俗来讲，就是不能根据实际情况做出调整。
2 G' {! I7 A- \, y通常脚本都是从上到下一股脑儿地执行，效率是很高，但一旦某条命令执行失败了，则后面的功能全都会受到影响。假如大家有一天遇到了心仪的他（她），心中默默地进行如下规划（见图4-17）。

图4-17  心中规划

结果可能是见面聊天后就觉得不合适了，后续的“要手机号码”“一起吃晚饭”和“一起看电影”就要终止了，就需要转而去做其他事情，因此需要判断语句来帮助完成。
% M$ S6 |7 n. G, r1 N! p; W接下来我们通过if、for、while、case这4种流程控制语句来学习编写难度更大、功能更强的Shell脚本。为了保证下文的实用性和趣味性，做到寓教于乐，我会尽可能多地讲解各种不同功能的Shell脚本示例，而不是逮住一个脚本不放，在它原有内容的基础上修修补补。尽管这种修补式的示例教学也可以让读者明白理论知识，但是却无法开放思路，不利于日后的工作。
4.3.1 if条件测试语句if条件测试语句可以让脚本根据实际情况自动执行相应的命令。从技术角度来讲，if语句分为单分支结构、双分支结构、多分支结构；其复杂度随着灵活度一起逐级上升。
if条件语句的单分支结构由if、then、fi关键词组成，而且只在条件成立后才执行预设的命令，相当于口语的“如果……那么……”。单分支的if语句属于最简单的一种条件判断结构，语法格式如图4-18所示。

图4-18  单分支的if条件语句

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

1. [root@linuxprobe ~]# vim mkcdrom.sh
   3 B: R* F4 }* B9 V$ [- A
2. #!/bin/bash
   
3. DIR="/media/cdrom"
   ' q9 G1 K6 y2 ~3 L7 w! }" P8 l" N" E& ^
4. if [ ! -d $DIR ]
   : j/ j% y& t, @1 s
5. then   
   
6.         mkdir -p $DIR
   . B$ v- A' g9 _0 }5 a! P& H& J. j. C
7. fi

复制代码

) c# A7 c  [; u
由于第5章才讲解用户身份与权限，因此这里继续用“bash脚本名称”的方式来执行脚本。在正常情况下，顺利执行完脚本文件后没有任何输出信息，但是可以使用ls命令验证/media/cdrom目录是否已经成功创建：

1. [root@linuxprobe ~]# bash mkcdrom.sh
   + f/ }$ z9 q1 s/ d; W8 J" z
2. [root@linuxprobe ~]# ls -ld /media/cdrom
   
3. drwxr-xr-x. 2 root root 6 Oct 13 21:34 /media/cdrom

复制代码

4 B: P/ D% }  l6 `0 }) V$ j
8 q+ `2 ^" r! n4 ^

---

if条件语句的双分支结构由if、then、else、fi关键词组成，它进行一次条件匹配判断，如果与条件匹配，则去执行相应的预设命令；反之则去执行不匹配时的预设命令，相当于口语的“如果……那么……或者……那么……”。if条件语句的双分支结构也是一种很简单的判断结构，语法格式如图4-19所示。
# H' D" c8 Z# p, L1 ]* W9 T- K

图4-19 双分支的if条件语句

下面使用双分支的if条件语句来验证某台主机是否在线，然后根据返回值的结果，要么显示主机在线信息，要么显示主机不在线信息。这里的脚本主要使用ping命令来测试与对方主机的网络连通性，而Linux系统中的ping命令不像Windows一样尝试4次就结束，因此为了避免用户等待时间过长，需要通过-c参数来规定尝试的次数，并使用-i参数定义每个数据包的发送间隔，以及使用-W参数定义等待超时时间。
4 m4 h3 f' v8 {; X6 V+ x" B9 m6 M( Q/ K

1. [root@linuxprobe ~]# vim chkhost.sh
   6 F. T: N4 n. j& N" |
2. #!/bin/bash
   ; j% a) ?1 k! a. v, E
3. ping -c 3 -i 0.2 -W 3 $1 &> /dev/null
   
4. if [ $? -eq 0 ]
   / x/ y# i' I* m1 g* C' _
5. then
   
6.         echo "Host $1 is On-line."
   
7. else
   , s5 x( n# n0 s, G) y
8.         echo "Host $1 is Off-line."
   $ \4 \- y; d8 v& j1 g& _
9. fi

复制代码

% m" H1 _# A7 J/ ~. [% K
6 S' }! H7 l" r# O2 E7 ]- ~我们在4.2.3节中用过$?变量，作用是显示上一次命令的执行返回值。若前面的那条语句成功执行，则$?变量会显示数字0，反之则显示一个非零的数字（可能为1，也可能为2，取决于系统版本）。因此可以使用整数比较运算符来判断$?变量是否为0，从而获知那条语句的最终判断情况。这里的服务器IP地址为192.168.10.10，我们来验证一下脚本的效果：

1. [root@linuxprobe ~]# bash chkhost.sh 192.168.10.10
   " @# m; @$ Q. F, g
2. Host 192.168.10.10 is On-line.
   - G4 F; I. W3 m) \
3. [root@linuxprobe ~]# bash chkhost.sh 192.168.10.20
   & p& a' r7 h, b: u9 w- W
4. Host 192.168.10.20 is Off-line.

复制代码

5 G& Y/ L9 Q; L. J
1 P( E! Y0 l6 S5 k  ?if条件语句的多分支结构由if、then、else、elif、fi关键词组成，它进行多次条件匹配判断，这多次判断中的任何一项在匹配成功后都会执行相应的预设命令，相当于口语的“如果……那么……如果……那么……”。if条件语句的多分支结构是工作中最常使用的一种条件判断结构，尽管相对复杂但是更加灵活，语法格式如图4-20所示。
下面使用多分支的if条件语句来判断用户输入的分数在哪个成绩区间内，然后输出如Excellent、Pass、Fail等提示信息。在Linux系统中，read是用来读取用户输入信息的命令，能够把接收到的用户输入信息赋值给后面的指定变量，-p参数用于向用户显示一些提示信息。

图 4-20 多分支的if条件语句

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

1. [root@linuxprobe ~]# vim chkscore.sh
   , _; ~! Z" O/ `! Y0 f. ^; ]/ X* p
2. #!/bin/bash
   ! a$ s0 u2 ]- ^  [2 m
3. read -p "Enter your score（0-100）：" GRADE
   1 i5 O( l  U! c8 o& F4 q$ D+ E
4. if [ $GRADE -ge 85 ] && [ $GRADE -le 100 ] ; then
   
5.         echo "$GRADE is Excellent"
   ' {8 v6 u) I) f" j# I  B
6. elif [ $GRADE -ge 70 ] && [ $GRADE -le 84 ] ; then
   
7.         echo "$GRADE is Pass"
   
8. else
   
9.         echo "$GRADE is Fail"
   + D$ D2 J3 n1 u1 y
10. fi
    7 D$ |, h! E) }9 d# W
11. [root@linuxprobe ~]# bash chkscore.sh
    
12. Enter your score（0-100）：88
    
13. 88 is Excellent
    / ?, w# }) W; @! r
14. [root@linuxprobe ~]# bash chkscore.sh
    
15. Enter your score（0-100）：80
    
16. 80 is Pass

复制代码

3 m; }( _  ?$ t& v' ^  H/ X3 H
下面执行该脚本。当用户输入的分数分别为30和200时，其结果如下：

1. [root@linuxprobe ~]# bash chkscore.sh  
   
2. Enter your score（0-100）：30
   ( j& x/ ^. m/ a% u6 S" t
3. 30 is Fail
   
4. [root@linuxprobe ~]# bash chkscore.sh
   / W5 t9 G' g1 C* }- F) @
5. Enter your score（0-100）：200
   : W4 ?8 J$ A  h  U; Y3 H
6. 200 is Fail

复制代码

2 F: h* V9 U2 g8 n4 z3 i0 ~2 Z; B
' {$ ]' y7 r+ ~$ Q* h为什么输入的分数为200时，依然显示Fail呢？原因很简单—没有成功匹配脚本中的两个条件判断语句，因此自动执行了最终的兜底策略。可见，这个脚本还不是很完美，建议读者自行完善这个脚本，使得用户在输入大于100或小于0的分数时，给予Error报错字样的提示。
4.3.2 for条件循环语句for循环语句允许脚本一次性读取多个信息，然后逐一对信息进行操作处理。当要处理的数据有范围时，使用for循环语句就再适合不过了。for循环语句的语法格式如图4-21所示。

图4-21  for范围循环语句

下面使用for循环语句从列表文件中读取多个用户名，然后为其逐一创建用户账户并设置密码。首先创建用户名称的列表文件users.txt，每个用户名称单独一行。读者可以自行决定具体的用户名称和个数：
* K( w4 Z$ v8 U$ G% W# d6 g

1. [root@linuxprobe ~]# vim users.txt
   ; A' e$ ~" V- p) o2 X1 P
2. andy
   , o" z9 m4 @( V! Q' E2 d6 R. L
3. barry
   
4. carl
   
5. duke
   
6. eric
   5 Q2 }+ [$ }( a" R" _. D" F
7. george

复制代码

; p; G- n$ s# W; e, v6 ]/ _* e
: Y- _3 g3 j( Z- j" v0 _/ Y9 D9 T接下来编写Shell脚本addusers.sh。在脚本中使用read命令读取用户输入的密码值，然后赋值给PASSWD变量，并通过-p参数向用户显示一段提示信息，告诉用户正在输入的内容即将作为账户密码。在执行该脚本后，会自动使用从列表文件users.txt中获取到所有的用户名称，然后逐一使用“id用户名”命令查看用户的信息，并使用$?判断这条命令是否执行成功，也就是判断该用户是否已经存在。
: F! u( y7 Q# A1 ~# \

1. [root@linuxprobe ~]# vim addusers.sh
   
2. #!/bin/bash
   8 m6 v- S& s- I9 d
3. read -p "Enter The Users Password : " PASSWD
   9 c/ A/ C" _7 V& H
4. for UNAME in `cat users.txt`
   # K4 K1 C) g% t2 q9 \+ G
5. do
   + D& e  i' c$ E9 v) e
6.         id $UNAME &> /dev/null
   1 [: U8 s, V; L. I% R: Z
7.         if [ $? -eq 0 ]
   
8.         then
   & S3 A- c2 S+ ]9 H% @
9.                 echo "$UNAME , Already exists"
   
10.         else
    : E5 K8 Q6 q4 R" }1 {
11.                 useradd $UNAME
    : ?3 J6 Q2 V( A/ |/ F: d% h
12.                 echo "$PASSWD" | passwd --stdin $UNAME &> /dev/null
    ! O* D8 C& m, E0 Q$ P
13.                 echo "$UNAME , Create success"
    : O8 l: F( {7 x
14.         fi
    
15. done

复制代码

9 T: z1 M' r' |
Tips
/dev/null是一个被称作Linux黑洞的文件，把输出信息重定向到这个文件等同于删除数据（类似于没有回收功能的垃圾箱），可以让用户的屏幕窗口保持简洁。

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

1. [root@linuxprobe ~]# bash addusers.sh
   
2. Enter The Users Password : linuxprobe
   9 O: R) Q6 W3 k0 R4 u4 |
3. andy , Create success
   
4. barry , Create success
     S2 F+ D4 o; `1 f
5. carl , Create success
   & @# o/ M+ S# R: H2 B8 R3 q. g
6. duke , Create success
   ! i) w- m9 P3 a9 v8 O
7. eric , Create success
   4 v. ]6 ^. |6 p
8. george , Create success
   
9. [root@linuxprobe ~]# tail -6 /etc/passwd
   
10. andy:x:1001:1001::/home/andy:/bin/bash
    6 J# {) f7 I- {% }3 c7 P0 A6 k
11. barry:x:1002:1002::/home/barry:/bin/bash
    9 D  Q" H1 K+ a0 s- R3 A
12. carl:x:1003:1003::/home/carl:/bin/bash
    " |/ G9 [$ i1 r& [) l8 G) K8 h6 W
13. duke:x:1004:1004::/home/duke:/bin/bash
    % {, i# k5 r) \0 Z7 w! J
14. eric:x:1005:1005::/home/eric:/bin/bash
    
15. george:x:1006:1006::/home/george:/bin/bash

复制代码

1 s- T6 T; Z- J3 U2 D& ]! {
- D$ ]4 o0 U4 t- Q+ C/ c( O大家还记得在学习双分支if条件语句时，用到的那个测试主机是否在线的脚本么？既然我们现在已经掌握了for循环语句，不妨做些更酷的事情，比如尝试让脚本从文本中自动读取主机列表，然后自动逐个测试这些主机是否在线。
首先创建一个主机列表文件ipaddrs.txt：

1. [root@linuxprobe ~]# vim ipaddrs.txt
   . A$ L) m# }! N6 d! Z5 n
2. 192.168.10.10
     q* q5 l7 W: P3 T& A# z+ [& @
3. 192.168.10.11
   
4. 192.168.10.12

复制代码

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

1. [root@linuxprobe ~]# vim CheckHosts.sh
   
2. #!/bin/bash
   
3. HLIST=$(cat ~/ipaddrs.txt)
   ) L5 N, _2 h1 E) Q7 v% G
4. for IP in $HLIST
   
5. do
   " }8 |) _2 c' |5 \) _9 J
6.         ping -c 3 -i 0.2 -W 3 $IP &> /dev/null
   
7.         if [ $? -eq 0 ]  
   1 l/ G! f1 D# Q5 T% P" Y: I. K# p
8.         then
   
9.                 echo "Host $IP is On-line."
   & x- T! T- @8 F+ A" N4 w2 U
10.         else
    
11.                 echo "Host $IP is Off-line."
    5 u+ H+ H" M9 m  y( M  C: D
12.         fi
    2 K5 X/ r( A8 I( O5 K
13. done
    
14. [root@linuxprobe ~]# ./CheckHosts.sh
    / M$ T( z, m. Z( @$ z
15. Host 192.168.10.10 is On-line.
    + v9 a  d1 U9 G' R& X
16. Host 192.168.10.11 is Off-line.
    
17. Host 192.168.10.12 is Off-line.

复制代码

3 z0 j7 r  E- P细心的读者应该发现了，Shell脚本中的代码缩进格式会根据不同的语句而改变。这是由Vim编辑器自动完成的，用户无须进行额外操作。但是，如果您使用的是RHEL 7以前的版本，则没有这个自动缩进功能，不过功能不受影响，只是会影响阅读体验而已。
) b* c: {7 l3 [6 E9 X7 m4.3.3 while条件循环语句

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

图4-22  while条件循环语句

接下来结合使用多分支的if条件测试语句与while条件循环语句，编写一个用来猜测数值大小的脚本Guess.sh。该脚本使用$RANDOM变量来调取出一个随机的数值（范围为0～32767），然后将这个随机数对1000进行取余操作，并使用expr命令取得其结果，再用这个数值与用户通过read命令输入的数值进行比较判断。这个判断语句分为3种情况，分别是判断用户输入的数值是等于、大于还是小于使用expr命令取得的数值。当前，现在这些内容不是重点，我们要关注的是while条件循环语句中的条件测试始终为true，因此判断语句会无限执行下去，直到用户输入的数值等于expr命令取得的数值后，才运行exit 0命令，终止脚本的执行。
& z+ D4 O* j" P4 r" o

1. [root@linuxprobe ~]# vim Guess.sh
   
2. #!/bin/bash
   
3. PRICE=$(expr $RANDOM % 1000)
   : y: g1 ?0 p7 H; R& M, S9 N
4. TIMES=0
   . e; `; q' D# p9 }
5. echo "商品实际价格为0-999之间，猜猜看是多少？"
   
6. while true
   
7. do
   / `, \2 C( ]% c) `3 P* @
8.         read -p "请输入您猜测的价格数目：" INT
   % Z3 z! n0 K) i0 ]
9.         let TIMES++
   # C+ K: L6 F, D/ {6 p: H
10.         if [ $INT -eq $PRICE ] ; then
    
11.                 echo "恭喜您答对了，实际价格是 $PRICE"
    5 Q0 q- W2 m) o& c0 U7 g7 B" k! R$ ]
12.                 echo "您总共猜测了 $TIMES 次"
    
13.                 exit
    
14.         elif [ $INT -gt $PRICE ] ; then
    % D# ~+ u, l2 l! {  q
15.                 echo "太高了！"
    7 j6 Z, W/ R  a) g5 \2 ~2 v
16.         else
    
17.                 echo "太低了！"
    
18.         fi
    - x& T) f5 b- s4 t) D4 K
19. done

复制代码

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

1. [root@linuxprobe ~]# bash Guess.sh
   
2. 商品实际价格为0-999之间，猜猜看是多少？
   
3. 请输入您猜测的价格数目：500
   " X. Z% V* |* C; e' y- ]
4. 太低了！
   
5. 请输入您猜测的价格数目：800
   
6. 太高了！
   5 Y) U6 Q3 U( m, f/ s
7. 请输入您猜测的价格数目：650
   ' y; z; q% Y. H. m0 P# u
8. 太低了！
   $ e- \) }7 M( `6 p2 z$ d
9. 请输入您猜测的价格数目：720
   9 ^7 {$ w4 g& e. D2 r( q2 H
10. 太高了！
    
11. 请输入您猜测的价格数目：690
    
12. 太低了！
    0 N3 ]3 Y! @6 q- z+ m( t8 i
13. 请输入您猜测的价格数目：700
    
14. 太高了！
    9 t9 l* v( T3 r# K
15. 请输入您猜测的价格数目：695
    9 \: L( _% k& w0 W
16. 太高了！
    % |) L/ a: }( S5 Z* T* P' g2 ~
17. 请输入您猜测的价格数目：692
    % n" e  k, d: L5 D4 z3 b8 F
18. 太高了！
    
19. 请输入您猜测的价格数目：691
    3 Z8 B. ]; B' r+ D+ g7 w, d1 M
20. 恭喜您答对了，实际价格是 691
    : X6 L( V6 Q- Y4 I/ t6 R
21. 您总共猜测了 9 次
    
22. 
    

复制代码

+ @' C+ Q( ]) Z& Y6 j' [$ b% y当条件为true（真）的时候，while语句会一直循环下去，只有碰到exit才会结束，所以同学们一定要记得加上exit哦。4.3.4 case条件测试语句如果您之前学习过C语言，看到这一小节的标题肯定会会心一笑：“这不就是switch语句嘛！”是的，case条件测试语句和switch语句的功能非常相似！case语句是在多个范围内匹配数据，若匹配成功则执行相关命令并结束整个条件测试；如果数据不在所列出的范围内，则会去执行星号（*）中所定义的默认命令。case语句的语法结构如图4-23所示。
; J( a3 k# T0 w+ k) A( t2 l

图4-23  case条件测试语句

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

1. [root@linuxprobe ~]# vim Checkkeys.sh
   
2. #!/bin/bash
   
3. read -p "请输入一个字符，并按Enter键确认：" KEY
   ( R0 m5 q8 [' |! {! C9 G
4. case "$KEY" in
   
5.         [a-z]|[A-Z])
   
6.                 echo "您输入的是 字母。"
   3 u" v# [7 k1 U0 g; t2 N' D) T, v" g
7.                 ;;
   7 L( t; o/ k, N4 x1 r
8.         [0-9])
   + }/ t  Q) y* }  I
9.                 echo "您输入的是 数字。"
   
10.                 ;;
    % j( X- c6 c: l3 `
11.         *)
    
12.                 echo "您输入的是 空格、功能键或其他控制字符。"
    ! e0 c) J* ~- v9 F
13. esac
    : s8 r  W9 C0 Y# w+ h5 f5 s, r( ~2 Q
14. [root@linuxprobe ~]# bash Checkkeys.sh
    3 V0 S' d, z. p& b
15. 请输入一个字符，并按Enter键确认：6
    
16. 您输入的是 数字。
    
17. [root@linuxprobe ~]# bash Checkkeys.sh
    9 z! E+ u; ~4 Q' n! M7 c
18. 请输入一个字符，并按Enter键确认：p
    1 Z  f+ W; v  g# H' v1 ^
19. 您输入的是 字母。
    1 {# K9 v4 q) j. Q$ f2 m
20. [root@linuxprobe ~]# bash Checkkeys.sh
    4 E1 U! B8 P- L
21. 请输入一个字符，并按Enter键确认：^[[15~
    ( F- V- l$ p: B7 ^, k+ T) Y! c+ F
22. 您输入的是 空格、功能键或其他控制字符。

复制代码

! L$ a) d: m  p1 Z9 b
6 ]8 F5 h. o2 r7 g4.4 计划任务服务程序经验丰富的系统运维工程师可以使得Linux在无须人为介入的情况下，在指定的时间段自动启用或停止某些服务或命令，从而实现运维的自动化。尽管我们现在已经有了功能彪悍的脚本程序来执行一些批处理工作，但是，如果仍然需要在每天凌晨两点敲击键盘回车键来执行这个脚本程序，就太痛苦了（当然，也可以训练您的小猫在半夜按下回车键）。接下来，刘遄老师将向大家讲解如何设置服务器的计划任务服务，把周期性、规律性的工作交给系统自动完成。
计划任务分为一次性计划任务与长期性计划任务，大家可以按照如下方式理解。

一次性计划任务：今晚23:30重启网站服务。
0 ^# j! @# j5 h长期性计划任务：每周一的凌晨3:25把/home/wwwroot目录打包备份为backup.tar.gz。
; z6 U/ u: ?5 e: q) n- c% c5 `

顾名思义，一次性计划任务只执行一次，一般用于临时的工作需求。可以用at命令实现这种功能，只需要写成“at时间”的形式就行。如果想要查看已设置好但还未执行的一次性计划任务，可以使用at -l命令；要想将其删除，可以使用“atrm任务序号”。at命令中的参数及其作用如表4-6所示。
4 p7 a- r) Y# n表4-6                                               at命令的参数及其作用
4 [- |% D5 c0 ], s0 \+ [5 t6 J+ \

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

在使用at命令来设置一次性计划任务时，默认采用的是交互式方法。例如，使用下述命令将系统设置为在今晚23:30自动重启网站服务。

1. [root@linuxprobe ~]# at 23:30
   
2. warning: commands will be executed using /bin/sh
   7 \. W5 K; [& `/ s8 G
3. at> systemctl restart httpd
   
4. at> 此处请同时按下<Ctrl>+<d>键来结束编写计划任务
   
5. job 1 at Wed Oct 14 23:30:00 2020
   2 _( ?3 L: U# R* S. x
6. [root@linuxprobe ~]# at -l
   
7. 1 Wed Oct 14 23:30:00 2020 a root

复制代码

7 Q  W! v! N9 U3 B% `" L  U
1 Z) L$ f' `' }看到warning提醒信息不要慌，at命令只是在告诉我们接下来的任务将由sh解释器负责执行。这与此前学习的Bash解释器基本一致，不需要有额外的操作。
另外，如果大家想挑战一下难度更大但简捷性更高的方式，可以把前面学习的管道符（任意门）放到两条命令之间，让at命令接收前面echo命令的输出信息，以达到通过非交互式的方式创建计划一次性任务的目的。

1. [root@linuxprobe ~]# echo "systemctl restart httpd" | at 23:30
   0 X9 V  ]7 Q. i3 v) k/ g
2. warning: commands will be executed using /bin/sh
     b% M1 O2 j- w8 e! O6 T. J0 m
3. job 2 at Wed Oct 14 23:30:00 2020
     l0 Y/ j( I( E; g
4. [root@linuxprobe ~]# at -l
   
5. 1 Wed Oct 14 23:30:00 2020 a root
   9 _: F6 v( @. H$ x% x
6. 2 Wed Oct 14 23:30:00 2020 a root

复制代码

& v, U8 f( }1 ]' ^& I+ D+ B8 B  l
1 p1 Q- e3 W" a  H8 O上面设置了两条一样的计划任务，可以使用atrm命令轻松删除其中一条：

1. [root@linuxprobe ~]# atrm 2
   % W/ v7 p& o1 q* b( \
2. [root@linuxprobe ~]# at -l
   
3. 1 Wed Oct 14 23:30:00 2020 a root

复制代码

, q6 @$ E- M7 x3 D, o% q3 K, {" f
/ O4 }  Q8 t+ {4 _! Y- j这里还有一种特殊场景—把计划任务写入Shell脚本中，当用户激活该脚本后再开始倒计时执行，而不是像上面那样在固定的时间（“at 23:30”命令）进行。这该怎么办呢？
一般我们会使用“at now +2 MINUTE”的方式进行操作，这表示2分钟（MINUTE）后执行这个任务，也可以将其替代成小时（HOUR）、日（DAY）、月（MONTH）等词汇：
: W$ O, H! y9 Q

1. [root@linuxprobe ~]# at now +2 MINUTE
   6 W, `% e; J& b# W) M$ v  s  X
2. warning: commands will be executed using /bin/sh
   / h/ x* m# \2 y: _1 G
3. at> systemctl restart httpd
   
4. at> 此处请同时按下<Ctrl>+<d>键来结束编写计划任务
   1 y0 \* d, R8 O% _- e+ v
5. job 3 at Wed Oct 14 22:50:00 2020

复制代码

* g1 o2 Q' o8 c; M9 ^. N9 Q

---

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

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

在正式部署计划任务前，请先跟刘遄老师念一下口诀“分、时、日、月、星期 命令”。这是使用crond服务设置任务的参数格式（其格式见表4-8）。需要注意的是，如果有些字段没有被设置，则需要使用星号（*）占位，如图4-24所示。
) L# v9 p* e3 z% ?

图4-24  使用crond设置任务的参数格式

表4-8                                       使用crond设置任务的参数字段说明

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

% h  M! P, v5 o6 U- N; z; t9 ^) j! i( v! P假设在每周一、三、五的凌晨3:25，都需要使用tar命令把某个网站的数据目录进行打包处理，使其作为一个备份文件。我们可以使用crontab -e命令来创建计划任务，为自己创建计划任务时无须使用-u参数。crontab –e命令的具体实现效果和crontab -l命令的结果如下所示：
9 ]: S6 i, b; J3 K! G2 ~

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

复制代码

需要说明的是，除了用逗号（,）来分别表示多个时间段，例如“8,9,12”表示8月、9月和12月。还可以用减号（-）来表示一段连续的时间周期（例如字段“日”的取值为“12-15”，则表示每月的12～15日）。还可以用除号（/）表示执行任务的间隔时间（例如“*/2”表示每隔2分钟执行一次任务）。
3 U+ n; ]( n6 V  L) X$ T如果在crond服务中需要同时包含多条计划任务的命令语句，应每行仅写一条。例如我们再添加一条计划任务，它的功能是每周一至周五的凌晨1点自动清空/tmp目录内的所有文件。尤其需要注意的是，在crond服务的计划任务参数中，所有命令一定要用绝对路径的方式来写，如果不知道绝对路径，请用whereis命令进行查询。rm命令的路径为下面输出信息中的加粗部分。

1. [root@linuxprobe ~]# whereis rm
   + C, `, b! z  t2 R2 E6 x
2. rm: /usr/bin/rm /usr/share/man/man1/rm.1.gz /usr/share/man/man1p/rm.1p.gz
   4 ~. S. q# `; [0 X
3. [root@linuxprobe ~]# crontab -e
   , n# E( |& _- e& @7 H/ L" N. O; S
4. crontab: installing new crontab
   , E6 n% J$ Q8 J
5. [root@linuxprobe ~]# crontab -l
     V2 n" l5 W) _! `2 g5 m4 B! i
6. 25 3 * * 1,3,5 /usr/bin/tar -czvf backup.tar.gz /home/wwwroot
   
7. 0  1 * * 1-5   /usr/bin/rm -rf /tmp/*

复制代码

9 U$ C- r5 R4 w: Y* K
. p& Y: Q$ u  h. O总结一下使用计划服务的注意事项。

在crond服务的配置参数中，一般会像Shell脚本那样以#号开头写上注释信息，这样在日后回顾这段命令代码时可以快速了解其功能、需求以及编写人员等重要信息。
! Y. ?2 y' l3 l2 s1 x6 w: Y计划任务中的“分”字段必须有数值，绝对不能为空或是*号，而“日”和“星期”字段不能同时使用，否则就会发生冲突。
' `% L3 I6 d* g

删除crond计划任务则非常简单，直接使用crontab -e命令进入编辑界面，删除里面的文本信息即可。也可以使用crontab -r命令直接进行删除：
, F8 ?/ T$ J8 M. {& U4 F

1. [root@linuxprobe ~]# crontab -r
   4 D5 e1 ?) g3 J! r3 Z) I
2. [root@linuxprobe ~]# crontab -l
   
3. no crontab for root

复制代码

' e7 G6 [$ }2 k/ S! K' h
最后再啰唆一句，想必读者也已经发现了，诸如crond在内的很多服务默认调用的是Vim编辑器，相信大家现在能进一步体会到在Linux系统中掌握Vim文本编辑器的好处了吧。所以请大家一定要在彻底掌握Vim编码器之后再学习下一章。
" ~# I" E( \6 K( r/ c  v% e: K' R