你好，欢迎来到「Linux Shell脚本」学习专题，你将享受到免费的 Shell 编程资料，以及很棒的浏览体验。

这套 Shell 脚本学习指南针对初学者编写，它通俗易懂，深入浅出，不仅讲解了基本知识，还深入底层原理，能让你在 1 天时间内快速了解 Shell（当然，要想深入学习还得假以时日）。

Shell 既是一个连接用户和 linux 内核的程序，又是一门管理 Linux 系统的脚本语言。Shell 脚本虽然没有C++、Python、Java、C#等编程语言强大，但也支持了基本的编程元素，这是本教程要重点讲解的。

带有  $ 符号的为高级教程，能够让大家认识到 Shell 的本质，并掌握一些“黑科技”。

第一部分：Shell基础（开胃菜）一

欢迎来到 Linux Shell 的世界，在真正开始 Linux Shell 编程之前，先让我们简单地了解一下 Shell 的基本知识，以便为我们接下来的学习打下一个好的基础。

学习完本章，你能对 Shell 有一个初步的了解，比如 Shell 是什么，有哪些？Shell 命令是什么？

一、Shell是什么？1分钟理解Shell的概念！

现在我们使用的操作系统（Windows、Mac OS、Android、iOS 等）都是带图形界面的，简单直观，容易上手，对专业用户（程序员、网管等）和普通用户（家庭主妇、老年人等）都非常适用；计算机的普及离不开图形界面。

然而在计算机的早期并没有图形界面，我们只能通过一个一个地命令来控制计算机，这些命令有成百上千之多，且不说记住这些命令非常困难，每天面对没有任何色彩的“黑屏”本身就是一件枯燥的事情；这个时候的计算机还远远谈不上炫酷和普及，只有专业人员才能使用。

对于图形界面，用户点击某个图标就能启动某个程序；对于命令行，用户输入某个程序的名字（可以看做一个命令）就能启动某个程序。这两者的基本过程都是类似的，都需要查找程序在硬盘上的安装位置，然后将它们加载到内存运行。

换句话说，图形界面和命令行要达到的目的是一样的，都是让用户控制计算机。

然而，真正能够控制计算机硬件（CPU、内存、显示器等）的只有操作系统内核（Kernel），图形界面和命令行只是架设在用户和内核之间的一座桥梁。

如果你不了解操作系统的作用，请转到《Linux简介：操作系统是什么》。

由于安全、复杂、繁琐等原因，用户不能直接接触内核（也没有必要），需要另外再开发一个程序，让用户直接使用这个程序；该程序的作用就是接收用户的操作（点击图标、输入命令），并进行简单的处理，然后再传递给内核，这样用户就能间接地使用操作系统内核了。你看，在用户和内核之间增加一层“代理”，既能简化用户的操作，又能保障内核的安全，何乐不为呢？

用户界面和命令行就是这个另外开发的程序，就是这层“代理”。在Linux下，这个命令行程序叫做 Shell。

Shell 是一个应用程序，它连接了用户和 Linux 内核，让用户能够更加高效、安全、低成本地使用 Linux 内核，这就是 Shell 的本质。

Shell 本身并不是内核的一部分，它只是站在内核的基础上编写的一个应用程序，它和 QQ、迅雷、Firefox 等其它软件没有什么区别。然而 Shell 也有着它的特殊性，就是开机立马启动，并呈现在用户面前；用户通过 Shell 来使用 Linux，不启动 Shell 的话，用户就没办法使用 Linux。

1、Shell 是如何连接用户和内核的？

Shell 能够接收用户输入的命令，并对命令进行处理，处理完毕后再将结果反馈给用户，比如输出到显示器、写入到文件等，这就是大部分读者对 Shell 的认知。你看，我一直都在使用 Shell，哪有使用内核哦？我也没有看到 Shell 将我和内核连接起来呀？！

其实，Shell 程序本身的功能是很弱的，比如文件操作、输入输出、进程管理等都得依赖内核。我们运行一个命令，大部分情况下 Shell 都会去调用内核暴露出来的接口，这就是在使用内核，只是这个过程被 Shell 隐藏了起来，它自己在背后默默进行，我们看不到而已。

接口其实就是一个一个的函数，使用内核就是调用这些函数。这就是使用内核的全部内容了吗？嗯，是的！除了函数，你没有别的途径使用内核。

