开始学习Bash(上)
内容参考阮一峰的Bash脚本教程
可恶,内容好多,我复制粘贴一下吧,真的感觉都是精华(T^T)
1.Bash 简介
Bash 是 Unix 系统和 Linux 系统的一种 Shell（命令行环境），是目前绝大多数 Linux 发行版的默认 Shell。
Shell 的含义
学习 Bash，首先需要理解 Shell 是什么。Shell 这个单词的原意是“外壳”，跟 kernel（内核）相对应，比喻内核外面的一层，即用户跟内核交互的对话界面。
具体来说，Shell 这个词有多种含义。
首先，Shell 是一个程序，提供一个与用户对话的环境。这个环境只有一个命令提示符，让用户从键盘输入命令，所以又称为命令行环境（command line interface，简写为 CLI）。Shell 接收到用户输入的命令，将命令送入操作系统执行，并将结果返回给用户。本书中，除非特别指明，Shell 指的就是命令行环境。
其次，Shell 是一个命令解释器，解释用户输入的命令。它支持变量、条件判断、循环操作等语法，所以用户可以用 Shell 命令写出各种小程序，又称为脚本（script）。这些脚本都通过 Shell 的解释执行，而不通过编译。
最后，Shell 是一个工具箱，提供了各种小工具，供用户方便地使用操作系统的功能。
Shell 的种类
Shell 有很多种，只要能给用户提供命令行环境的程序，都可以看作是 Shell。
历史上，主要的 Shell 有下面这些。
- Bourne Shell（sh）
- Bourne Again shell（bash）
- C Shell（csh）
- TENEX C Shell（tcsh）
- Korn shell（ksh）
- Z Shell（zsh）
- Friendly Interactive Shell（fish）
Bash 是目前最常用的 Shell，除非特别指明，下文的 Shell 和 Bash 当作同义词使用，可以互换。
下面的命令可以查看当前设备默认的 Shell。
$ echo $SHELL
/bin/bash
当前正在使用的 Shell 不一定是默认 Shell，一般来说，ps命令结果的倒数第二行是当前 Shell。
$ ps
PID TTY TIME CMD
4467 pts/0 00:00:00 bash
5379 pts/0 00:00:00 ps
上面示例中，ps命令结果的倒数第二行显示，运行的命令（cmd）是bash，表明当前正在使用的
Shell 是 Bash。
下面的命令可以查看当前的 Linux 系统安装的所有 Shell。
$ cat /etc/shells
上面三个命令中，$是命令行环境的提示符，用户只需要输入提示符后面的内容。
Linux 允许每个用户使用不同的 Shell，用户的默认 Shell 一般都是 Bash，或者与 Bash 兼容。
命令行环境
终端模拟器
如果是不带有图形环境的 Linux 系统（比如专用于服务器的系统），启动后就直接是命令行环境。
不过，现在大部分的 Linux 发行版，尤其是针对普通用户的发行版，都是图形环境。用户登录系统后，自动进入图形环境，需要自己启动终端模拟器，才能进入命令行环境。
所谓“终端模拟器”（terminal emulator）就是一个模拟命令行窗口的程序，让用户在一个窗口中使用命令行环境，并且提供各种附加功能，比如调整颜色、字体大小、行距等等。
不同 Linux 发行版（准确地说是不同的桌面环境）带有的终端程序是不一样的，比如 KDE 桌面环境的终端程序是 konsole，Gnome 桌面环境的终端程序是 gnome-terminal，用户也可以安装第三方的终端程序。所有终端程序，尽管名字不同，基本功能都是一样的，就是让用户可以进入命令行环境，使用 Shell。
命令行提示符
进入命令行环境以后，用户会看到 Shell 的提示符。提示符往往是一串前缀，最后以一个美元符号$结尾，用户可以在这个符号后面输入各种命令。
[user@hostname] $
上面例子中，完整的提示符是[user@hostname] $，其中前缀是用户名（user）加上@，再加主机名（hostname）。比如，用户名是bill，主机名是home-machine，前缀就是bill@home-machine。
注意，根用户（root）的提示符，不以美元符号（$）结尾，而以井号（#）结尾，用来提醒用户，现在具有根权限，可以执行各种操作，务必小心，不要出现误操作。这个符号是可以自己定义的，详见《命令提示符》一章。
为了简洁，后文的命令行提示符都只使用$表示。
进入和退出方法
进入命令行环境以后，一般就已经打开 Bash 了。如果你的 Shell 不是 Bash，可以输入bash命令启动 Bash。
$ bash
退出 Bash 环境，可以使用exit命令，也可以同时按下Ctrl + d。
$ exit
Bash 的基本用法就是在命令行输入各种命令，非常直观。作为练习，可以试着输入pwd命令。按下回车键，就会显示当前所在的目录。
$ pwd
/home/me
如果不小心输入了pwe，会返回一个提示，表示输入出错，没有对应的可执行程序。
$ pwe
bash: pwe：未找到命令
Shell 和 Bash 的历史
Shell 伴随着 Unix 系统的诞生而诞生。
1969年，Ken Thompson 和 Dennis Ritchie 开发了第一版的 Unix。
1971年，Ken Thompson 编写了最初的 Shell，称为 Thompson shell，程序名是sh，方便用户使用 Unix。
1973年至1975年间，John R. Mashey 扩展了最初的 Thompson shell，添加了编程功能，使得 Shell 成为一种编程语言。这个版本的 Shell 称为 Mashey shell。
1976年，Stephen Bourne 结合 Mashey shell 的功能，重写一个新的 Shell，称为 Bourne shell。
1978年，加州大学伯克利分校的 Bill Joy 开发了 C shell，为 Shell 提供 C 语言的语法，程序名是csh。它是第一个真正替代sh的 UNIX shell，被合并到 Berkeley UNIX 的 2BSD 版本中。
1979年，UNIX 第七版发布，内置了 Bourne Shell，导致它成为 Unix 的默认 Shell。注意，Thompson shell、Mashey shell 和 Bourne shell 都是贝尔实验室的产品，程序名都是sh。对于用户来说，它们是同一个东西，只是底层代码不同而已。
1983年，David Korn 开发了Korn shell，程序名是ksh。
1985年，Richard Stallman 成立了自由软件基金会（FSF），由于 Shell 的版权属于贝尔公司，所以他决定写一个自由版权的、使用 GNU 许可证的 Shell 程序，避免 Unix 的版权争议。
1988年，自由软件基金会的第一个付薪程序员 Brian Fox 写了一个 Shell，功能基本上是 Bourne shell 的克隆，叫做 Bourne-Again SHell，简称 Bash，程序名为bash，任何人都可以免费使用。后来，它逐渐成为 Linux 系统的标准 Shell。
1989年，Bash 发布1.0版。
1996年，Bash 发布2.0版。
2004年，Bash 发布3.0版。
2009年，Bash 发布4.0版。
2019年，Bash 发布5.0版。
用户可以通过bash命令的--version参数或者环境变量$BASH_VERSION，查看本机的 Bash 版本。
$ bash --version
GNU bash，版本 5.0.3(1)-release (x86_64-pc-linux-gnu)
# 或者
$ echo $BASH_VERSION
5.0.3(1)-release
2.Bash 的基本语法
本章介绍 Bash 的最基本语法。
echo 命令
由于后面的例子会大量用到echo命令，这里先介绍这个命令。
echo命令的作用是在屏幕输出一行文本，可以将该命令的参数原样输出。
$ echo hello world
hello world
上面例子中，echo的参数是hello world，可以原样输出。
如果想要输出的是多行文本，即包括换行符。这时就需要把多行文本放在引号里面。
$ echo "<HTML>
<HEAD>
<TITLE>Page Title</TITLE>
</HEAD>
<BODY>
Page body.
</BODY>
</HTML>"
上面例子中，echo可以原样输出多行文本。
-n参数
默认情况下，echo输出的文本末尾会有一个回车符。-n参数可以取消末尾的回车符，使得下一个提示符紧跟在输出内容的后面。
$ echo -n hello world
hello world$
上面例子中，world后面直接就是下一行的提示符$。
$ echo a;echo b
a
b
$ echo -n a;echo b
ab
上面例子中，-n参数可以让两个echo命令的输出连在一起，出现在同一行。
-e参数
-e参数会解释引号（双引号和单引号）里面的特殊字符（比如换行符\n）。如果不使用-e参数，即默认情况下，引号会让特殊字符变成普通字符，echo不解释它们，原样输出。
$ echo "Hello\nWorld"
Hello\nWorld
# 双引号的情况
$ echo -e "Hello\nWorld"
Hello
World
# 单引号的情况
$ echo -e 'Hello\nWorld'
Hello
World
上面代码中，-e参数使得\n解释为换行符，导致输出内容里面出现换行。
命令格式
命令行环境中，主要通过使用 Shell 命令，进行各种操作。Shell 命令基本都是下面的格式。
$ command [ arg1 ... [ argN ]]
上面代码中，command是具体的命令或者一个可执行文件，arg1 ... argN是传递给命令的参数，它们是可选的。
$ ls -l
上面这个命令中，ls是命令，-l是参数。
有些参数是命令的配置项，这些配置项一般都以一个连词线开头，比如上面的-l。同一个配置项往往有长和短两种形式，比如-l是短形式，--list是长形式，它们的作用完全相同。短形式便于手动输入，长形式一般用在脚本之中，可读性更好，利于解释自身的含义。
# 短形式
$ ls -r
# 长形式
$ ls --reverse
上面命令中，-r是短形式，--reverse是长形式，作用完全一样。前者便于输入，后者便于理解。
Bash 单个命令一般都是一行，用户按下回车键，就开始执行。有些命令比较长，写成多行会有利于阅读和编辑，这时可以在每一行的结尾加上反斜杠，Bash 就会将下一行跟当前行放在一起解释。
$ echo foo bar
# 等同于
$ echo foo \
bar
空格
Bash 使用空格（或 Tab 键）区分不同的参数。
$ command foo bar
上面命令中，foo和bar之间有一个空格，所以 Bash 认为它们是两个参数。
如果参数之间有多个空格，Bash 会自动忽略多余的空格。
$ echo this is a test
this is a test
上面命令中，a和test之间有多个空格，Bash 会忽略多余的空格。
分号
分号（;）是命令的结束符，使得一行可以放置多个命令，上一个命令执行结束后，再执行第二个命令。
$ clear; ls
上面例子中，Bash 先执行clear命令，执行完成后，再执行ls命令。
注意，使用分号时，第二个命令总是接着第一个命令执行，不管第一个命令执行成功或失败。
命令的组合符&&和||
除了分号，Bash 还提供两个命令组合符&&和||，允许更好地控制多个命令之间的继发关系。
Command1 && Command2
上面命令的意思是，如果Command1命令运行成功，则继续运行Command2命令。
Command1 || Command2
上面命令的意思是，如果Command1命令运行失败，则继续运行Command2命令。
下面是一些例子。
$ cat filelist.txt ; ls -l filelist.txt
上面例子中，只要cat命令执行结束，不管成功或失败，都会继续执行ls命令。
$ cat filelist.txt && ls -l filelist.txt
上面例子中，只有cat命令执行成功，才会继续执行ls命令。如果cat执行失败（比如不存在文件flielist.txt），那么ls命令就不会执行。
$ mkdir foo || mkdir bar
上面例子中，只有mkdir foo命令执行失败（比如foo目录已经存在），才会继续执行mkdir bar命令。如果mkdir foo命令执行成功，就不会创建bar目录了。
type 命令
Bash 本身内置了很多命令，同时也可以执行外部程序。怎么知道一个命令是内置命令，还是外部程序呢？
type命令用来判断命令的来源。
$ type echo
echo is a shell builtin
$ type ls
ls is hashed (/bin/ls)
上面代码中，type命令告诉我们，echo是内部命令，ls是外部程序（/bin/ls）。
type命令本身也是内置命令。
$ type type
type is a shell builtin
如果要查看一个命令的所有定义，可以使用type命令的-a参数。
$ type -a echo
echo is shell builtin
echo is /usr/bin/echo
echo is /bin/echo
上面代码表示，echo命令既是内置命令，也有对应的外部程序。
type命令的-t参数，可以返回一个命令的类型：别名（alias），关键词（keyword），函数（function），内置命令（builtin）和文件（file）。
$ type -t bash
file
$ type -t if
keyword
上面例子中，bash是文件，if是关键词。
快捷键
Bash 提供很多快捷键，可以大大方便操作。下面是一些最常用的快捷键，完整的介绍参见《行操作》一章。
Ctrl + L：清除屏幕并将当前行移到页面顶部。Ctrl + C：中止当前正在执行的命令。Shift + PageUp：向上滚动。Shift + PageDown：向下滚动。Ctrl + U：从光标位置删除到行首。Ctrl + K：从光标位置删除到行尾。Ctrl + W：删除光标位置前一个单词。Ctrl + D：关闭 Shell 会话。↑，↓：浏览已执行命令的历史记录。
除了上面的快捷键，Bash 还具有自动补全功能。命令输入到一半的时候，可以按下 Tab 键，Bash 会自动完成剩下的部分。比如，输入tou，然后按一下 Tab 键，Bash 会自动补上ch。
除了命令的自动补全，Bash 还支持路径的自动补全。有时，需要输入很长的路径，这时只需要输入前面的部分，然后按下 Tab 键，就会自动补全后面的部分。如果有多个可能的选择，按两次 Tab 键，Bash 会显示所有选项，让你选择。
3.Bash 的模式扩展
简介
Shell 接收到用户输入的命令以后，会根据空格将用户的输入，拆分成一个个词元（token）。然后，Shell 会扩展词元里面的特殊字符，扩展完成后才会调用相应的命令。
这种特殊字符的扩展，称为模式扩展（globbing）。其中有些用到通配符，又称为通配符扩展（wildcard expansion）。Bash 一共提供八种扩展。
- 波浪线扩展
?字符扩展*字符扩展- 方括号扩展
- 大括号扩展
- 变量扩展
- 子命令扩展
- 算术扩展
本章介绍这八种扩展。
Bash 是先进行扩展，再执行命令。因此，扩展的结果是由 Bash 负责的，与所要执行的命令无关。命令本身并不存在参数扩展，收到什么参数就原样执行。这一点务必需要记住。
模块扩展的英文单词是globbing，这个词来自于早期的 Unix 系统有一个/etc/glob文件，保存扩展的模板。后来 Bash 内置了这个功能，但是这个名字就保留了下来。
模式扩展与正则表达式的关系是，模式扩展早于正则表达式出现，可以看作是原始的正则表达式。它的功能没有正则那么强大灵活，但是优点是简单和方便。
Bash 允许用户关闭扩展。
$ set -o noglob
# 或者
$ set -f
下面的命令可以重新打开扩展。
$ set +o noglob
# 或者
$ set +f
波浪线扩展
波浪线~会自动扩展成当前用户的主目录。
$ echo ~
/home/me
~/dir表示扩展成主目录的某个子目录，dir是主目录里面的一个子目录名。
# 进入 /home/me/foo 目录
$ cd ~/foo
~user表示扩展成用户user的主目录。
$ echo ~foo
/home/foo
$ echo ~root
/root
上面例子中，Bash 会根据波浪号后面的用户名，返回该用户的主目录。
如果~user的user是不存在的用户名，则波浪号扩展不起作用。
$ echo ~nonExistedUser
~nonExistedUser
~+会扩展成当前所在的目录，等同于pwd命令。
$ cd ~/foo
$ echo ~+
/home/me/foo
? 字符扩展
?字符代表文件路径里面的任意单个字符，不包括空字符。比如，Data???匹配所有Data后面跟着三个字符的文件名。
# 存在文件 a.txt 和 b.txt
$ ls ?.txt
a.txt b.txt
上面命令中，?表示单个字符，所以会同时匹配a.txt和b.txt。
如果匹配多个字符，就需要多个?连用。
# 存在文件 a.txt、b.txt 和 ab.txt
$ ls ??.txt
ab.txt
上面命令中，??匹配了两个字符。
? 字符扩展属于文件名扩展，只有文件确实存在的前提下，才会发生扩展。如果文件不存在，扩展就不会发生。
# 当前目录有 a.txt 文件
$ echo ?.txt
a.txt
# 当前目录为空目录
$ echo ?.txt
?.txt
上面例子中，如果?.txt可以扩展成文件名，echo命令会输出扩展后的结果；如果不能扩展成文件名，echo就会原样输出?.txt。
* 字符扩展
*字符代表文件路径里面的任意数量的任意字符，包括零个字符。
# 存在文件 a.txt、b.txt 和 ab.txt
$ ls *.txt
a.txt b.txt ab.txt
上面例子中，*.txt代表后缀名为.txt的所有文件。
如果想输出当前目录的所有文件，直接用*即可。
$ ls *
*可以匹配空字符，下面是一个例子。
# 存在文件 a.txt、b.txt 和 ab.txt
$ ls a*.txt
a.txt ab.txt
$ ls *b*
b.txt ab.txt
注意，*不会匹配隐藏文件（以.开头的文件），即ls *不会输出隐藏文件。
如果要匹配隐藏文件，需要写成.*。
# 显示所有隐藏文件
$ echo .*
如果要匹配隐藏文件，同时要排除.和..这两个特殊的隐藏文件，可以与方括号扩展结合使用，写成.[!.]*。
$ echo .[!.]*
注意，*字符扩展属于文件名扩展，只有文件确实存在的前提下才会扩展。如果文件不存在，就会原样输出。
# 当前目录不存在 c 开头的文件
$ echo c*.txt
c*.txt
上面例子中，当前目录里面没有c开头的文件，导致c*.txt会原样输出。
*只匹配当前目录，不会匹配子目录。
# 子目录有一个 a.txt
# 无效的写法
$ ls *.txt
# 有效的写法
$ ls */*.txt
上面的例子，文本文件在子目录，*.txt不会产生匹配，必须写成*/*.txt。有几层子目录，就必须写几层星号。
Bash 4.0 引入了一个参数globstar，当该参数打开时，允许**匹配零个或多个子目录。因此，**/*.txt可以匹配顶层的文本文件和任意深度子目录的文本文件。详细介绍请看后面shopt命令的介绍。
方括号扩展
方括号扩展的形式是[...]，只有文件确实存在的前提下才会扩展。如果文件不存在，就会原样输出。括号之中的任意一个字符。比如，[aeiou]可以匹配五个元音字母中的任意一个。
# 存在文件 a.txt 和 b.txt
$ ls [ab].txt
a.txt b.txt
# 只存在文件 a.txt
$ ls [ab].txt
a.txt
上面例子中，[ab]可以匹配a或b，前提是确实存在相应的文件。
方括号扩展属于文件名匹配，即扩展后的结果必须符合现有的文件路径。如果不存在匹配，就会保持原样，不进行扩展。
# 不存在文件 a.txt 和 b.txt
$ ls [ab].txt
ls: 无法访问'[ab].txt': 没有那个文件或目录
上面例子中，由于扩展后的文件不存在，[ab].txt就原样输出了，导致ls命名报错。
方括号扩展还有两种变体：[^...]和[!...]。它们表示匹配不在方括号里面的字符，这两种写法是等价的。比如，[^abc]或[!abc]表示匹配除了a、b、c以外的字符。
# 存在 aaa、bbb、aba 三个文件
$ ls ?[!a]?
aba bbb
上面命令中，[!a]表示文件名第二个字符不是a的文件名，所以返回了aba和bbb两个文件。
注意，如果需要匹配[字符，可以放在方括号内，比如[[aeiou]。如果需要匹配连字号-，只能放在方括号内部的开头或结尾，比如[-aeiou]或[aeiou-]。
[start-end] 扩展
方括号扩展有一个简写形式[start-end]，表示匹配一个连续的范围。比如，[a-c]等同于[abc]，[0-9]匹配[0123456789]。
# 存在文件 a.txt、b.txt 和 c.txt
$ ls [a-c].txt
a.txt
b.txt
c.txt
# 存在文件 report1.txt、report2.txt 和 report3.txt
$ ls report[0-9].txt
report1.txt
report2.txt
report3.txt
...
下面是一些常用简写的例子。
[a-z]：所有小写字母。[a-zA-Z]：所有小写字母与大写字母。[a-zA-Z0-9]：所有小写字母、大写字母与数字。[abc]*：所有以a、b、c字符之一开头的文件名。program.[co]：文件program.c与文件program.o。BACKUP.[0-9][0-9][0-9]：所有以BACKUP.开头，后面是三个数字的文件名。
这种简写形式有一个否定形式[!start-end]，表示匹配不属于这个范围的字符。比如，[!a-zA-Z]表示匹配非英文字母的字符。
$ ls report[!1–3].txt
report4.txt report5.txt
上面代码中，[!1-3]表示排除1、2和3。
大括号扩展
大括号扩展{...}表示分别扩展成大括号里面的所有值，各个值之间使用逗号分隔。比如，{1,2,3}扩展成1 2 3。
$ echo {1,2,3}
1 2 3
$ echo d{a,e,i,u,o}g
dag deg dig dug dog
$ echo Front-{A,B,C}-Back
Front-A-Back Front-B-Back Front-C-Back
注意，大括号扩展不是文件名扩展。它会扩展成所有给定的值，而不管是否有对应的文件存在。
$ ls {a,b,c}.txt
ls: 无法访问'a.txt': 没有那个文件或目录
ls: 无法访问'b.txt': 没有那个文件或目录
ls: 无法访问'c.txt': 没有那个文件或目录
上面例子中，即使不存在对应的文件，{a,b,c}依然扩展成三个文件名，导致ls命令报了三个错误。
另一个需要注意的地方是，大括号内部的逗号前后不能有空格。否则，大括号扩展会失效。
$ echo {1 , 2}
{1 , 2}
上面例子中，逗号前后有空格，Bash 就会认为这不是大括号扩展，而是三个独立的参数。
逗号前面可以没有值，表示扩展的第一项为空。
$ cp a.log{,.bak}
# 等同于
# cp a.log a.log.bak
大括号可以嵌套。
$ echo {j{p,pe}g,png}
jpg jpeg png
$ echo a{A{1,2},B{3,4}}b
aA1b aA2b aB3b aB4b
大括号也可以与其他模式联用，并且总是先于其他模式进行扩展。
$ echo /bin/{cat,b*}
/bin/cat /bin/b2sum /bin/base32 /bin/base64 ... ...
# 基本等同于
$ echo /bin/cat;echo /bin/b*
上面例子中，会先进行大括号扩展，然后进行*扩展，等同于执行两条echo命令。
大括号可以用于多字符的模式，方括号不行（只能匹配单字符）。
$ echo {cat,dog}
cat dog
由于大括号扩展{...}不是文件名扩展，所以它总是会扩展的。这与方括号扩展[...]完全不同，如果匹配的文件不存在，方括号就不会扩展。这一点要注意区分。
# 不存在 a.txt 和 b.txt
$ echo [ab].txt
[ab].txt
$ echo {a,b}.txt
a.txt b.txt
上面例子中，如果不存在a.txt和b.txt，那么[ab].txt就会变成一个普通的文件名，而{a,b}.txt可以照样扩展。
{start..end} 扩展
大括号扩展有一个简写形式{start..end}，表示扩展成一个连续序列。比如，{a..z}可以扩展成26个小写英文字母。
$ echo {a..c}
a b c
$ echo d{a..d}g
dag dbg dcg ddg
$ echo {1..4}
1 2 3 4
$ echo Number_{1..5}
Number_1 Number_2 Number_3 Number_4 Number_5
这种简写形式支持逆序。
$ echo {c..a}
c b a
$ echo {5..1}
5 4 3 2 1
注意，如果遇到无法理解的简写，大括号模式就会原样输出，不会扩展。
$ echo {a1..3c}
{a1..3c}
这种简写形式可以嵌套使用，形成复杂的扩展。
$ echo .{mp{3..4},m4{a,b,p,v}}
.mp3 .mp4 .m4a .m4b .m4p .m4v
大括号扩展的常见用途为新建一系列目录。
$ mkdir {2007..2009}-{01..12}
上面命令会新建36个子目录，每个子目录的名字都是”年份-月份“。
这个写法的另一个常见用途，是直接用于for循环。
for i in {1..4}
do
echo $i
done
上面例子会循环4次。
如果整数前面有前导0，扩展输出的每一项都有前导0。
$ echo {01..5}
01 02 03 04 05
$ echo {001..5}
001 002 003 004 005
这种简写形式还可以使用第二个双点号（start..end..step），用来指定扩展的步长。
$ echo {0..8..2}
0 2 4 6 8
上面代码将0扩展到8，每次递增的长度为2，所以一共输出5个数字。
多个简写形式连用，会有循环处理的效果。(感觉有矩阵内味儿了)
$ echo {a..c}{1..3}
a1 a2 a3 b1 b2 b3 c1 c2 c3
变量扩展
Bash 将美元符号$开头的词元视为变量，将其扩展成变量值，详见《Bash 变量》一章。
$ echo $SHELL
/bin/bash
变量名除了放在美元符号后面，也可以放在${}里面。
$ echo ${SHELL}
/bin/bash
${!string*}或${!string@}返回所有匹配给定字符串string的变量名。
$ echo ${!S*}
SECONDS SHELL SHELLOPTS SHLVL SSH_AGENT_PID SSH_AUTH_SOCK
上面例子中，${!S*}扩展成所有以S开头的变量名。(可!不是一般代表非的意思吗,这里反而变成所有...)
通过后续对变量的解释,明白了这个感叹号表示最终结果的意思.
子命令扩展
$(...)可以扩展成另一个命令的运行结果，该命令的所有输出都会作为返回值。
$ echo $(date)
Tue Jan 28 00:01:13 CST 2020
上面例子中，$(date)返回date命令的运行结果。
还有另一种较老的语法，子命令放在反引号之中，也可以扩展成命令的运行结果。(看来我一直用的这种的写法)
$ echo `date`
Tue Jan 28 00:01:13 CST 2020
$(...)可以嵌套，比如$(ls $(pwd))。(新写法的好处,老写法应该做不到)
算术扩展
$((...))可以扩展成整数运算的结果，详见《Bash 的算术运算》一章。
$ echo $((2 + 2))
4
字符类
[[:class:]]表示一个字符类，扩展成某一类特定字符之中的一个。常用的字符类如下。
[[:alnum:]]：匹配任意英文字母与数字[[:alpha:]]：匹配任意英文字母[[:blank:]]：空格和 Tab 键。[[:cntrl:]]：ASCII 码 0-31 的不可打印字符。[[:digit:]]：匹配任意数字 0-9。[[:graph:]]：A-Z、a-z、0-9 和标点符号。[[:lower:]]：匹配任意小写字母 a-z。[[:print:]]：ASCII 码 32-127 的可打印字符。[[:punct:]]：标点符号（除了 A-Z、a-z、0-9 的可打印字符）。[[:space:]]：空格、Tab、LF（10）、VT（11）、FF（12）、CR（13）。[[:upper:]]：匹配任意大写字母 A-Z。[[:xdigit:]]：16进制字符（A-F、a-f、0-9）。
ASCII码参照表,具体参照这篇文章
| ASCII值 | 控制字符 | ASCII值 | 控制字符 | ASCII值 | 控制字符 | ASCII值 | 控制字符 |
|---|---|---|---|---|---|---|---|
| 0 | NUL | 32 | (space) | 64 | @ | 96 | 、 |
| 1 | SOH | 33 | ！ | 65 | A | 97 | a |
| 2 | STX | 34 | ” | 66 | B | 98 | b |
| 3 | ETX | 35 | # | 67 | C | 99 | c |
| 4 | EOT | 36 | $ | 68 | D | 100 | d |
| 5 | ENQ | 37 | % | 69 | E | 101 | e |
| 6 | ACK | 38 | & | 70 | F | 102 | f |
| 7 | BEL | 39 | ' | 71 | G | 103 | g |
| 8 | BS | 40 | ( | 72 | H | 104 | h |
| 9 | HT | 41 | ) | 73 | I | 105 | i |
| 10 | LF | 42 | * | 74 | J | 106 | j |
| 11 | VT | 43 | + | 75 | K | 107 | k |
| 12 | FF | 44 | , | 76 | L | 108 | l |
| 13 | CR | 45 | - | 77 | M | 109 | m |
| 14 | SO | 46 | . | 78 | N | 110 | n |
| 15 | SI | 47 | / | 79 | O | 111 | o |
| 16 | DLE | 48 | 0 | 80 | P | 112 | p |
| 17 | DCI | 49 | 1 | 81 | Q | 113 | q |
| 18 | DC2 | 50 | 2 | 82 | R | 114 | r |
| 19 | DC3 | 51 | 3 | 83 | X | 115 | s |
| 20 | DC4 | 52 | 4 | 84 | T | 116 | t |
| 21 | NAK | 53 | 5 | 85 | U | 117 | u |
| 22 | SYN | 54 | 6 | 86 | V | 118 | v |
| 23 | TB | 55 | 7 | 87 | W | 119 | w |
| 24 | CAN | 56 | 8 | 88 | X | 120 | x |
| 25 | EM | 57 | 9 | 89 | Y | 121 | y |
| 26 | SUB | 58 | : | 90 | Z | 122 | z |
| 27 | ESC | 59 | ; | 91 | [ | 123 | { |
| 28 | FS | 60 | < | 92 | \ | 124 | | |
| 29 | GS | 61 | = | 93 | ] | 125 | } |
| 30 | RS | 62 | > | 94 | ^ | 126 | ~ |
| 31 | US | 63 | ? | 95 | — | 127 | DEL |
请看下面的例子。
$ echo [[:upper:]]*
上面命令输出所有大写字母开头的文件名。
字符类的第一个方括号后面，可以加上感叹号!，表示否定。比如，[![:digit:]]匹配所有非数字。
$ echo [![:digit:]]*
上面命令输出所有不以数字开头的文件名。
字符类也属于文件名扩展，如果没有匹配的文件名，字符类就会原样输出。
# 不存在以大写字母开头的文件
$ echo [[:upper:]]*
[[:upper:]]*
上面例子中，由于没有可匹配的文件，字符类就原样输出了。
使用注意点
通配符有一些使用注意点，不可不知。
（1）通配符是先解释，再执行。
Bash 接收到命令以后，发现里面有通配符，会进行通配符扩展，然后再执行命令。
$ ls a*.txt
ab.txt
上面命令的执行过程是，Bash 先将a*.txt扩展成ab.txt，然后再执行ls ab.txt。
（2）文件名扩展在不匹配时，会原样输出。
文件名扩展在没有可匹配的文件时，会原样输出。
# 不存在 r 开头的文件名
$ echo r*
r*
上面代码中，由于不存在r开头的文件名，r*会原样输出。
下面是另一个例子。
$ ls *.csv
ls: *.csv: No such file or directory
另外，前面已经说过，大括号扩展{...}不是文件名扩展。
（3）只适用于单层路径。
所有文件名扩展只匹配单层路径，不能跨目录匹配，即无法匹配子目录里面的文件。或者说，?或*这样的通配符，不能匹配路径分隔符（/）。
如果要匹配子目录里面的文件，可以写成下面这样。
$ ls */*.txt
Bash 4.0 新增了一个globstar参数，允许**匹配零个或多个子目录，详见后面shopt命令的介绍。
（4）文件名可以使用通配符。
Bash 允许文件名使用通配符，即文件名包括特殊字符。这时引用文件名，需要把文件名放在单引号或双引号里面。
$ touch 'fo*'
$ ls
fo*
上面代码创建了一个fo*文件，这时*就是文件名的一部分。
量词语法
量词语法用来控制模式匹配的次数。它只有在 Bash 的extglob参数打开的情况下才能使用，不过一般是默认打开的。下面的命令可以查询。
$ shopt extglob
extglob on
如果extglob参数是关闭的，可以用下面的命令打开。
$ shopt -s extglob
量词语法有下面几个。
?(pattern-list)：模式匹配零次或一次。*(pattern-list)：模式匹配零次或多次。+(pattern-list)：模式匹配一次或多次。@(pattern-list)：只匹配一次模式。!(pattern-list)：匹配给定模式以外的任何内容。
$ ls abc?(.)txt
abctxt abc.txt
上面例子中，?(.)匹配零个或一个点。
$ ls abc?(def)
abc abcdef
上面例子中，?(def)匹配零个或一个def。
$ ls abc@(.txt|.php)
abc.php abc.txt
上面例子中，@(.txt|.php)匹配文件有且只有一个.txt或.php后缀名。
$ ls abc+(.txt)
abc.txt abc.txt.txt
上面例子中，+(.txt)匹配文件有一个或多个.txt后缀名。
$ ls a!(b).txt
a.txt abb.txt ac.txt
上面例子中，!(b)表示匹配单个字母b以外的任意内容，所以除了ab.txt以外，其他文件名都能匹配。
量词语法也属于文件名扩展，如果不存在可匹配的文件，就会原样输出。
# 没有 abc 开头的文件名
$ ls abc?(def)
ls: 无法访问'abc?(def)': 没有那个文件或目录
上面例子中，由于没有可匹配的文件，abc?(def)就原样输出，导致ls命令报错。
shopt 命令
shopt命令可以调整 Bash 的行为。它有好几个参数跟通配符扩展有关。
shopt命令的使用方法如下。
# 打开某个参数
$ shopt -s [optionname]
# 关闭某个参数
$ shopt -u [optionname]
# 查询某个参数关闭还是打开
$ shopt [optionname]
（1）dotglob 参数
dotglob参数可以让扩展结果包括隐藏文件（即点开头的文件）。
正常情况下，扩展结果不包括隐藏文件。
$ ls *
abc.txt
打开dotglob，就会包括隐藏文件。
$ shopt -s dotglob
$ ls *
abc.txt .config
（2）nullglob 参数
nullglob参数可以让通配符不匹配任何文件名时，返回空字符。
默认情况下，通配符不匹配任何文件名时，会保持不变。
$ rm b*
rm: 无法删除'b*': 没有那个文件或目录
上面例子中，由于当前目录不包括b开头的文件名，导致b*不会发生文件名扩展，保持原样不变，所以rm命令报错没有b*这个文件。
打开nullglob参数，就可以让不匹配的通配符返回空字符串。
$ shopt -s nullglob
$ rm b*
rm: 缺少操作数
上面例子中，由于没有b*匹配的文件名，所以rm b*扩展成了rm，导致报错变成了”缺少操作数“。
（3）failglob 参数
failglob参数使得通配符不匹配任何文件名时，Bash 会直接报错，而不是让各个命令去处理。
$ shopt -s failglob
$ rm b*
bash: 无匹配: b*
上面例子中，打开failglob以后，由于b*不匹配任何文件名，Bash 直接报错了，不再让rm命令去处理。
（4）extglob 参数
extglob参数使得 Bash 支持 ksh 的一些扩展语法。它默认应该是打开的。
$ shopt extglob
extglob on
它的主要应用是支持量词语法。如果不希望支持量词语法，可以用下面的命令关闭。
$ shopt -u extglob
（5）nocaseglob 参数
nocaseglob参数可以让通配符扩展不区分大小写。
$ shopt -s nocaseglob
$ ls /windows/program*
/windows/ProgramData
/windows/Program Files
/windows/Program Files (x86)
上面例子中，打开nocaseglob以后，program*就不区分大小写了，可以匹配ProgramData等。
（6）globstar 参数
globstar参数可以使得**匹配零个或多个子目录。该参数默认是关闭的。
假设有下面的文件结构。
a.txt
sub1/b.txt
sub1/sub2/c.txt
上面的文件结构中，顶层目录、第一级子目录sub1、第二级子目录sub1\sub2里面各有一个文本文件。请问怎样才能使用通配符，将它们显示出来？
默认情况下，只能写成下面这样。
$ ls *.txt */*.txt */*/*.txt
a.txt sub1/b.txt sub1/sub2/c.txt
这是因为*只匹配当前目录，如果要匹配子目录，只能一层层写出来。
打开globstar参数以后，**匹配零个或多个子目录。因此，**/*.txt就可以得到想要的结果。
$ shopt -s globstar
$ ls **/*.txt
a.txt sub1/b.txt sub1/sub2/c.txt
参考链接
4.引号和转义
Bash 只有一种数据类型，就是字符串。不管用户输入什么数据，Bash 都视为字符串。因此，字符串相关的引号和转义，对 Bash 来说就非常重要。
转义
某些字符在 Bash 里面有特殊含义（比如$、&、*）。
$ echo $date
$
上面例子中，输出$date不会有任何结果，因为$是一个特殊字符。
如果想要原样输出这些特殊字符，就必须在它们前面加上反斜杠，使其变成普通字符。这就叫做“转义”（escape）。
$ echo \$date
$date
上面命令中，只有在特殊字符$前面加反斜杠，才能原样输出。
反斜杠本身也是特殊字符，如果想要原样输出反斜杠，就需要对它自身转义，连续使用两个反斜线（\\）。
$ echo \\
\
上面例子输出了反斜杠本身。
反斜杠除了用于转义，还可以表示一些不可打印的字符。
\a：响铃\b：退格\n：换行\r：回车\t：制表符
如果想要在命令行使用这些不可打印的字符，可以把它们放在引号里面，然后使用echo命令的-e参数。
$ echo a\tb
atb
$ echo -e "a\tb"
a b
上面例子中，命令行直接输出不可打印字符\t，Bash 不能正确解释。必须把它们放在引号之中，然后使用echo命令的-e参数。
换行符是一个特殊字符，表示命令的结束，Bash 收到这个字符以后，就会对输入的命令进行解释执行。换行符前面加上反斜杠转义，就使得换行符变成一个普通字符，Bash 会将其当作长度为0的空字符处理，从而可以将一行命令写成多行。
$ mv \
/path/to/foo \
/path/to/bar
# 等同于
$ mv /path/to/foo /path/to/bar
上面例子中，如果一条命令过长，就可以在行尾使用反斜杠，将其改写成多行。这是常见的多行命令的写法。
单引号
Bash 允许字符串放在单引号或双引号之中，加以引用。
单引号用于保留字符的字面含义，各种特殊字符在单引号里面，都会变为普通字符，比如星号（*）、美元符号（$）、反斜杠（\）等。
$ echo '*'
*
$ echo '$USER'
$USER
$ echo '$((2+2))'
$((2+2))
$ echo '$(echo foo)'
$(echo foo)
上面命令中，单引号使得 Bash 扩展、变量引用、算术运算和子命令，都失效了。如果不使用单引号，它们都会被 Bash 自动扩展。
由于反斜杠在单引号里面变成了普通字符，所以如果单引号之中，还要使用单引号，不能使用转义，需要在外层的单引号前面加上一个美元符号（$），然后再对里层的单引号转义。
# 不正确
$ echo it's
# 不正确
$ echo 'it\'s'
# 正确
$ echo $'it\'s'
不过，更合理的方法是改在双引号之中使用单引号。
$ echo "it's"
it's
双引号
双引号比单引号宽松，大部分特殊字符在双引号里面，都会失去特殊含义，变成普通字符。
$ echo "*"
*
上面例子中，通配符*是一个特殊字符，放在双引号之中，就变成了普通字符，会原样输出。这一点需要特别留意，这意味着，双引号里面不会进行文件名扩展。
但是，三个特殊字符除外：美元符号（$）、反引号（`）和反斜杠（\）。这三个字符在双引号之中，依然有特殊含义，会被 Bash 自动扩展。
$ echo "$SHELL"
/bin/bash
$ echo "`date`"
Mon Jan 27 13:33:18 CST 2020
上面例子中，美元符号（$）和反引号（`）在双引号中，都保持特殊含义。美元符号用来引用变量，反引号则是执行子命令。
$ echo "I'd say: \"hello!\""
I'd say: "hello!"
$ echo "\\"
\
上面例子中，反斜杠在双引号之中保持特殊含义，用来转义。所以，可以使用反斜杠，在双引号之中插入双引号，或者插入反斜杠本身。
换行符在双引号之中，会失去特殊含义，Bash 不再将其解释为命令的结束，只是作为普通的换行符。所以可以利用双引号，在命令行输入多行文本。
$ echo "hello
world"
hello
world
上面命令中，Bash 正常情况下会将换行符解释为命令结束，但是换行符在双引号之中就失去了这种特殊作用，只用来换行，所以可以输入多行。echo命令会将换行符原样输出，显示的时候正常解释为换行。
双引号的另一个常见的使用场合是，文件名包含空格。这时就必须使用双引号（或单引号），将文件名放在里面。
$ ls "two words.txt"
上面命令中，two words.txt是一个包含空格的文件名，如果不放在双引号里面，就会被 Bash 当作两个文件。
双引号会原样保存多余的空格。
$ echo "this is a test"
this is a test
双引号还有一个作用，就是保存原始命令的输出格式。
# 单行输出
$ echo $(cal)
一月 2020 日 一 二 三 四 五 六 1 2 3 ... 31
# 原始格式输出
$ echo "$(cal)"
一月 2020
日 一 二 三 四 五 六
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
上面例子中，如果$(cal)不放在双引号之中，echo就会将所有结果以单行输出，丢弃了所有原始的格式。
Here 文档
Here 文档（here document）是一种输入多行字符串的方法，格式如下。
<< token
text
token
它的格式分成开始标记（<< token）和结束标记（token）。开始标记是两个小于号 + Here 文档的名称，名称可以随意取，后面必须是一个换行符；结束标记是单独一行顶格写的 Here 文档名称，如果不是顶格，结束标记不起作用。两者之间就是多行字符串的内容。
下面是一个通过 Here 文档输出 HTML 代码的例子。
$ cat << _EOF_
<html>
<head>
<title>
The title of your page
</title>
</head>
<body>
Your page content goes here.
</body>
</html>
_EOF_
Here 文档内部会发生变量替换，同时支持反斜杠转义，但是不支持通配符扩展，双引号和单引号也失去语法作用，变成了普通字符。
$ foo='hello world'
$ cat << _example_
$foo
"$foo"
'$foo'
_example_
hello world
"hello world"
'hello world'
上面例子中，变量$foo发生了替换，但是双引号和单引号都原样输出了，表明它们已经失去了引用的功能。
如果不希望发生变量替换，可以把 Here 文档的开始标记放在单引号之中。
$ foo='hello world'
$ cat << '_example_'
$foo
"$foo"
'$foo'
_example_
$foo
"$foo"
'$foo'
上面例子中，Here 文档的开始标记（_example_）放在单引号之中，导致变量替换失效了。
Here 文档的本质是重定向，它将字符串重定向输出给某个命令，相当于包含了echo命令。
$ command << token
string
token
# 等同于
$ echo string | command
上面代码中，Here 文档相当于echo命令的重定向。
所以，Here 字符串只适合那些可以接受标准输入作为参数的命令，对于其他命令无效，比如echo命令就不能用 Here 文档作为参数。
$ echo << _example_
hello
_example_
上面例子不会有任何输出，因为 Here 文档对于echo命令无效。
此外，Here 文档也不能作为变量的值，只能用于命令的参数。
Here 字符串
Here 文档还有一个变体，叫做 Here 字符串（Here string），使用三个小于号（<<<）表示。
<<< string
它的作用是将字符串通过标准输入，传递给命令。
有些命令直接接受给定的参数，与通过标准输入接受参数，结果是不一样的。所以才有了这个语法，使得将字符串通过标准输入传递给命令更方便，比如cat命令只接受标准输入传入的字符串。
$ cat <<< 'hi there'
# 等同于
$ echo 'hi there' | cat
上面的第一种语法使用了 Here 字符串，要比第二种语法看上去语义更好，也更简洁。
$ md5sum <<< 'ddd'
# 等同于
$ echo 'ddd' | md5sum
上面例子中，md5sum命令只能接受标准输入作为参数，不能直接将字符串放在命令后面，会被当作文件名，即md5sum ddd里面的ddd会被解释成文件名。这时就可以用 Here 字符串，将字符串传给md5sum命令。
5.Bash 变量
简介
Bash 变量分成环境变量和自定义变量两类。
环境变量
环境变量是 Bash 环境自带的变量，进入 Shell 时已经定义好了，可以直接使用。它们通常是系统定义好的，也可以由用户从父 Shell 传入子 Shell。
env命令或printenv命令，可以显示所有环境变量。
$ env
# 或者
$ printenv
下面是一些常见的环境变量。
BASHPID：Bash 进程的进程 ID。BASHOPTS：当前 Shell 的参数，可以用shopt命令修改。DISPLAY：图形环境的显示器名字，通常是:0，表示 X Server 的第一个显示器。EDITOR：默认的文本编辑器。HOME：用户的主目录。HOST：当前主机的名称。IFS：词与词之间的分隔符，默认为空格。LANG：字符集以及语言编码，比如zh_CN.UTF-8。PATH：由冒号分开的目录列表，当输入可执行程序名后，会搜索这个目录列表。PS1：Shell 提示符。PS2： 输入多行命令时，次要的 Shell 提示符。PWD：当前工作目录。RANDOM：返回一个0到32767之间的随机数。SHELL：Shell 的名字。SHELLOPTS：启动当前 Shell 的set命令的参数，参见《set 命令》一章。TERM：终端类型名，即终端仿真器所用的协议。UID：当前用户的 ID 编号。USER：当前用户的用户名。
很多环境变量很少发生变化，而且是只读的，可以视为常量。由于它们的变量名全部都是大写，所以传统上，如果用户要自己定义一个常量，也会使用全部大写的变量名。
注意，Bash 变量名区分大小写，HOME和home是两个不同的变量。
查看单个环境变量的值，可以使用printenv命令或echo命令。
$ printenv PATH
# 或者
$ echo $PATH
注意，printenv命令后面的变量名，不用加前缀$。
自定义变量
自定义变量是用户在当前 Shell 里面自己定义的变量，仅在当前 Shell 可用。一旦退出当前 Shell，该变量就不存在了。
set命令可以显示所有变量（包括环境变量和自定义变量），以及所有的 Bash 函数。
$ set
创建变量
用户创建变量的时候，变量名必须遵守下面的规则。
- 字母、数字和下划线字符组成。
- 第一个字符必须是一个字母或一个下划线，不能是数字。
- 不允许出现空格和标点符号。
变量声明的语法如下。
variable=value
上面命令中，等号左边是变量名，右边是变量。注意，等号两边不能有空格。
如果变量的值包含空格，则必须将值放在引号中。
myvar="hello world"
Bash 没有数据类型的概念，所有的变量值都是字符串。
下面是一些自定义变量的例子。
a=z # 变量 a 赋值为字符串 z
b="a string" # 变量值包含空格，就必须放在引号里面
c="a string and $b" # 变量值可以引用其他变量的值
d="\t\ta string\n" # 变量值可以使用转义字符
e=$(ls -l foo.txt) # 变量值可以是命令的执行结果
f=$((5 * 7)) # 变量值可以是数学运算的结果
变量可以重复赋值，后面的赋值会覆盖前面的赋值。
$ foo=1
$ foo=2
$ echo $foo
2
上面例子中，变量foo的第二次赋值会覆盖第一次赋值。
如果同一行定义多个变量，必须使用分号（;）分隔。
$ foo=1;bar=2
上面例子中，同一行定义了foo和bar两个变量。
读取变量
读取变量的时候，直接在变量名前加上$就可以了。
$ foo=bar
$ echo $foo
bar
每当 Shell 看到以$开头的单词时，就会尝试读取这个变量名对应的值。
如果变量不存在，Bash 不会报错，而会输出空字符。
由于$在 Bash 中有特殊含义，把它当作美元符号使用时，一定要非常小心，
$ echo The total is $100.00
The total is 00.00
上面命令的原意是输入$100，但是 Bash 将$1解释成了变量，该变量为空，因此输入就变成了00.00。所以，如果要使用$的原义，需要在$前面放上反斜杠，进行转义。
$ echo The total is \$100.00
The total is $100.00
读取变量的时候，变量名也可以使用花括号{}包围，比如$a也可以写成${a}。这种写法可以用于变量名与其他字符连用的情况。
$ a=foo
$ echo $a_file
$ echo ${a}_file
foo_file
上面代码中，变量名a_file不会有任何输出，因为 Bash 将其整个解释为变量，而这个变量是不存在的。只有用花括号区分$a，Bash 才能正确解读。
事实上，读取变量的语法$foo，可以看作是${foo}的简写形式。
如果变量的值本身也是变量，可以使用${!varname}的语法，读取最终的值。(到这里明白了这个感叹号到底什么意思)
$ myvar=USER
$ echo ${!myvar}
ruanyf
上面的例子中，变量myvar的值是USER，${!myvar}的写法将其展开成最终的值。
如果变量值包含连续空格（或制表符和换行符），最好放在双引号里面读取。
$ a="1 2 3"
$ echo $a
1 2 3
$ echo "$a"
1 2 3
上面示例中，变量a的值包含两个连续空格。如果直接读取，Shell 会将连续空格合并成一个。只有放在双引号里面读取，才能保持原来的格式。
删除变量
unset命令用来删除一个变量。
unset NAME
这个命令不是很有用。因为不存在的 Bash 变量一律等于空字符串，所以即使unset命令删除了变量，还是可以读取这个变量，值为空字符串。
所以，删除一个变量，也可以将这个变量设成空字符串。
$ foo=''
$ foo=
上面两种写法，都是删除了变量foo。由于不存在的值默认为空字符串，所以后一种写法可以在等号右边不写任何值。
输出变量，export 命令
用户创建的变量仅可用于当前 Shell，子 Shell 默认读取不到父 Shell 定义的变量。为了把变量传递给子 Shell，需要使用export命令。这样输出的变量，对于子 Shell 来说就是环境变量。
export命令用来向子 Shell 输出变量。
NAME=foo
export NAME
上面命令输出了变量NAME。变量的赋值和输出也可以在一个步骤中完成。
export NAME=value
上面命令执行后，当前 Shell 及随后新建的子 Shell，都可以读取变量$NAME。
子 Shell 如果修改继承的变量，不会影响父 Shell。
# 输出变量 $foo
$ export foo=bar
# 新建子 Shell
$ bash
# 读取 $foo
$ echo $foo
bar
# 修改继承的变量
$ foo=baz
# 退出子 Shell
$ exit
# 读取 $foo
$ echo $foo
bar
上面例子中，子 Shell 修改了继承的变量$foo，对父 Shell 没有影响。
特殊变量
Bash 提供一些特殊变量。这些变量的值由 Shell 提供，用户不能进行赋值。
（1）$?
$?为上一个命令的退出码，用来判断上一个命令是否执行成功。返回值是0，表示上一个命令执行成功；如果不是零，表示上一个命令执行失败。(感觉还挺好用的)
$ ls doesnotexist
ls: doesnotexist: No such file or directory
$ echo $?
1
上面例子中，ls命令查看一个不存在的文件，导致报错。$?为1，表示上一个命令执行失败。
（2）$$
$$为当前 Shell 的进程 ID。(目前还没感觉到这个变量的用处,我是说,在写脚本的时候)
$ echo $$
10662
这个特殊变量可以用来命名临时文件。
LOGFILE=/tmp/output_log.$$
（3）$_
$_为上一个命令的最后一个参数。
$ grep dictionary /usr/share/dict/words
dictionary
$ echo $_
/usr/share/dict/words
（4）$!
$!为最近一个后台执行的异步命令的进程 ID。
$ firefox &
[1] 11064
$ echo $!
11064
上面例子中，firefox是后台运行的命令，$!返回该命令的进程 ID。
（5）$0
$0为当前 Shell 的名称（在命令行直接执行时）或者脚本名（在脚本中执行时）。
$ echo $0
bash
上面例子中，$0返回当前运行的是 Bash。
（6）$-
$-为当前 Shell 的启动参数。
$ echo $-
himBHs
（7）$@和$#
$#表示脚本的参数数量，$@表示脚本的参数值，参见脚本一章。
(此处我高亮了一下,免得我后面忘了)
变量的默认值
Bash 提供四个特殊语法，跟变量的默认值有关，目的是保证变量不为空。
${varname:-word}
上面语法的含义是，如果变量varname存在且不为空，则返回它的值，否则返回word。它的目的是返回一个默认值，比如${count:-0}表示变量count不存在时返回0。
${varname:=word}
上面语法的含义是，如果变量varname存在且不为空，则返回它的值，否则将它设为word，并且返回word。它的目的是设置变量的默认值，比如${count:=0}表示变量count不存在时返回0，且将count设为0。
${varname:+word}
上面语法的含义是，如果变量名存在且不为空，则返回word，否则返回空值。它的目的是测试变量是否存在，比如${count:+1}表示变量count存在时返回1（表示true），否则返回空值。
${varname:?message}
上面语法的含义是，如果变量varname存在且不为空，则返回它的值，否则打印出varname: message，并中断脚本的执行。如果省略了message，则输出默认的信息“parameter null or not set.”。它的目的是防止变量未定义，比如${count:?"undefined!"}表示变量count未定义时就中断执行，抛出错误，返回给定的报错信息undefined!。
上面四种语法如果用在脚本中，变量名的部分可以用数字1到9，表示脚本的参数。
filename=${1:?"filename missing."}
上面代码出现在脚本中，1表示脚本的第一个参数。如果该参数不存在，就退出脚本并报错。(我还以为...是名字叫"1"的变量...但是想了想,变量是不能以数字开头的😲)
declare 命令(网上说可写作typeset)
declare命令可以声明一些特殊类型的变量，为变量设置一些限制，比如声明只读类型的变量和整数类型的变量。
它的语法形式如下。
declare OPTION VARIABLE=value
declare命令的主要参数（OPTION）如下。
-a：声明数组变量。网上说,没必要用这个参数,所有变量都不必显式定义就可以用作数组,事实上,似乎所有变量都是数组,而且赋值给没有下标的变量与赋值给"[0]"相同。-f：输出所有函数定义。-F：输出所有函数名。-i：声明整数变量。-l：声明变量为小写字母。-p：查看变量信息。-r：声明只读变量。-u：声明变量为大写字母。-x：该变量输出为环境变量。
declare命令如果用在函数中，声明的变量只在函数内部有效，等同于local命令。
不带任何参数时，declare命令输出当前环境的所有变量，包括函数在内，等同于不带有任何参数的set命令。
$ declare
（1）-i参数
-i参数声明整数变量以后，可以直接进行数学运算。
$ declare -i val1=12 val2=5
$ declare -i result
$ result=val1*val2
$ echo $result
60
上面例子中，如果变量result不声明为整数，val1*val2会被当作字面量，不会进行整数运算。另外，val1和val2其实不需要声明为整数，因为只要result声明为整数，它的赋值就会自动解释为整数运算。
那么,
declare -i num
num=`ps -ef|grep -i ssh|awk '{print $2}'`
其结果也是整数类型?
试了下,的确是整数,因为可以使用-eq,-gt等做判断
注意，一个变量声明为整数以后，依然可以被改写为字符串。
$ declare -i var=12
$ var=foo
$ echo $var
0
上面例子中，变量var声明为整数，覆盖以后，Bash 不会报错，但会赋以不确定的值，上面的例子中可能输出0，也可能输出的是3。
（2）-x参数
-x参数等同于export命令，可以输出一个变量为子 Shell 的环境变量。
$ declare -x foo
# 等同于
$ export foo
（3）-r参数
-r参数可以声明只读变量，无法改变变量值，也不能unset变量。
$ declare -r bar=1
$ bar=2
bash: bar：只读变量
$ echo $?
1
$ unset bar
bash: bar：只读变量
$ echo $?
1
上面例子中，后两个赋值语句都会报错，命令执行失败。
（4）-u参数
-u参数声明变量为大写字母，可以自动把变量值转成大写字母。
$ declare -u foo
$ foo=upper
$ echo $foo
UPPER
（5）-l参数
-l参数声明变量为小写字母，可以自动把变量值转成小写字母。
$ declare -l bar
$ bar=LOWER
$ echo $bar
lower
（6）-p参数
-p参数输出变量信息。
$ foo=hello
$ declare -p foo
declare -- foo="hello"
$ declare -p bar
bar：未找到
上面例子中，declare -p可以输出已定义变量的值，对于未定义的变量，会提示找不到。
如果不提供变量名，declare -p输出所有变量的信息。
$ declare -p
（7）-f参数
-f参数输出当前环境的所有函数，包括它的定义。
$ declare -f
（8）-F参数
-F参数输出当前环境的所有函数名，不包含函数定义。
$ declare -F
readonly 命令
readonly命令等同于declare -r，用来声明只读变量，不能改变变量值，也不能unset变量。
$ readonly foo=1
$ foo=2
bash: foo：只读变量
$ echo $?
1
上面例子中，更改只读变量foo会报错，命令执行失败。
readonly命令有三个参数。
-f：声明的变量为函数名。-p：打印出所有的只读变量。-a：声明的变量为数组。
可不可以使用declare -r -p这种连用格式?因为上面说readonly等同于declare -r(但是感觉不行)
let 命令
let命令声明变量时，可以直接执行算术表达式。
$ let foo=1+2
$ echo $foo
3
上面例子中，let命令可以直接计算1 + 2。
let命令的参数表达式如果包含空格，就需要使用引号。
$ let "foo = 1 + 2"
let可以同时对多个变量赋值，赋值表达式之间使用空格分隔。
$ let "v1 = 1" "v2 = v1++"
$ echo $v1,$v2
2,1
上面例子中，let声明了两个变量v1和v2，其中v2等于v1++，表示先返回v1的值，然后v1自增。
这种语法支持的运算符，参考《Bash 的算术运算》一章。
6.字符串操作
本章介绍 Bash 字符串操作的语法。
字符串的长度
获取字符串长度的语法如下。
${#varname}
下面是一个例子。
$ myPath=/home/cam/book/long.file.name
$ echo ${#myPath}
29
大括号{}是必需的，否则 Bash 会将$#理解成脚本的参数个数，将变量名理解成文本。
$ echo $#myvar
0myvar
上面例子中，Bash 将$#和myvar分开解释了。
子字符串
字符串提取子串的语法如下。
${varname:offset:length}
上面语法的含义是返回变量$varname的子字符串，从位置offset开始（从0开始计算），长度为length。
$ count=frogfootman
$ echo ${count:4:4}
foot
上面例子返回字符串frogfootman从4号位置开始的长度为4的子字符串foot。
这种语法不能直接操作字符串，只能通过变量来读取字符串，并且不会改变原始字符串。
# 报错
$ echo ${"hello":2:3}
上面例子中，"hello"不是变量名，导致 Bash 报错。
如果省略length，则从位置offset开始，一直返回到字符串的结尾。
$ count=frogfootman
$ echo ${count:4}
footman
上面例子是返回变量count从4号位置一直到结尾的子字符串。
如果offset为负值，表示从字符串的末尾开始算起。注意，负数前面必须有一个空格， 以防止与${variable:-word}的变量的设置默认值语法混淆。这时还可以指定length，length可以是正值，也可以是负值（负值不能超过offset的长度）。
$ foo="This string is long."
$ echo ${foo: -5}
long.
$ echo ${foo: -5:2}
lo
$ echo ${foo: -5:-2}
lon
上面例子中，offset为-5，表示从倒数第5个字符开始截取，所以返回long.。如果指定长度length为2，则返回lo；如果length为-2，表示要排除从字符串末尾开始的2个字符，所以返回lon。
搜索和替换
Bash 提供字符串搜索和替换的多种方法。
（1）字符串头部的模式匹配。
以下两种语法可以检查字符串开头，是否匹配给定的模式。如果匹配成功，就删除匹配的部分，返回剩下的部分。原始变量不会发生变化。
# 如果 pattern 匹配变量 variable 的开头，
# 删除最短匹配（非贪婪匹配）的部分，返回剩余部分
${variable#pattern}
# 如果 pattern 匹配变量 variable 的开头，
# 删除最长匹配（贪婪匹配）的部分，返回剩余部分
${variable##pattern}
上面两种语法会删除变量字符串开头的匹配部分（将其替换为空），返回剩下的部分。区别是一个是最短匹配（又称非贪婪匹配），另一个是最长匹配（又称贪婪匹配）。
我个人觉得,一个叫最近匹配,一个叫最远且长匹配可能比较好记,因为下面的例子中,体现的是最近而不是最短这个特点,最短应该把/cam/给删除掉吧?或者叫懒匹配和勤匹配?
匹配模式pattern可以使用*、?、[]等通配符。
$ myPath=/home/cam/book/long.file.name
$ echo ${myPath#/*/}
cam/book/long.file.name
$ echo ${myPath##/*/}
long.file.name
上面例子中，匹配的模式是/*/，其中*可以匹配任意数量的字符，所以最短匹配是/home/，最长匹配是/home/cam/book/。
下面写法可以删除文件路径的目录部分，只留下文件名。
$ path=/home/cam/book/long.file.name
$ echo ${path##*/}
long.file.name
上面例子中，模式*/匹配目录部分，所以只返回文件名。
下面再看一个例子。
$ phone="555-456-1414"
$ echo ${phone#*-}
456-1414
$ echo ${phone##*-}
1414
如果匹配不成功，则返回原始字符串。
$ phone="555-456-1414"
$ echo ${phone#444}
555-456-1414
上面例子中，原始字符串里面无法匹配模式444，所以原样返回。
如果要将头部匹配的部分，替换成其他内容，采用下面的写法。
# 模式必须出现在字符串的开头
${variable/#pattern/string}
# 示例
$ foo=JPG.JPG
$ echo ${foo/#JPG/jpg}
jpg.JPG
上面例子中，被替换的JPG必须出现在字符串头部，所以返回jpg.JPG。
（2）字符串尾部的模式匹配。
以下两种语法可以检查字符串结尾，是否匹配给定的模式。如果匹配成功，就删除匹配的部分，返回剩下的部分。原始变量不会发生变化。
# 如果 pattern 匹配变量 variable 的结尾，
# 删除最短匹配（非贪婪匹配）的部分，返回剩余部分
${variable%pattern}
# 如果 pattern 匹配变量 variable 的结尾，
# 删除最长匹配（贪婪匹配）的部分，返回剩余部分
${variable%%pattern}
上面两种语法会删除变量字符串结尾的匹配部分（将其替换为空），返回剩下的部分。区别是一个是最短匹配（又称非贪婪匹配），另一个是最长匹配（又称贪婪匹配）。
$ path=/home/cam/book/long.file.name
$ echo ${path%.*}
/home/cam/book/long.file
$ echo ${path%%.*}
/home/cam/book/long
上面例子中，匹配模式是.*，其中*可以匹配任意数量的字符，所以最短匹配是.name，最长匹配是.file.name。
下面写法可以删除路径的文件名部分，只留下目录部分。
$ path=/home/cam/book/long.file.name
$ echo ${path%/*}
/home/cam/book
上面例子中，模式/*匹配文件名部分，所以只返回目录部分。
下面的写法可以替换文件的后缀名。
$ file=foo.png
$ echo ${file%.png}.jpg
foo.jpg
上面的例子将文件的后缀名，从.png改成了.jpg。
下面再看一个例子。
$ phone="555-456-1414"
$ echo ${phone%-*}
555-456
$ echo ${phone%%-*}
555
如果匹配不成功，则返回原始字符串。
如果要将尾部匹配的部分，替换成其他内容，采用下面的写法。
# 模式必须出现在字符串的结尾
${variable/%pattern/string}
# 示例
$ foo=JPG.JPG
$ echo ${foo/%JPG/jpg}
JPG.jpg
上面例子中，被替换的JPG必须出现在字符串尾部，所以返回JPG.jpg。
（3）任意位置的模式匹配。
以下两种语法可以检查字符串内部，是否匹配给定的模式。如果匹配成功，就删除匹配的部分，换成其他的字符串返回。原始变量不会发生变化。
# 如果 pattern 匹配变量 variable 的一部分，
# 最长匹配（贪婪匹配）的那部分被 string 替换，但仅替换第一个匹配
${variable/pattern/string}
# 如果 pattern 匹配变量 variable 的一部分，
# 最长匹配（贪婪匹配）的那部分被 string 替换，所有匹配都替换
${variable//pattern/string}
上面两种语法都是最长匹配（贪婪匹配）下的替换，区别是前一个语法仅仅替换第一个匹配，后一个语法替换所有匹配。
$ path=/home/cam/foo/foo.name
$ echo ${path/foo/bar}
/home/cam/bar/foo.name
$ echo ${path//foo/bar}
/home/cam/bar/bar.name
上面例子中，前一个命令只替换了第一个foo，后一个命令将两个foo都替换了。
下面的例子将分隔符从:换成换行符。
$ echo -e ${PATH//:/'\n'}
/usr/local/bin
/usr/bin
/bin
...
上面例子中，echo命令的-e参数，表示将替换后的字符串的\n字符，解释为换行符。
模式部分可以使用通配符。
$ phone="555-456-1414"
$ echo ${phone/5?4/-}
55-56-1414
上面的例子将5-4替换成-。
如果省略了string部分，那么就相当于匹配的部分替换成空字符串，即删除匹配的部分。
$ path=/home/cam/foo/foo.name
$ echo ${path/.*/}
/home/cam/foo/foo
上面例子中，第二个斜杠后面的string部分省略了，所以模式.*匹配的部分.name被删除后返回。
前面提到过，这个语法还有两种扩展形式。
# 模式必须出现在字符串的开头
${variable/#pattern/string}
# 模式必须出现在字符串的结尾
${variable/%pattern/string}
改变大小写
下面的语法可以改变变量(值)的大小写(改不改变变量本身的值?)。
# 转为大写
${varname^^}
# 转为小写
${varname,,}
下面是一个例子。
$ foo=heLLo
$ echo ${foo^^}
HELLO
$ echo ${foo,,}
hello
7.Bash 的算术运算
算术表达式
((...))语法可以进行整数的算术运算。
$ ((foo = 5 + 5))
$ echo $foo
10
((...))会自动忽略内部的空格，所以下面的写法都正确，得到同样的结果。
$ ((2+2))
$ (( 2+2 ))
$ (( 2 + 2 ))
这个语法不返回值，命令执行的结果根据算术运算的结果而定。只要算术结果不是0，命令就算执行成功。
$ (( 3 + 2 ))
$ echo $?
0
上面例子中，3 + 2的结果是5，命令就算执行成功，环境变量$?为0。
如果算术结果为0，命令就算执行失败。
$ (( 3 - 3 ))
$ echo $?
1
上面例子中，3 - 3的结果是0，环境变量$?为1，表示命令执行失败。
如果要读取算术运算的结果，需要在((...))前面加上美元符号$((...))，使其变成算术表达式，返回算术运算的值。
$ echo $((2 + 2))
4
((...))语法支持的算术运算符如下。
+：加法-：减法*：乘法/：除法（整除）%：余数**：指数++：自增运算（前缀或后缀）--：自减运算（前缀或后缀）
注意，除法运算符的返回结果总是整数，比如5除以2，得到的结果是2，而不是2.5。
$ echo $((5 / 2))
2
++和--这两个运算符有前缀和后缀的区别。作为前缀是先运算后返回值，作为后缀是先返回值后运算。
$ i=0
$ echo $i
0
$ echo $((i++))
0
$ echo $i
1
$ echo $((++i))
2
$ echo $i
2
上面例子中，++作为后缀是先返回值，执行echo命令，再进行自增运算；作为前缀则是先进行自增运算，再返回值执行echo命令。
$((...))内部可以用圆括号改变运算顺序。
$ echo $(( (2 + 3) * 4 ))
20
上面例子中，内部的圆括号让加法先于乘法执行。
$((...))结构可以嵌套。
$ echo $(((5**2) * 3))
75
# 等同于
$ echo $(($((5**2)) * 3))
75
这个语法只能计算整数，否则会报错。
# 报错
$ echo $((1.5 + 1))
bash: 语法错误
$((...))的圆括号之中，不需要在变量名之前加上$，不过加上也不报错。
$ number=2
$ echo $(($number + 1))
3
上面例子中，变量number前面有没有美元符号，结果都是一样的。
如果在$((...))里面使用字符串，Bash 会认为那是一个变量名。如果不存在同名变量，Bash 就会将其作为空值，因此不会报错。
$ echo $(( "hello" + 2))
2
$ echo $(( "hello" * 2))
0
上面例子中，"hello"会被当作变量名，返回空值，而$((...))会将空值当作0，所以乘法的运算结果就是0。同理，如果$((...))里面使用不存在的变量，也会当作0处理。
如果一个变量的值为字符串，跟上面的处理逻辑是一样的。即该字符串如果不对应已存在的变量，在$((...))里面会被当作空值。
$ foo=hello
$ echo $(( foo + 2))
2
上面例子中，变量foo的值是hello，而hello也会被看作变量名。这使得有可能写出动态替换的代码。
$ foo=hello
$ hello=3
$ echo $(( foo + 2 ))
5
上面代码中，foo + 2取决于变量hello的值。
最后，$[...]是以前的语法，也可以做整数运算，不建议使用。
$ echo $[2+2]
4
数值的进制
Bash 的数值默认都是十进制，但是在算术表达式中，也可以使用其他进制。
number：没有任何特殊表示法的数字是十进制数（以10为底）。0number：八进制数。0xnumber：十六进制数。base#number：base进制的数。
下面是一些例子。
$ echo $((0xff))
255
$ echo $((2#11111111))
255
上面例子中，0xff是十六进制数，2#11111111是二进制数。
位运算
$((...))支持以下的二进制位运算符。
<<：位左移运算，把一个数字的所有位向左移动指定的位。>>：位右移运算，把一个数字的所有位向右移动指定的位。&：位的“与”运算，对两个数字的所有位执行一个AND操作。|：位的“或”运算，对两个数字的所有位执行一个OR操作。~：位的“否”运算，对一个数字的所有位取反。^：位的异或运算（exclusive or），对两个数字的所有位执行一个异或操作。
下面是右移运算符>>的例子。
$ echo $((16>>2))
4
下面是左移运算符<<的例子。
$ echo $((16<<2))
64
下面是17（二进制10001）和3（二进制11）的各种二进制运算的结果。
$ echo $((17&3))
1
$ echo $((17|3))
19
$ echo $((17^3))
18
10001&11,其满足要求的只有最后一位,都是1,结果为1
10001|11,其满足要求发生替换的为倒数第二位,0替换为1,数值增加$$2^1$$,即17+2=19
10001异或11,其满足要求的为倒数第二位求或,替换为1,倒数第一位求异,1变成0,数值整体增加1,即18
逻辑运算
$((...))支持以下的逻辑运算符。
<：小于>：大于<=：小于或相等>=：大于或相等==：相等!=：不相等&&：逻辑与||：逻辑或!：逻辑否expr1?expr2:expr3：三元条件运算符(三目运算表达式)。若表达式expr1的计算结果为非零值（算术真），则执行表达式expr2，否则执行表达式expr3。
如果逻辑表达式为真，返回1，否则返回0。
$ echo $((3 > 2))
1
$ echo $(( (3 > 2) || (4 <= 1) ))
1
三元运算符执行一个单独的逻辑测试。它用起来类似于if/then/else语句。
$ a=0
$ echo $((a<1 ? 1 : 0))
1
$ echo $((a>1 ? 1 : 0))
0
上面例子中，第一个表达式为真时，返回第二个表达式的值，否则返回第三个表达式的值。
赋值运算
算术表达式$((...))可以执行赋值运算。
$ echo $((a=1))
1
$ echo $a
1
上面例子中，a=1对变量a进行赋值。这个式子本身也是一个表达式，返回值就是等号右边的值。
$((...))支持的赋值运算符，有以下这些。
parameter = value：简单赋值。parameter += value：等价于parameter = parameter + value。parameter -= value：等价于parameter = parameter – value。parameter *= value：等价于parameter = parameter * value。parameter /= value：等价于parameter = parameter / value。parameter %= value：等价于parameter = parameter % value。parameter <<= value：等价于parameter = parameter << value。parameter >>= value：等价于parameter = parameter >> value。parameter &= value：等价于parameter = parameter & value。parameter |= value：等价于parameter = parameter | value。parameter ^= value：等价于parameter = parameter ^ value。
下面是一个例子。
$ foo=5
$ echo $((foo*=2))
10
如果在表达式内部赋值，可以放在圆括号中，否则会报错。
$ echo $(( a<1 ? (a+=1) : (a-=1) ))
求值运算
逗号,在$((...))内部是求值运算符，执行前后两个表达式，并返回后一个表达式的值。
$ echo $((foo = 1 + 2, 3 * 4))
12
$ echo $foo
3
上面例子中，逗号前后两个表达式都会执行，然后返回后一个表达式的值12。
expr 命令
expr命令支持算术运算，可以不使用((...))语法。
$ expr 3 + 2
5
expr命令支持变量替换。
$ foo=3
$ expr $foo + 2
5
expr命令也不支持非整数参数。
$ expr 3.5 + 2
expr: 非整数参数
上面例子中，如果有非整数的运算，expr命令就报错了。
let 命令
let命令用于将算术运算的结果，赋予一个变量。
$ let x=2+3
$ echo $x
5
上面例子中，变量x等于2+3的运算结果。
注意，x=2+3这个式子里面不能有空格，否则会报错。let命令的详细用法参见《变量》一章。
8.Bash 行操作
简介
Bash 内置了 Readline 库，具有这个库提供的很多“行操作”功能，比如命令的自动补全，可以大大加快操作速度。
这个库默认采用 Emacs 快捷键，也可以改成 Vi 快捷键。
$ set -o vi
下面的命令可以改回 Emacs 快捷键。
$ set -o emacs
如果想永久性更改编辑模式（Emacs / Vi），可以将命令写在~/.inputrc文件，这个文件是 Readline 的配置文件。
set editing-mode vi
本章介绍的快捷键都属于 Emacs 模式。Vi 模式的快捷键，读者可以参考 Vi 编辑器的教程。
Bash 默认开启这个库，但是允许关闭。
$ bash --noediting
上面命令中，--noediting参数关闭了 Readline 库，启动的 Bash 就不带有行操作功能。
光标移动
Readline 提供快速移动光标的快捷键。
Ctrl + a：移到行首。Ctrl + b：向行首移动一个字符，与左箭头作用相同。Ctrl + e：移到行尾。Ctrl + f：向行尾移动一个字符，与右箭头作用相同。Alt + f：移动到当前单词的词尾。Alt + b：移动到当前单词的词首。
上面快捷键的 Alt 键，也可以用 ESC 键代替。
清除屏幕
Ctrl + l快捷键可以清除屏幕，即将当前行移到屏幕的第一行，与clear命令作用相同。
编辑操作
下面的快捷键可以编辑命令行内容。
Ctrl + d：删除光标位置的字符（delete）。Ctrl + w：删除光标前面的单词。Ctrl + t：光标位置的字符与它前面一位的字符交换位置（transpose）。Alt + t：光标位置的词与它前面一位的词交换位置（transpose）。Alt + l：将光标位置至词尾转为小写（lowercase）。Alt + u：将光标位置至词尾转为大写（uppercase）。
使用Ctrl + d的时候，如果当前行没有任何字符，会导致退出当前 Shell，所以要小心。
剪切和粘贴快捷键如下。
Ctrl + k：剪切光标位置到行尾的文本。Ctrl + u：剪切光标位置到行首的文本。Alt + d：剪切光标位置到词尾的文本。Alt + Backspace：剪切光标位置到词首的文本。Ctrl + y：在光标位置粘贴文本。
同样地，Alt 键可以用 Esc 键代替。
自动补全
命令输入到一半的时候，可以按一下 Tab 键，Readline 会自动补全命令或路径。比如，输入cle，再按下 Tab 键，Bash 会自动将这个命令补全为clear。
如果符合条件的命令或路径有多个，就需要连续按两次 Tab 键，Bash 会提示所有符合条件的命令或路径。
除了命令或路径，Tab 还可以补全其他值。如果一个值以$开头，则按下 Tab 键会补全变量；如果以~开头，则补全用户名；如果以@开头，则补全主机名（hostname），主机名以列在/etc/hosts文件里面的主机为准。
自动补全相关的快捷键如下。
- Tab：完成自动补全。
Alt + ?：列出可能的补全，与连按两次 Tab 键作用相同。Alt + /：尝试文件路径补全。Ctrl + x /：先按Ctrl + x，再按/，等同于Alt + ?，列出可能的文件路径补全。Alt + !：命令补全。Ctrl + x !：先按Ctrl + x，再按!，等同于Alt + !，命令补全。Alt + ~：用户名补全。Ctrl + x ~：先按Ctrl + x，再按~，等同于Alt + ~，用户名补全。Alt + $：变量名补全。Ctrl + x $：先按Ctrl + x，再按$，等同于Alt + $，变量名补全。Alt + @：主机名补全。Ctrl + x @：先按Ctrl + x，再按@，等同于Alt + @，主机名补全。Alt + *：在命令行一次性插入所有可能的补全。Alt + Tab：尝试用.bash_history里面以前执行命令，进行补全。
上面的Alt键也可以用 ESC 键代替。
操作历史
基本用法
Bash 会保留用户的操作历史，即用户输入的每一条命令都会记录。有了操作历史以后，就可以使用方向键的↑和↓，快速浏览上一条和下一条命令。
退出当前 Shell 的时候，Bash 会将用户在当前 Shell 的操作历史写入~/.bash_history文件，该文件默认储存500个操作。
环境变量HISTFILE总是指向这个文件。
$ echo $HISTFILE
/home/me/.bash_history
history命令会输出这个文件的全部内容。用户可以看到最近执行过的所有命令，每条命令之前都有行号。越近的命令，排在越后面。
$ history
...
498 echo Goodbye
499 ls ~
500 cd
输入命令时，按下Ctrl + r快捷键，就可以搜索操作历史，选择以前执行过的命令。这时键入命令的开头部分，Shell 就会自动在历史文件中，查询并显示最近一条匹配的结果，这时按下回车键，就会执行那条命令。
下面的方法可以快速执行以前执行过的命令。
$ echo Hello World
Hello World
$ echo Goodbye
Goodbye
$ !e
echo Goodbye
Goodbye
上面例子中，!e表示找出操作历史之中，最近的那一条以e开头的命令并执行。Bash 会先输出那一条命令echo Goodbye，然后直接执行。
同理，!echo也会执行最近一条以echo开头的命令。
$ !echo
echo Goodbye
Goodbye
$ !echo H
echo Goodbye H
Goodbye H
$ !echo H G
echo Goodbye H G
Goodbye H G
注意，!string语法只会匹配命令，不会匹配参数。所以!echo H不会执行echo Hello World，而是会执行echo Goodbye，并把参数H附加在这条命令之后。同理，!echo H G也是等同于echo Goodbye命令之后附加H G。
由于!string语法会扩展成以前执行过的命令，所以含有!的字符串放在双引号里面，必须非常小心，如果它后面有非空格的字符，就很有可能报错。
$ echo "I say:\"hello!\""
bash: !\: event not found
上面的命令会报错，原因是感叹号后面是一个反斜杠，Bash 会尝试寻找，以前是否执行过反斜杠开头的命令，一旦找不到就会报错。解决方法就是在感叹号前面，也加上反斜杠。
$ echo "I say:\"hello\!\""
I say:"hello\!"
history 命令
前面说过，history命令能显示操作历史，即.bash_history文件的内容。
$ history
使用该命令，而不是直接读取.bash_history文件的好处是，它会在所有的操作前加上行号，最近的操作在最后面，行号最大。
通过定制环境变量HISTTIMEFORMAT，可以显示每个操作的时间。
$ export HISTTIMEFORMAT='%F %T '
$ history
1 2013-06-09 10:40:12 cat /etc/issue
2 2013-06-09 10:40:12 clear
上面代码中，%F相当于%Y - %m - %d，%T相当于 %H : %M : %S。
只要设置HISTTIMEFORMAT这个环境变量，就会在.bash_history文件保存命令的执行时间戳。如果不设置，就不会保存时间戳。
环境变量HISTSIZE设置保存历史操作的数量。
$ export HISTSIZE=10000
上面命令设置保存过去10000条操作历史。
如果不希望保存本次操作的历史，可以设置HISTSIZE等于0。
export HISTSIZE=0
如果HISTSIZE=0写入用户主目录的~/.bashrc文件，那么就不会保留该用户的操作历史。如果写入/etc/profile，整个系统都不会保留操作历史。
环境变量HISTIGNORE可以设置哪些命令不写入操作历史。
export HISTIGNORE='pwd:ls:exit'
上面示例设置，pwd、ls、exit这三个命令不写入操作历史。
如果想搜索某个以前执行的命令，可以配合grep命令搜索操作历史。
$ history | grep /usr/bin
上面命令返回.bash_history文件里面，那些包含/usr/bin的命令。
操作历史的每一条记录都有编号。知道了命令的编号以后，可以用感叹号 + 编号执行该命令。如果想要执行.bash_history里面的第8条命令，可以像下面这样操作。
$ !8
history命令的-c参数可以清除操作历史。
$ history -c
相关快捷键
下面是一些与操作历史相关的快捷键。
Ctrl + p：显示上一个命令，与向上箭头效果相同（previous）。Ctrl + n：显示下一个命令，与向下箭头效果相同（next）。Alt + <：显示第一个命令。Alt + >：显示最后一个命令，即当前的命令。Ctrl + o：执行历史文件里面的当前条目，并自动显示下一条命令。这对重复执行某个序列的命令很有帮助。
感叹号!的快捷键如下。
!!：执行上一个命令。!n：n为数字，执行历史文件里面行号为n的命令。!-n：执行当前命令之前n条的命令。!string：执行最近一个以指定字符串string开头的命令。!?string：执行最近一条包含字符串string的命令。!$：代表上一个命令的最后一个参数。!*：代表上一个命令的所有参数，即除了命令以外的所有部分。^string1^string2：执行最近一条包含string1的命令，将其替换成string2。
下面是!$和!*的例子。
$ cp a.txt b.txt
$ echo !$
b.txt
$ cp a.txt b.txt
$ echo !*
a.txt b.txt
上面示例中，!$代表上一个命令的最后一个参数（b.txt），!*代表上一个命令的所有参数（a.txt b.txt）。
下面是^string1^string2的例子。
$ rm /var/log/httpd/error.log
$ ^error^access
rm /var/log/httpd/access.log
上面示例中，^error^access将最近一条含有error的命令里面的error，替换成access。
如果希望确定是什么命令，然后再执行，可以打开histverify选项。这样的话，使用!快捷键所产生的命令，会先打印出来，等到用户按下回车键后再执行。
$ shopt -s histverify
其他快捷键
Ctrl + j：等同于回车键（LINEFEED）。Ctrl + m：等同于回车键（CARRIAGE RETURN）。Ctrl + o：等同于回车键，并展示操作历史的下一个命令。Ctrl + v：将下一个输入的特殊字符变成字面量，比如回车变成^M。Ctrl + [：等同于 ESC。Alt + .：插入上一个命令的最后一个词。Alt + _：等同于Alt + .。
上面的Alt + .快捷键，对于很长的文件路径，有时会非常方便。因为 Unix 命令的最后一个参数通常是文件路径。
$ mkdir foo_bar
$ cd #按下 Alt + .
上面例子中，在cd命令后按下Alt + .，就会自动插入foo_bar。
9.目录堆栈
为了方便用户在不同目录之间切换，Bash 提供了目录堆栈功能。
cd -
Bash 可以记忆用户进入过的目录。默认情况下，只记忆前一次所在的目录，cd -命令可以返回前一次的目录。
# 当前目录是 /path/to/foo
$ cd bar
# 重新回到 /path/to/foo
$ cd -
上面例子中，用户原来所在的目录是/path/to/foo，进入子目录bar以后，使用cd -可以回到原来的目录。
pushd，popd
如果希望记忆多重目录，可以使用pushd命令和popd命令。它们用来操作目录堆栈。
pushd命令的用法类似cd命令，可以进入指定的目录。
$ pushd dirname
上面命令会进入目录dirname，并将该目录放入堆栈。
第一次使用pushd命令时，会将当前目录先放入堆栈，然后将所要进入的目录也放入堆栈，位置在前一个记录的上方。以后每次使用pushd命令，都会将所要进入的目录，放在堆栈的顶部。
popd命令不带有参数时，会移除堆栈的顶部记录，并进入新的栈顶目录（即原来的第二条目录）。
下面是一个例子。
# 当前处在主目录，堆栈为空
$ pwd
/home/me
# 进入 /home/me/foo
# 当前堆栈为 /home/me/foo /home/me
$ pushd ~/foo
# 进入 /etc
# 当前堆栈为 /etc /home/me/foo /home/me
$ pushd /etc
# 进入 /home/me/foo
# 当前堆栈为 /home/me/foo /home/me
$ popd
# 进入 /home/me
# 当前堆栈为 /home/me
$ popd
# 目录不变，当前堆栈为空
$ popd
这两个命令的参数如下。
（1）-n 参数
-n的参数表示仅操作堆栈，不改变目录。
$ popd -n
上面的命令仅删除堆栈顶部的记录，不改变目录，执行完成后还停留在当前目录。
（2）整数参数
这两个命令还可以接受一个整数作为参数，该整数表示堆栈中指定位置的记录（从0开始）。pushd命令会把这条记录移动到栈顶，同时切换到该目录；popd则从堆栈中删除这条记录，不会切换目录。
# 将从栈顶算起的3号目录（从0开始）移动到栈顶，同时切换到该目录
$ pushd +3
# 将从栈底算起的3号目录（从0开始）移动到栈顶，同时切换到该目录
$ pushd -3
# 删除从栈顶算起的3号目录（从0开始），不改变当前目录
$ popd +3
# 删除从栈底算起的3号目录（从0开始），不改变当前目录
$ popd -3
上面例子的整数编号都是从0开始计算，popd +0是删除第一个目录，popd +1是删除第二个，popd -0是删除最后一个目录，popd -1是删除倒数第二个。
（3）目录参数
pushd可以接受一个目录作为参数，表示将该目录放到堆栈顶部，并进入该目录。
$ pushd dir
popd没有这个参数。
dirs 命令
dirs命令可以显示目录堆栈的内容，一般用来查看pushd和popd操作后的结果。
$ dirs
~/foo/bar ~/foo ~
该命令会输出一行文本，列出目录堆栈，目录之间使用空格分隔。栈顶（最晚入栈的目录）在最左边，栈底（最早入栈的目录）在最右边。
它有以下参数。
-c：清空目录栈。-l：用户主目录不显示波浪号前缀，而打印完整的目录。-p：每行一个条目打印目录栈，默认是打印在一行。-v：每行一个条目，每个条目之前显示位置编号（从0开始）。+N：N为整数，表示显示堆顶算起的第 N 个目录，从零开始。-N：N为整数，表示显示堆底算起的第 N 个目录，从零开始。
10.Bash 脚本入门
脚本（script）就是包含一系列命令的一个文本文件。Shell 读取这个文件，依次执行里面的所有命令，就好像这些命令直接输入到命令行一样。所有能够在命令行完成的任务，都能够用脚本完成。
脚本的好处是可以重复使用，也可以指定在特定场合自动调用，比如系统启动或关闭时自动执行脚本。
Shebang 行
脚本的第一行通常是指定解释器，即这个脚本必须通过什么解释器执行。这一行以#!字符开头，这个字符称为 Shebang，所以这一行就叫做 Shebang 行。
#!后面就是脚本解释器的位置，Bash 脚本的解释器一般是/bin/sh或/bin/bash。
#!/bin/sh
# 或者
#!/bin/bash
#!与脚本解释器之间有没有空格，都是可以的。
如果 Bash 解释器不放在目录/bin，脚本就无法执行了。为了保险，可以写成下面这样。
#!/usr/bin/env bash
上面命令使用env命令（这个命令总是在/usr/bin目录），返回 Bash 可执行文件的位置。env命令的详细介绍，请看后文。
Shebang 行不是必需的，但是建议加上这行。如果缺少该行，就需要手动将脚本传给解释器。举例来说，脚本是script.sh，有 Shebang 行的时候，可以直接调用执行。
$ ./script.sh
上面例子中，script.sh是脚本文件名。脚本通常使用.sh后缀名，不过这不是必需的。
如果没有 Shebang 行，就只能手动将脚本传给解释器来执行。
$ /bin/sh ./script.sh
# 或者
$ bash ./script.sh
执行权限和路径
前面说过，只要指定了 Shebang 行的脚本，可以直接执行。这有一个前提条件，就是脚本需要有执行权限。可以使用下面的命令，赋予脚本执行权限。
# 给所有用户执行权限
$ chmod +x script.sh
# 给所有用户读权限和执行权限
$ chmod +rx script.sh
# 或者
$ chmod 755 script.sh
# 只给脚本拥有者读权限和执行权限
$ chmod u+rx script.sh
脚本的权限通常设为755（拥有者有所有权限，其他人有读和执行权限）或者700（只有拥有者可以执行）。
除了执行权限，脚本调用时，一般需要指定脚本的路径（比如path/script.sh）。如果将脚本放在环境变量$PATH指定的目录中，就不需要指定路径了。因为 Bash 会自动到这些目录中，寻找是否存在同名的可执行文件。
建议在主目录新建一个~/bin子目录，专门存放可执行脚本，然后把~/bin加入$PATH。
export PATH=$PATH:~/bin
上面命令改变环境变量$PATH，将~/bin添加到$PATH的末尾。可以将这一行加到~/.bashrc文件里面，然后重新加载一次.bashrc，这个配置就可以生效了。
$ source ~/.bashrc
以后不管在什么目录，直接输入脚本文件名，脚本就会执行。
$ script.sh
上面命令没有指定脚本路径，因为script.sh在$PATH指定的目录中。
env 命令
env命令总是指向/usr/bin/env文件，或者说，这个二进制文件总是在目录/usr/bin。
#!/usr/bin/env NAME这个语法的意思是，让 Shell 查找$PATH环境变量里面第一个匹配的NAME。如果你不知道某个命令的具体路径，或者希望兼容其他用户的机器，这样的写法就很有用。
/usr/bin/env bash的意思就是，返回bash可执行文件的位置，前提是bash的路径是在$PATH里面。其他脚本文件也可以使用这个命令。比如 Node.js 脚本的 Shebang 行，可以写成下面这样。
#!/usr/bin/env node
env命令的参数如下。
-i,--ignore-environment：不带环境变量启动。-u,--unset=NAME：从环境变量中删除一个变量。--help：显示帮助。--version：输出版本信息。
下面是一个例子，新建一个不带任何环境变量的 Shell。
$ env -i /bin/sh
注释
Bash 脚本中，#表示注释，可以放在行首，也可以放在行尾。
# 本行是注释
echo 'Hello World!'
echo 'Hello World!' # 井号后面的部分也是注释
建议在脚本开头，使用注释说明当前脚本的作用，这样有利于日后的维护。
脚本参数
调用脚本的时候，脚本文件名后面可以带有参数。
$ script.sh word1 word2 word3
上面例子中，script.sh是一个脚本文件，word1、word2和word3是三个参数。
脚本文件内部，可以使用特殊变量，引用这些参数。
$0：脚本文件名，即script.sh。$1~$9：对应脚本的第一个参数到第九个参数。$#：参数的总数。$@：全部的参数，参数之间使用空格分隔。$*：全部的参数，参数之间使用变量$IFS值的第一个字符分隔，默认为空格，但是可以自定义。
如果脚本的参数多于9个，那么第10个参数可以用${10}的形式引用，以此类推。
注意，如果命令是command -o foo bar，那么-o是$1，foo是$2，bar是$3。
下面是一个脚本内部读取命令行参数的例子。
#!/bin/bash
# script.sh
echo "全部参数：" $@
echo "命令行参数数量：" $#
echo '$0 = ' $0
echo '$1 = ' $1
echo '$2 = ' $2
echo '$3 = ' $3
执行结果如下。
$ ./script.sh a b c
全部参数：a b c
命令行参数数量：3
$0 = script.sh
$1 = a
$2 = b
$3 = c
用户可以输入任意数量的参数，利用for循环，可以读取每一个参数。
#!/bin/bash
for i in "$@"; do
echo $i
done
上面例子中，$@返回一个全部参数的列表，然后使用for循环遍历。
如果多个参数放在双引号里面，视为一个参数。
$ ./script.sh "a b"
上面例子中，Bash 会认为"a b"是一个参数，$1会返回a b。注意，返回时不包括双引号。
shift 命令
shift命令可以改变脚本参数，每次执行都会移除脚本当前的第一个参数（$1），使得后面的参数向前一位，即$2变成$1、$3变成$2、$4变成$3，以此类推。
while循环结合shift命令，也可以读取每一个参数。
#!/bin/bash
echo "一共输入了 $# 个参数"
while [ "$1" != "" ]; do
echo "剩下 $# 个参数"
echo "参数：$1"
shift
done
上面例子中，shift命令每次移除当前第一个参数，从而通过while循环遍历所有参数。
shift命令可以接受一个整数作为参数，指定所要移除的参数个数，默认为1。
shift 3
上面的命令移除前三个参数，原来的$4变成$1。
getopts 命令
getopts命令用在脚本内部，可以解析复杂的脚本命令行参数，通常与while循环一起使用，取出脚本所有的带有前置连词线（-）的参数。
getopts optstring name
它带有两个参数。第一个参数optstring是字符串，给出脚本所有的连词线参数。比如，某个脚本可以有三个配置项参数-l、-h、-a，其中只有-a可以带有参数值，而-l和-h是开关参数，那么getopts的第一个参数写成lha:，顺序不重要。注意，a后面有一个冒号，表示该参数带有参数值，getopts规定带有参数值的配置项参数，后面必须带有一个冒号（:）。getopts的第二个参数name是一个变量名，用来保存当前取到的配置项参数，即l、h或a。
下面是一个例子。
while getopts 'lha:' OPTION; do
case "$OPTION" in
l)
echo "linuxconfig"
;;
h)
echo "h stands for h"
;;
a)
avalue="$OPTARG"
echo "The value provided is $OPTARG"
;;
?)
echo "script usage: $(basename $0) [-l] [-h] [-a somevalue]" >&2
exit 1
;;
esac
done
shift "$(($OPTIND - 1))"
上面例子中，while循环不断执行getopts 'lha:' OPTION命令，每次执行就会读取一个连词线参数（以及对应的参数值），然后进入循环体。变量OPTION保存的是，当前处理的那一个连词线参数（即l、h或a）。如果用户输入了没有指定的参数（比如-x），那么OPTION等于?。循环体内使用case判断，处理这四种不同的情况。
如果某个连词线参数带有参数值，比如-a foo，那么处理a参数的时候，环境变量$OPTARG保存的就是参数值。
注意，只要遇到不带连词线的参数，getopts就会执行失败，从而退出while循环。比如，getopts可以解析command -l foo，但不可以解析command foo -l。另外，多个连词线参数写在一起的形式，比如command -lh，getopts也可以正确处理。
变量$OPTIND在getopts开始执行前是1，然后每次执行就会加1。等到退出while循环，就意味着连词线参数全部处理完毕。这时，$OPTIND - 1就是已经处理的连词线参数个数，使用shift命令将这些参数移除，保证后面的代码可以用$1、$2等处理命令的主参数。
配置项参数终止符 --
-和--开头的参数，会被 Bash 当作配置项解释。但是，有时它们不是配置项，而是实体参数的一部分，比如文件名叫做-f或--file。
$ cat -f
$ cat --file
上面命令的原意是输出文件-f和--file的内容，但是会被 Bash 当作配置项解释。
这时就可以使用配置项参数终止符--，它的作用是告诉 Bash，在它后面的参数开头的-和--不是配置项，只能当作实体参数解释。
$ cat -- -f
$ cat -- --file
上面命令可以正确展示文件-f和--file的内容，因为它们放在--的后面，开头的-和--就不再当作配置项解释了。
如果要确保某个变量不会被当作配置项解释，就要在它前面放上参数终止符--。
$ ls -- $myPath
上面示例中，--强制变量$myPath只能当作实体参数（即路径名）解释。如果变量不是路径名，就会报错。
$ myPath="-l"
$ ls -- $myPath
ls: 无法访问'-l': 没有那个文件或目录
上面例子中，变量myPath的值为-l，不是路径。但是，--强制$myPath只能作为路径解释，导致报错“不存在该路径”。
下面是另一个实际的例子，如果想在文件里面搜索--hello，这时也要使用参数终止符--。
$ grep -- "--hello" example.txt
上面命令在example.txt文件里面，搜索字符串--hello。这个字符串是--开头，如果不用参数终止符，grep命令就会把--hello当作配置项参数，从而报错。
exit 命令
exit命令用于终止当前脚本的执行，并向 Shell 返回一个退出值。
$ exit
上面命令中止当前脚本，将最后一条命令的退出状态，作为整个脚本的退出状态。
exit命令后面可以跟参数，该参数就是退出状态。
# 退出值为0（成功）
$ exit 0
# 退出值为1（失败）
$ exit 1
退出时，脚本会返回一个退出值。脚本的退出值，0表示正常，1表示发生错误，2表示用法不对，126表示不是可执行脚本，127表示命令没有发现。如果脚本被信号N终止，则退出值为128 + N。简单来说，只要退出值非0，就认为执行出错。
下面是一个例子。
if [ $(id -u) != "0" ]; then
echo "根用户才能执行当前脚本"
exit 1
fi
上面的例子中，id -u命令返回用户的 ID，一旦用户的 ID 不等于0（根用户的 ID），脚本就会退出，并且退出码为1，表示运行失败。
exit与return命令的差别是，return命令是函数的退出，并返回一个值给调用者，脚本依然执行。exit是整个脚本的退出，如果在函数之中调用exit，则退出函数，并终止脚本执行。
命令执行结果
命令执行结束后，会有一个返回值。0表示执行成功，非0（通常是1）表示执行失败。环境变量$?可以读取前一个命令的返回值。
利用这一点，可以在脚本中对命令执行结果进行判断。
cd /path/to/somewhere
if [ "$?" = "0" ]; then
rm *
else
echo "无法切换目录！" 1>&2
exit 1
fi
上面例子中，cd /path/to/somewhere这个命令如果执行成功（返回值等于0），就删除该目录里面的文件，否则退出脚本，整个脚本的返回值变为1，表示执行失败。
由于if可以直接判断命令的执行结果，执行相应的操作，上面的脚本可以改写成下面的样子。
if cd /path/to/somewhere; then
rm *
else
echo "Could not change directory! Aborting." 1>&2
exit 1
fi
更简洁的写法是利用两个逻辑运算符&&（且）和||（或）。
# 第一步执行成功，才会执行第二步
cd /path/to/somewhere && rm *
# 第一步执行失败，才会执行第二步
cd /path/to/somewhere || exit 1
source 命令
source命令用于执行一个脚本，通常用于重新加载一个配置文件。
$ source .bashrc
source命令最大的特点是在当前 Shell 执行脚本，不像直接执行脚本时，会新建一个子 Shell。所以，source命令执行脚本时，不需要export变量。
#!/bin/bash
# test.sh
echo $foo
上面脚本输出$foo变量的值。
# 当前 Shell 新建一个变量 foo
$ foo=1
# 打印输出 1
$ source test.sh
1
# 打印输出空字符串
$ bash test.sh
上面例子中，当前 Shell 的变量foo并没有export，所以直接执行无法读取，但是source执行可以读取。
source命令的另一个用途，是在脚本内部加载外部库。
#!/bin/bash
source ./lib.sh
function_from_lib
上面脚本在内部使用source命令加载了一个外部库，然后就可以在脚本里面，使用这个外部库定义的函数。
source有一个简写形式，可以使用一个点（.）来表示。
$ . .bashrc
别名，alias 命令
alias命令用来为一个命令指定别名，这样更便于记忆。下面是alias的格式。
alias NAME=DEFINITION
上面命令中，NAME是别名的名称，DEFINITION是别名对应的原始命令。注意，等号两侧不能有空格，否则会报错。
一个常见的例子是为grep命令起一个search的别名。
alias search=grep
alias也可以用来为长命令指定一个更短的别名。下面是通过别名定义一个today的命令。
$ alias today='date +"%A, %B %-d, %Y"'
$ today
星期一, 一月 6, 2020
有时为了防止误删除文件，可以指定rm命令的别名。
$ alias rm='rm -i'
上面命令指定rm命令是rm -i，每次删除文件之前，都会让用户确认。
alias定义的别名也可以接受参数，参数会直接传入原始命令。
$ alias echo='echo It says: '
$ echo hello world
It says: hello world
上面例子中，别名定义了echo命令的前两个参数，等同于修改了echo命令的默认行为。
指定别名以后，就可以像使用其他命令一样使用别名。一般来说，都会把常用的别名写在~/.bashrc的末尾。另外，只能为命令定义别名，为其他部分（比如很长的路径）定义别名是无效的。
直接调用alias命令，可以显示所有别名。
$ alias
unalias命令可以解除别名。
$ unalias lt
参考链接
- How to use getopts to parse a script options, Egidio Docile