比如，我们都知道在 Shell 中输入cat log.txt命令就可以查看 log.txt 文件中的内容，然而，log.txt 放在磁盘的哪个位置？分成了几个数据块？在哪里开始？在哪里终止？如何操作探头读取它？这些底层细节 Shell 统统不知道的，它只能去调用内核提供的 open() 和 read() 函数，告诉内核我要读取 log.txt 文件，请帮助我，然后内核就乖乖地按照 Shell 的吩咐去读取文件了，并将读取到的文件内容交给 Shell，最后再由 Shell 呈现给用户（其实呈现到显示器上还得依赖内核）。整个过程中 Shell 就是一个“中间商”，它在用户和内核之间“倒卖”数据，只是用户不知道罢了。

2、Shell 还能连接其它程序

在 Shell 中输入的命令，有一部分是 Shell 本身自带的，这叫做内置命令；有一部分是其它的应用程序（一个程序就是一个命令），这叫做外部命令。

Shell 本身支持的命令并不多，功能也有限，但是 Shell 可以调用其他的程序，每个程序就是一个命令，这使得 Shell 命令的数量可以无限扩展，其结果就是 Shell 的功能非常强大，完全能够胜任 Linux 的日常管理工作，如文本或字符串检索、文件的查找或创建、大规模软件的自动部署、更改系统设置、监控服务器性能、发送报警邮件、抓取网页内容、压缩文件等。

更加惊讶的是，Shell 还可以让多个外部程序发生连接，在它们之间很方便地传递数据，也就是把一个程序的输出结果传递给另一个程序作为输入。

大家所说的 Shell 强大，并不是 Shell 本身功能丰富，而是它擅长使用和组织其他的程序。Shell 就是一个领导者，这正是 Shell 的魅力所在。

可以将 Shell 在整个 Linux 系统中的地位描述成下图所示的样子。注意“用户”和“其它应用程序”是通过虚线连接的，因为用户启动 Linux 后直接面对的是 Shell，通过 Shell 才能运行其它的应用程序。

Shell 并不是简单的堆砌命令，我们还可以在 Shell 中编程，这和使用C++、C#、Java、Python 等常见的编程语言并没有什么两样。

Shell 虽然没有 C++、Java、Python 等强大，但也支持了基本的编程元素，例如：

• if...else 选择结构，case...in 开关语句，for、while、until 循环；
• 变量、数组、字符串、注释、加减乘除、逻辑运算等概念；
• 函数，包括用户自定义的函数和内置函数（例如 printf、export、eval 等）。

站在这个角度讲，Shell 也是一种编程语言，它的编译器（解释器）是 Shell 这个程序。我们平时所说的 Shell，有时候是指连接用户和内核的这个程序，有时候又是指 Shell 编程。

Shell 主要用来开发一些实用的、自动化的小工具，而不是用来开发具有复杂业务逻辑的中大型软件，例如检测计算机的硬件参数、搭建 Web 运行环境、日志分析等，Shell 都非常合适。

使用 Shell 的熟练程度反映了用户对 Linux 的掌握程度，运维工程师、网络管理员、程序员都应该学习 Shell。

尤其是 Linux 运维工程师，Shell 更是必不可少的，是必须掌握的技能，它使得我们能够自动化地管理服务器集群，否则你就得一个一个地登录所有的服务器，对每一台服务器都进行相同的设置，而这些服务器可能有成百上千之多，会浪费大量的时间在重复性的工作上。

4、Shell 是一种脚本语言

任何代码最终都要被“翻译”成二进制的形式才能在计算机中执行。

有的编程语言，如 C/C++、Pascal、Go语言、汇编等，必须在程序运行之前将所有代码都翻译成二进制形式，也就是生成可执行文件，用户拿到的是最终生成的可执行文件，看不到源码。

这个过程叫做编译（Compile），这样的编程语言叫做编译型语言，完成编译过程的软件叫做编译器（Compiler）。

而有的编程语言，如 Shell、JavaScript、Python、php等，需要一边执行一边翻译，不会生成任何可执行文件，用户必须拿到源码才能运行程序。程序运行后会即时翻译，翻译完一部分执行一部分，不用等到所有代码都翻译完。

这个过程叫做解释，这样的编程语言叫做解释型语言或者脚本语言（Script），完成解释过程的软件叫做解释器。

编译型语言的优点是执行速度快、对硬件要求低、保密性好，适合开发操作系统、大型应用程序、数据库等。

脚本语言的优点是使用灵活、部署容易、跨平台性好，非常适合 Web 开发以及小工具的制作。

Shell 就是一种脚本语言，我们编写完源码后不用编译，直接运行源码即可。

二、Shell是运维人员必须掌握的技能

Linux 运维人员就是负责 Linux 服务器的运行和维护。随着互联网的爆发，Linux 运维在最近几年也迎来了春天，出现了大量的职位需求，催生了一批 Linux 运维培训班。

如今的 IT 服务器领域是 Linux、UNIX、Windows 三分天下，Linux 系统可谓后起之秀，特别是“互联网热”以来，Linux 在服务器端的市场份额不断扩大，每年增长势头迅猛，开始对 Windows 和 UNIX 的地位构成严重威胁。

下图是 2016 年初国内服务器端各个操作系统的市场份额：

• 安装操作系统，例如 CentOS、Ubuntu 等。
• 部署代码运行环境，例如网站后台语言采用 PHP，就需要安装 Nginx、Apache、MySQL、PHP 运行时等。
• 及时修复漏洞，防止服务器被攻击，这包括 Linux 本身漏洞以及各个软件的漏洞。
• 根据项目需求升级软件，例如 PHP 7.0 在性能方面获得了重大突破，如果现在服务器压力比较大，就可以考虑将旧版的 PHP 5.x 升级到 PHP 7.0。
• 监控服务器压力，别让服务器宕机。例如淘宝双十一的时候就会瞬间涌入大量用户，导致部分服务器宕机，网页没法访问，甚至连支付宝都不能使用。
• 分析日志，及时发现代码或者环境的问题，通知相关人员修复。

这些任务只要登录远程服务器，或者去机房连接服务器（下图所示）就能够完成，为什么要用 Shell 编程呢？

因为 OPS 面对的是成千上万台的服务器，不是十台八台，你总不能把同样的工作重复成千上万遍吧，那时估计黄花菜都凉了，市场也成一片红海了。

服务器一旦多了，这些人力工作都需要自动化起来，跑一段代码就能在成千上万台服务器上完成相同的工作，例如服务的监控、代码快速部署、服务启动停止、数据备份、日志分析等。

Shell 脚本很适合处理纯文本类型的数据，而 Linux 中几乎所有的配置文件、日志文件（如 NFS、Rsync、Httpd、Nginx、MySQL 等），以及绝大多数的启动文件都是纯文本类型的文件。

下面的手链形象地展示了 Shell 在运维工作中的地位：

1、Shell、python 和 Perl

除了 Shell，能够用于 Linux 运维的脚本语言还有 Python 和 Perl。

（1）Perl 语言

Perl 比 Shell 强大很多，在 2010 年以前很流行，它的语法灵活、复杂，在实现不同的功能时可以用多种不同的方式，缺点是不易读，团队协作困难。

Perl 脚本已经成为历史了，现在的 Linux 运维人员几乎不需要了解 Perl 了，最多可以了解一下 Perl 的安装环境。

（2） Python 语言

Python 是近几年非常流行的语言，它不但可以用于脚本程序开发，也可以实现 Web 程序开发（知乎、豆瓣、YouTube、Instagram 都是用 Python 开发），甚至还可以实现软件的开发（大名鼎鼎的 OpenStack、SaltStack 都是 Python 语言开发）、游戏开发、大数据开发、移动端开发。

现在越来越多的公司要求运维人员会 Python 自动化开发，Python 也成了运维人员必备的技能，每一个运维人员在熟悉了 Shell 之后，都应该再学习 Python 语言。

（3）Shell

Shell 脚本的优势在于处理偏操作系统底层的业务，例如，Linux 内部的很多应用（有的是应用的一部分）都是使用 Shell 脚本开发的，因为有 1000 多个 Linux 系统命令为它作支撑，特别是 Linux 正则表达式以及三剑客 grep、awk、sed 等命令。

对于一些常见的系统脚本，使用 Shell 开发会更简单、更快速，例如，让软件一键自动化安装、优化，监控报警脚本，软件启动脚本，日志分析脚本等，虽然 Python 也能做到这些，但是考虑到掌握难度、开发效率、开发习惯等因素，它们可能就不如 Shell 脚本流行以及有优势了。对于一些常见的业务应用，使用 Shell 更符合 Linux 运维简单、易用、高效的三大原则。

Python 语言的优势在于开发复杂的运维软件、Web 页面的管理工具和 Web 业务的开发（例如 CMDB 自动化运维平台、跳板机、批量管理软件 SaltStack、云计算OpenStack 软件）等。

我们在开发一个应用时，应该根据业务需求，结合不同语言的优势以及自己擅长的语言来选择，扬长避短，从而达到高效开发、易于自己维护的目的。

三、常用的Shell有哪些？

Linux 是一个开源的操作系统，由分布在世界各地的多个组织机构或个人共同开发完成，每个组织结构或个人负责一部分功能，最后组合在一起，就构成了今天的 Linux。例如：

• Linux 内核最初由芬兰黑客 Linus Torvalds 开发，后来他组建了团队，Linux 内核由这个团队维护。
• GNU 组织开发了很多核心软件和基础库，例如 GCC 编译器、C语言标准库、文本编辑器 Emacs、进程管理软件、Shell 以及 GNOME 桌面环境等。
• VIM 编辑器由荷兰人 Bram Moolenaar 开发。

Windows、Mac OS、Android 等操作系统不一样，它们都由一家公司开发，所有的核心软件和基础库都由一家公司做决定，容易形成统一的标准，一般不会开发多款功能类似的软件。

而 Linux 不一样，它是“万国牌”，由多个组织机构开发，不同的组织机构为了发展自己的 Linux 分支可能会开发出功能类似的软件，它们各有优缺点，用户可以自由选择。Shell 就是这样的一款软件，不同的组织机构开发了不同的 Shell，它们各有所长，有的占用资源少，有的支持高级编程功能，有的兼容性好，有的重视用户体验。

Shell 既是一种脚本编程语言，也是一个连接内核和用户的软件。

常见的 Shell 有 sh、bash、csh、tcsh、ash 等。

1、sh

sh 的全称是 Bourne shell，由 AT&T 公司的 Steve Bourne开发，为了纪念他，就用他的名字命名了。

sh 是 UNIX 上的标准 shell，很多 UNIX 版本都配有 sh。sh 是第一个流行的 Shell。

2、csh

sh 之后另一个广为流传的 shell 是由柏克莱大学的 Bill Joy 设计的，这个 shell 的语法有点类似C语言，所以才得名为 C shell ，简称为 csh。

Bill Joy 是一个风云人物，他创立了 BSD 操作系统，开发了 vi 编辑器，还是 Sun 公司的创始人之一。

BSD 是 UNIX 的一个重要分支，后人在此基础上发展出了很多现代的操作系统，最著名的有 FreeBSD、OpenBSD 和 NetBSD，就连 Mac OS X 在很大程度上也基于BSD。

3、tcsh

tcsh 是 csh 的增强版，加入了命令补全功能，提供了更加强大的语法支持。

4、ash

一个简单的轻量级的 Shell，占用资源少，适合运行于低内存环境，但是与下面讲到的 bash shell 完全兼容。

5、bash

bash shell 是 Linux 的默认 shell，本教程也基于 bash 编写。

bash 由 GNU 组织开发，保持了对 sh shell 的兼容性，是各种 Linux 发行版默认配置的 shell。

bash 兼容 sh 意味着，针对 sh 编写的 Shell 代码可以不加修改地在 bash 中运行。

尽管如此，bash 和 sh 还是有一些不同之处：

• 一方面，bash 扩展了一些命令和参数；
• 另一方面，bash 并不完全和 sh 兼容，它们有些行为并不一致，但在大多数企业运维的情况下区别不大，特殊场景可以使用 bash 代替 sh。

6、查看 Shell

Shell 是一个程序，一般都是放在/bin或者/usr/bin目录下，当前 Linux 系统可用的 Shell 都记录在/etc/shells文件中。/etc/shells是一个纯文本文件，你可以在图形界面下打开它，也可以使用 cat 命令查看它。

通过 cat 命令来查看当前 Linux 系统的可用 Shell：

$ cat /etc/shells
/bin/sh
/bin/bash
/sbin/nologin
/usr/bin/sh
/usr/bin/bash
/usr/sbin/nologin
/bin/tcsh
/bin/csh

在现代的 Linux 上，sh 已经被 bash 代替，/bin/sh往往是指向/bin/bash的符号链接。

如果你希望查看当前 Linux 的默认 Shell，那么可以输出 SHELL 环境变量：

$ echo $SHELL
/bin/bash

输出结果表明默认的 Shell 是 bash。

echo是一个 Shell 命令，用来输出变量的值。SHELL是 Linux 系统中的环境变量，它指明了当前使用的 Shell 程序的位置，也就是使用的哪个 Shell。

四、进入Shell的两种方式

在 Linux 发展的早期，唯一能用的工具就是 Shell，Linux 用户都是在 Shell 中输入文本命令，并查看文本输出；如果有必要的话，Shell 也能显示一些基本的图形。

而如今 Linux 的环境已经完全不同，几乎所有的 Linux 发行版都使用某种图形桌面环境（例如 GNOME、KDE、Unity 等），这使得原生的 Shell 入口被隐藏了，进入 Shell 仿佛变得困难起来。

1、进入 Linux 控制台

一种进入 Shell 的方法是让 Linux 系统退出图形界面模式，进入控制台模式，这样一来，显示器上只有一个简单的带着白色文字的“黑屏”，就像图形界面出现之前的样子。这种模式称为 Linux 控制台（Console）。

现代 Linux 系统在启动时会自动创建几个虚拟控制台（Virtual Console），其中一个供图形桌面程序使用，其他的保留原生控制台的样子。虚拟控制台其实就是 Linux 系统内存中运行的虚拟终端（Virtual Terminal）。

从图形界面模式进入控制台模式也很简单，往往按下Ctrl + Alt + Fn(n=1,2,3,4,5...)快捷键就能够来回切换。

例如，CentOS 在启动时会创建 6 个虚拟控制台，按下快捷键Ctrl + Alt + Fn(n=2,3,4,5,6)可以从图形界面模式切换到控制台模式，按下Ctrl + Alt + F1可以从控制台模式再切换回图形界面模式。也就是说，1 号控制台被图形桌面程序占用了。

下图就是进入了控制台模式：

在图形界面模式下，输入密码时往往会显示为 *，密码有几个字符就显示几个 *；而 在控制台模式下，输入密码什么都不会显示，好像按键无效一样，这一点请大家不要惊慌，只要输入的密码正确就能够登录。

图形界面也是一个程序，会占用 CPU 时间和内存空间，当 Linux 作为服务器系统时，安装调试完毕后，应该让 Linux 运行在控制台模式下，以节省服务器资源。正是由于这个原因，很多服务器甚至不安装图形界面程序，管理员只能使用命令来完成各项操作。

2、使用终端

进入 Shell 的另外一种方法是使用Linux桌面环境中的终端模拟包（Terminal emulation package），也就是我们常说的终端（Terminal），这样在图形桌面中就可以使用 Shell。

以 CentOS 为例，可以在“应用程序”菜单中找到终端，如下图所示：

打开终端后，就可以输入 Shell 命令了：

• xterm 终端

  最古老最基础的 X Windows 桌面程序自带的终端模拟包就是 xterm。xterm 在 X Windows 出现之前便已经存在了，默认包含在大多数 X Windows 中。xterm 虽然没有太多炫目的特性，但是运行它不需要太多的资源，所以 xterm 在针对老硬件设计的 Linux 发行版中仍然很常见，比如 fluxbox 图形桌面环境就用它作为默认的终端模拟包。

• Konsole 终端

  KDE 桌面项目也开发了自己的终端模拟包，名为 Konsole。Konsole 整合了基本的 xterm 特性以及一些更高级的类似 Windows 应用程序的特性。

五、Linux Shell命令的基本格式

进入 Shell 以后，我们就可以输入命令来使用 Linux 的各种功能了，但是在真正使用 Shell 命令之前，我们有必要先学习一下 Shell 命令的基本格式。

进入 Shell 以后第一眼看到的内容类似下面这种形式：

[mozhiyan@localhost ~]$

这叫做命令提示符，看见它就意味着可以输入命令了。命令提示符不是命令的一部分，它只是起到一个提示作用。

Shell 命令的基本格式如下：

command [选项] [参数]

[]表示可选的，也就是可有可无。有些命令不写选项和参数也能执行，有些命令在必要的时候可以附带选项和参数。

ls 是常用的一个命令，它属于目录操作命令，用来列出当前目录下的文件和文件夹。ls 可以附带选项，也可以不带，不带选项的写法为：

[mozhiyan@localhost ~]$ cd demo

[mozhiyan@localhost demo]$ ls

abc              demo.sh    a.out            demo.txt

getsum        main.sh     readme.txt   a.sh

module.sh   log.txt        test.sh          main.c

先执行cd demo命令进入 demo 目录，这是我在自己的主目录下创建的文件夹，用来保存教学使用的各种代码和数据。

接着执行 ls 命令，它列出了 demo 目录下的所有文件，并且进行了格式对齐。

1、使用选项

ls 命令之后不加选项和参数也能执行，不过只能执行最基本的功能，即显示当前目录下的文件名。那么加入一个选项，会出现什么结果？

[mozhiyan@localhost demo]$ ls -l

总用量 140

-rwxrwxr-x. 1 mozhiyan mozhiyan 8675 4月 2 15:01 a.out

-rwxr-xr-x. 1 mozhiyan mozhiyan 116 4月 3 09:24 a.sh

-rw-rw-r--. 1 mozhiyan mozhiyan 44 4月 2 16:41 check.sh

-rw-r--r--. 1 mozhiyan mozhiyan 399 3月 11 17:12 demo.sh

-rw-rw-r--. 1 mozhiyan mozhiyan 4 4月 8 17:56 demo.txt

-rw-rw-r--. 1 mozhiyan mozhiyan 0 4月 15 17:26 log.txt

-rw-rw-r--. 1 mozhiyan mozhiyan 650 4月 10 11:06 main.c

-rwxrwxr-x. 1 mozhiyan mozhiyan 69 3月 26 10:13 main.sh

-rw-rw-r--. 1 mozhiyan mozhiyan 111 3月 26 09:56 module.sh

-rw-rw-r--. 1 mozhiyan mozhiyan 352 3月 22 17:40 out.log

-rw-rw-r--. 1 mozhiyan mozhiyan 61 4月 16 11:19 output.txt

-rw-r--r--. 1 mozhiyan mozhiyan 5 4月 11 15:16 readme.txt

-rwxr-xr-x. 1 mozhiyan mozhiyan 88 4月 15 17:23 test.sh

如果加一个-l选项，则可以看到显示的内容明显增多了。-l是长格式（long list）的意思，也就是显示文件的详细信息。

可以看到，选项的作用是调整命令功能。如果没有选项，那么命令只能执行最基本的功能；而一旦有选项，则能执行更多功能，或者显示更加丰富的数据。

短格式选项和长格式选项

Linux 的选项又分为短格式选项和长格式选项。

• 短格式选项是长格式选项的简写，用一个减号-和一个字母表示，例如ls -l。
• 长格式选项是完整的英文单词，用两个减号--和一个单词表示，例如ls --all。

一般情况下，短格式选项是长格式选项的缩写，也就是一个短格式选项会有对应的长格式选项。当然也有例外，比如 ls 命令的短格式选项-l就没有对应的长格式选项，所以具体的命令选项还需要通过帮助手册来查询。

2、使用参数

参数是命令的操作对象，一般情况下，文件、目录、用户和进程等都可以作为参数被命令操作。例如：

[mozhiyan@localhost demo]$ ls -l main.c

-rw-rw-r--. 1 mozhiyan mozhiyan 650 4月 10 11:06 main.c

但是为什么一开始 ls 命令可以省略参数？那是因为有默认参数。命令一般都需要加入参数，用于指定命令操作的对象是谁。如果可以省略参数，则一般都有默认参数。例如 ls：

[mozhiyan@localhost ~]$ cd demo

[mozhiyan@localhost demo]$ ls

abc              demo.sh    a.out            demo.txt

getsum        main.sh     readme.txt   a.sh

module.sh   log.txt        test.sh          main.c

这个 ls 命令后面如果没有指定参数的话，默认参数是当前所在位置，所以会显示当前目录下的文件名。

选项和参数一起使用

Shell 命令可以同时附带选项和参数，例如：

[mozhiyan@localhost ~]$ echo "http://c.biancheng.net/shell/"

http://c.biancheng.net/shell/

[mozhiyan@localhost ~]$ echo -n "http://c.biancheng.net/shell/"

http://c.biancheng.net/shell/[mozhiyan@localhost ~]$

-n是 echo 命令的选项，"http://c.biancheng.net/shell/"是 echo 命令的参数，它们被同时用于 echo 命令。

echo 命令用来输出一个字符串，默认输出完成后会换行；给它增加-n选项，就不会换行了。

3、选项附带的参数

有些命令的选项后面也可以附带参数，这些参数用来补全选项，或者调整选项的功能细节。

例如，read 命令用来读取用户输入的数据，并把读取到的数据赋值给一个变量，它通常的用法为：

read str

str 为变量名。

如果我们只是想读取固定长度的字符串，那么可以给 read 命令增加-n选项。比如读取一个字符作为性别的标志，那么可以这样写：

read -n 1 sex

1是-n选项的参数，sex是 read 命令的参数。

-n选项表示读取固定长度的字符串，那么它后面必然要跟一个数字用来指明长度，否则选项是不完整的。

4、总结

Shell 命令的选项用于调整命令功能，而命令的参数是这个命令的操作对象。有些选项后面也需要附带参数，以补全命令的功能。

六、Shell命令的本质到底是什么？如何自己实现一个命令？

《一、Shell是什么》一节中讲到，用户通过在 Shell 中输入一些命令来使用 Linux。给命令附带不同的选项后，同一个命令的功能也会有所差异。

Shell 命令分为两种：

• Shell 自带的命令称为内置命令，它在 Shell 内部可以通过函数来实现，当 Shell 启动后，这些命令所对应的代码（函数体代码）也被加载到内存中，所以使用内置命令是非常快速的。
• 更多的命令是外部的应用程序，一个命令就对应一个应用程序。运行外部命令要开启一个新的进程，所以效率上比内置命令差很多。

用户输入一个命令后，Shell 先检测该命令是不是内置命令，如果是就执行，如果不是就检测有没有对应的外部程序：有的话就转而执行外部程序，执行结束后再回到 Shell；没有的话就报错，告诉用户该命令不存在。

1、内置命令

内置命令不宜过多，过多的内置命令会导致 Shell 程序本身体积膨胀，运行 Shell 程序后就会占用更多的内存。Shell 是一个常驻内存的程序，占用过多内存会影响其它的程序。

只有那些最常用的命令才有理由成为内置命令，比如 cd、kill、echo 等。

2、外部命令

外部命令可能是读者比较疑惑的，一个外部的应用程序究竟是如何变成一个 Shell 命令的呢？

应用程序就是一个文件，只不过这个文件是可以执行的。既然是文件，那么它就有一个名字，并且存放在文件系统中。用户在 Shell 中输入一个外部命令后，只是将可执行文件的名字告诉了 Shell，但是并没有告诉 Shell 去哪里寻找这个文件。

难道 Shell 要遍历整个文件系统，查看每个目录吗？这显然是不能实现的。

为了解决这个问题，Shell 在启动文件中增加了一个叫做 PATH 的环境变量，该变量就保存了 Shell 对外部命令的查找路径，如果在这些路径下找不到同名的文件，Shell 也不会再去其它路径下查找了，它就直接报错。PATH 变量保存了检索路径。

我们使用 echo 命令输出 PATH 变量的值，看看它保存了哪些检索路径：

[mozhiyan@localhost ~]$ echo $PATH

/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin:/home/mozhiyan/.local/bin:/home/mozhiyan/bin

不同的路径之间以:分隔。你看，Shell 只会在几个固定的路径中查找外部命令。

如果我们自己用C语言或者 C++ 编写一个应用程序，并将它放到这几个目录下面，那么我们的程序也会成为 Shell 命令。当然，你也可以修改 PATH 变量给它增加另外的路径，不过这并不是本文的重点。

我自己使用C语言编写了一个叫做 getsum 的程序，它用来计算从 m 累加到 n 的和，代码如下：

#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
    int start = 0;
    int end = 0;
    int sum = 0;
    int opt;
    char *optstring = ":s:e:";

    while((opt = getopt(argc, argv, optstring))!= -1){
        switch(opt){
            case 's': start = atoi(optarg); break;
            case 'e': end = atoi(optarg); break;
            case ':': puts("Missing parameter"); exit(1);
        }
    }
   
    if(start<0 || end<=start){
        puts("Parameter error"); exit(2);
    }
   
    for(int i=start; i<=end; i++){
        sum+=i;
    }
    printf("%d\n", sum);

    return 0;
}

将这段代码编译成名为 getsum 的应用程序，并放在~/bin目录（~ 表示用户主目录）下，然后在 Shell 中输入下面的命令，就可以计算 1+2+3 ...... +99+100 的值。

[mozhiyan@localhost ~]$ getsum -s 1 -e 100

5050

-s选项表示起始数字，-e选项表示终止数字。

对于不了解C语言的读者，我也提供了编译好的 getsum 程序，请猛击这里下载。

3、总结

Shell 内置命令的本质是一个自带的函数，执行内置命令就是调用这个自带的函数。因为函数代码在 Shell 启动时已经被加载到内存了，所以内置命令的执行速度很快。

Shell 外部命令的本质是一个应用程序，执行外部命令就是启动一个新的应用程序。因为要创建新的进程并加载应用程序的代码，所以外部命令的执行速度很慢。

七、Shell命令的选项和参数在本质上到底是什么？

很多 Shell 命令都是可以附带选项和参数的，不同的选项和参数也使得命令的功能细节有所差异。

Shell 命令附带参数的例子：

• cd demo命令表示进入当前目录下的 demo 目录，其中demo就是 cd 命令的参数。
• echo "123xyz"命令表示输出字符串并换行，其中"123xyz"就是 echo 命令的参数。

Shell 命令附带选项的例子：
ls -l命令用来显示当前目录下的所有文件以及它们的详细信息，其中-l就是 ls 命令的选项。
echo -n "http://c.biancheng.net/shell/"表示在输出字符串后不换行，其中-n是 echo 命令的选项，"http://c.biancheng.net/shell/"是 echo 命令的参数。

有些命令的选项后面也可以附带参数：

• getsum -s 1 -e 100命令用来计算从 1 累加到 100 的和，其中-s和-e是 getsum 命令的选项，1和100分别是-s和-e选项的参数。
• read -n 1 sex命令用来读取一个字符并赋值给 sex 变量，其中-n是 read 命令的选项，1是-n选项的参数，sex是 read 命令的参数。

你是否对这些形形色色的选项和参数感到好奇？你是否想知道它们在底层是如何实现的？你是否也想自己动手对它们进行解析？本节就来给你揭晓答案！

死磕这个细节并不是闲得无聊，它能帮助我们理解命令的真正含义。好了，废话不多说，让我们赶紧转入正题吧。

上节我们讲到，一个 Shell 内置命令就是一个内部的函数，一个外部命令就是一个应用程序。内置命令后面附带的所有数据（所有选项和参数）最终都以参数的形式传递给了函数，外部命令后面附带的所有数据（所有选项和参数）最终都以参数的形式传递给了应用程序。

也就是说，不管是内置命令还是外部命令，它后面附带的所有数据都会被“打包”成参数，这些参数有的传递给了函数，有的传递给了应用程序。

有编程经验的读者应该知道，C语言或者 C++ 程序的入口函数是int main(int argc, char *argv[])，传递给应用程序的参数最终都被 main 函数接收了。从这个角度看，传递给应用程序的参数其实也是传递给了函数。

有了以上认知，我们就不用再区分函数和应用程序了，我们就认为：不管是内置命令还是外部命令，它后面附带的数据最终都以参数的形式传递给了函数。实现一个命令的一项重要工作就是解析传递给函数的参数。

注意，命令后面附带的数据并不是被合并在一起，作为一个参数传递给函数的；这些数据是由空格分隔的，它们被分隔成了几份，就会转换成几个参数。例如getsum -s 1 -e 100要向函数传递四个参数，read -n 1 sex要向函数中传递三个参数。

并且，命令后面附带的数据都是“原汁原味”地传递给了函数，比如getsum -s 1 -e 100要传递的四个参数分别是 -s、1、-e、100，减号-也会一起传递过去，在函数内部，减号-可以用来区分该参数是否是命令的选项。

至于在函数内部如何解析这些参数，对于外部命令来说那就是 C/C++ 程序员的工作了，这里不再过多赘述，只给出演示代码。

上节我给大家演示了一个 getsum 程序，本节依然使用该程序演示参数的解析，只是对代码进行了微调。

#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
    int start = 0;
    int end = 0;
    int sum = 0;
    int opt;
    char *optstring = ":s:e:";

    //分析接收到的参数
    while((opt = getopt(argc, argv, optstring))!= -1){
        switch(opt){
            case 's': start = atoi(optarg); break;
            case 'e': end = atoi(optarg); break;
            case ':': puts("Missing parameter"); exit(1);
        }
    }
   
    //检测参数是否有效
    if(start<0 || end<=start){
        puts("Parameter error"); exit(2);
    }
   
    //打印接收到的参数
    printf("Received parameters: ");
    for(int i=0; i<argc; i++){
        printf("%s  ", argv[i]);
    }
    printf("\n");
   
    //计算累加的和
    for(int i=start; i<=end; i++){
        sum+=i;
    }
    printf("sum=%d\n", sum);

    return 0;
}

第 11~20 行是解析参数的关键代码，getopt.h 头文件中的 getopt() 函数是值得重点研究的，有了该函数我们就不用自己去解析参数了，省了很大的力气。

第 27~32 行将接收到的参数打印出来，以便读者更好地观察。

根据上节给出的办法就可以运行 getsum 命令：

[mozhiyan@localhost ~]$ getsum -s 1 -e 100

Received parameters: getsum -s 1 -e 100

sum=5050