Shell脚本语言笔记
- 一、shell是什么？
- 二、Shell 是一种脚本语言
- 1、定义变量
- 2、单引号和双引号的区别：
- 3、将命令的结果赋值给变量，常见的有以下两种方式：
- 4、只读变量
- 5、删除变量：
- 6、给脚本文件传递位置参数：
- 7、Shell 特殊变量及其含义
- 8、获取字符串长度，具体方法如下：
- 9、Shell字符串拼接（连接、合并）
- 10、Shell字符串截取（非常详细）
- 11、shell数组：
- 12、Shell获取数组长度，就是数组元素的个数。
- 13、Shell数组拼接，Shell数组合并：
- 14、Shell删除数组元素（也可以删除整个数组）：
- 15、Shell内建命令（内置命令）：
- 16、Shell alias：给命令创建别名：
- 17、Shell echo命令：输出字符串
- 18、Shell read命令：读取从键盘输入的数据：
- 19、Shell exit命令：退出当前进程：
- 20、Shell declare和typeset命令：设置变量属性：
- 21、Shell数学计算（算术运算，加减乘除运算）
- 22、Shell (())：对整数进行数学运算：
- 23、Shell let命令：对整数进行数学运算：
- 24、Shell if else语句（详解版）
- 25、Shell退出状态：
- 26、Shell test命令（Shell []）详解，附带所有选项及说明：
- 27、Shell [[]]详解：检测某个条件是否成立：
- 28、Shell case in语句详解：
- 29、Shell while循环详解：
- 30、Shell until循环用法详解：
- 31、Shell for循环和for int循环详解：
- 32、Shell select in循环详解：
- 33、Shell break和continue跳出循环详解：
- 34、Shell函数详解（函数定义、函数调用）：
- 35、Shell函数参数：
- 36、Linux Shell重定向（输入输出重定向）精讲：
- 37、Linux Shell管道详解：
- 38、Shell过滤器：
一、shell是什么？
- Shell 是一个应用程序，它连接了用户和 Linux 内核，让用户能够更加高效、安全、低成本地使用 Linux 内核，这就是 Shell的本质。 Shell 本身并不是内核的一部分，它只是站在内核的基础上编写的一个应用程序，它和 QQ、迅雷、Firefox等其它软件没有什么区别。然而 Shell 也有着它的特殊性，就是开机立马启动，并呈现在用户面前；用户通过 Shell 来使用
Linux，不启动 Shell 的话，用户就没办法使用 Linux。
二、Shell 是一种脚本语言
任何代码最终都要被“翻译”成二进制的形式才能在计算机中执行。
有的编程语言，如
C/C++、Pascal、Go语言、汇编等，必须在程序运行之前将所有代码都翻译成二进制形式，也就是生成可执行文件，用户拿到的是最终生成的可执行文件，看不到源码。
这个过程叫做编译（Compile），这样的编程语言叫做编译型语言，完成编译过程的软件叫做编译器（Compiler）。
而有的编程语言，如 Shell、JavaScript、Python、PHP等，需要一边执行一边翻译，不会生成任何可执行文件，用户必须拿到源码才能运行程序。程序运行后会即时翻译，翻译完一部分执行一部分，不用等到所有代码都翻译完。
这个过程叫做解释，这样的编程语言叫做解释型语言或者脚本语言（Script），完成解释过程的软件叫做解释器。
编译型语言的优点是执行速度快、对硬件要求低、保密性好，适合开发操作系统、大型应用程序、数据库等。
脚本语言的优点是使用灵活、部署容易、跨平台性好，非常适合 Web 开发以及小工具的制作。
Shell 就是一种脚本语言，我们编写完源码后不用编译，直接运行源码即可。
1、定义变量
Shell 支持以下三种定义变量的方式：
variable=value variable='value' variable="value"
variable 是变量名，value 是赋给变量的值。如果 value 不包含任何空白符（例如空格、Tab 缩进等），那么可以不使用引号；如果 value 包含了空白符，那么就必须使用引号包围起来。
注意，赋值号=的周围不能有空格，这可能和你熟悉的大部分编程语言都不一样。
2、单引号和双引号的区别：
以单引号''包围变量的值时，单引号里面是什么就输出什么，即使内容中有变量和命令（命令需要反引起来）也会把它们原样输出。这种方式比较适合定义显示纯字符串的情况，即不希望解析变量、命令等的场景。
以双引号""包围变量的值时，输出时会先解析里面的变量和命令，而不是把双引号中的变量名和命令原样输出。这种方式比较适合字符串中附带有变量和命令并且想将其解析后再输出的变量定义。
3、将命令的结果赋值给变量，常见的有以下两种方式：
variable=`command`
variable=$(command)
第一种方式键的下方）包围起来，反引号和单引号非常相似，容易产生混淆，所以不推荐使用这种方式；
第二种方式把命令用$()包围起来，区分更加明显，所以推荐使用这种方式
4、只读变量
1、使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。语法： readonly myUrl
5、删除变量：
1、使用 unset 命令可以删除变量。语法： unset variable_name 变量被删除后不能再次使用；unset
命令不能删除只读变量。
6、给脚本文件传递位置参数：
这种通过$n的形式来接收的参数，在 Shell 中称为位置参数。
echo "Language: $1" echo "URL: $2"
7、Shell 特殊变量及其含义
变量 含义
$0 当前脚本的文件名。
$n（n≥1） 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个参数是 $1，第二个参数是 $2。
$# 传递给脚本或函数的参数个数。
$* 传递给脚本或函数的所有参数。
$@ 传递给脚本或函数的所有参数。当被双引号" "包含时，$@ 与 $* 稍有不同。
$? 上个命令的退出状态，或函数的返回值，我们将在《Shell $?》一节中详细讲解。
$$ 当前 Shell 进程 ID。对于 Shell 脚本，就是这些脚本所在的进程 ID。
8、获取字符串长度，具体方法如下：
${#string_name} string_name 表示字符串名字。
9、Shell字符串拼接（连接、合并）
name="Shell"
url="http://c.biancheng.net/shell/"
str1=$name$url #中间不能有空格，当字符串不被任何一种引号包围时，遇到空格就认为字符串结束了
str2="$name $url" #如果被双引号包围，那么中间可以有空格
str3=$name": "$url #中间可以出现别的字符串
str4="$name: $url" #这样写也可以
str5="${name}Script: ${url}index.html" #这个时候需要给变量名加上大括号，加{ }是为了帮助解释器识别变量的边界
10、Shell字符串截取（非常详细）
格式 说明
${string: start :length} 从 string 字符串的左边第 start 个字符开始，向右截取 length 个字符。
${string: start} 从 string 字符串的左边第 start 个字符开始截取，直到最后。
${string: 0-start :length} 从 string 字符串的右边第 start 个字符开始，向右截取 length 个字符。
${string: 0-start} 从 string 字符串的右边第 start 个字符开始截取，直到最后。
${string#*chars} 从 string 字符串第一次出现 *chars 的位置开始，截取 *chars 右边的所有字符。
${string##*chars} 从 string 字符串最后一次出现 *chars 的位置开始，截取 *chars 右边的所有字符。
${string%*chars} 从 string 字符串第一次出现 *chars 的位置开始，截取 *chars 左边的所有字符。
${string%%*chars} 从 string 字符串最后一次出现 *chars 的位置开始，截取 *chars 左边的所有字符。
11、shell数组：
nums=(29 100 13 8 91 44) 定义数组，用括号( )来表示数组，数组元素之间用空格来分隔。元素不限定类型、不限定大小。
echo ${nums[@]} #输出所有数组元素
nums[10]=66 #给第10个元素赋值（此时会增加数组长度）
echo ${nums[*]} #输出所有数组元素
echo ${nums[4]} #输出第4个元素
n=${nums[2]} #获取第二个元素然后赋值给变量。
12、Shell获取数组长度，就是数组元素的个数。
nums=(29 100 13) 定义数组，有3个元素
echo ${#nums[*]} 输出数组元素个数
nums[10]="http://c.biancheng.net/shell/" #向数组中添加第四个，第10位元素
echo ${#nums[@]} 输出数组的元素个数
echo ${#nums[10]} 输出数组地10个元素的长度
unset nums[1] #删除数组元素
echo ${#nums[*]}
13、Shell数组拼接，Shell数组合并：
array1=(23 56) 定义数组
array2=(99 "http://c.biancheng.net/shell/") 定义数组
array_new=(${array1[@]} ${array2[*]}) 先利用@或*，将数组扩展成列表，然后再合并到一起。使用@和*是等价的。
echo ${array_new[@]} #也可以写作 ${array_new[*]}
14、Shell删除数组元素（也可以删除整个数组）：
使用 unset 关键字来删除数组元素，具体格式如下：
unset array_name[index] array_name 表示数组名，index 表示数组下标。
如果不写下标，而是写成下面的形式：
unset array_name 那么就是删除整个数组，所有元素都会消失。
15、Shell内建命令（内置命令）：
Shell 内建命令，就是由 Bash 自身提供的命令，而不是文件系统中的某个可执行文件。
可以使用 type 来确定一个命令是否是内建命令： type cd type ifconfig
内建命令会比外部命令执行得更快，执行外部命令时不但会触发磁盘 I/O，还需要 fork出一个单独的进程来执行，执行完成后再退出。而执行内建命令相当于调用当前 Shell 进程的一个函数。
Bash Shell 内建命令
命令 说明
: 扩展参数列表，执行重定向操作
. 读取并执行指定文件中的命令（在当前 shell 环境中）
alias 为指定命令定义一个别名
bg 将作业以后台模式运行
bind 将键盘序列绑定到一个 readline 函数或宏
break 退出 for、while、select 或 until 循环
builtin 执行指定的 shell 内建命令
caller 返回活动子函数调用的上下文
cd 将当前目录切换为指定的目录
command 执行指定的命令，无需进行通常的 shell 查找
compgen 为指定单词生成可能的补全匹配
complete 显示指定的单词是如何补全的
compopt 修改指定单词的补全选项
continue 继续执行 for、while、select 或 until 循环的下一次迭代
declare 声明一个变量或变量类型。
dirs 显示当前存储目录的列表
disown 从进程作业表中刪除指定的作业
echo 将指定字符串输出到 STDOUT
enable 启用或禁用指定的内建shell命令
eval 将指定的参数拼接成一个命令，然后执行该命令
exec 用指定命令替换 shell 进程
exit 强制 shell 以指定的退出状态码退出
export 设置子 shell 进程可用的变量
fc 从历史记录中选择命令列表
fg 将作业以前台模式运行
getopts 分析指定的位置参数
hash 查找并记住指定命令的全路径名
help 显示帮助文件
history 显示命令历史记录
jobs 列出活动作业
kill 向指定的进程 ID(PID) 发送一个系统信号
let 计算一个数学表达式中的每个参数
local 在函数中创建一个作用域受限的变量
logout 退出登录 shell
mapfile 从 STDIN 读取数据行，并将其加入索引数组
popd 从目录栈中删除记录
printf 使用格式化字符串显示文本
pushd 向目录栈添加一个目录
pwd 显示当前工作目录的路径名
read 从 STDIN 读取一行数据并将其赋给一个变量
readarray 从 STDIN 读取数据行并将其放入索引数组
readonly 从 STDIN 读取一行数据并将其赋给一个不可修改的变量
return 强制函数以某个值退出，这个值可以被调用脚本提取
set 设置并显示环境变量的值和 shell 属性
shift 将位置参数依次向下降一个位置
shopt 打开/关闭控制 shell 可选行为的变量值
source 读取并执行指定文件中的命令（在当前 shell 环境中）
suspend 暂停 Shell 的执行，直到收到一个 SIGCONT 信号
test 基于指定条件返回退出状态码 0 或 1
times 显示累计的用户和系统时间
trap 如果收到了指定的系统信号，执行指定的命令
type 显示指定的单词如果作为命令将会如何被解释
typeset 声明一个变量或变量类型。
ulimit 为系统用户设置指定的资源的上限
umask 为新建的文件和目录设置默认权限
unalias 刪除指定的别名
unset 刪除指定的环境变量或 shell 属性
wait 等待指定的进程完成，并返回退出状态码
16、Shell alias：给命令创建别名：
alisa 用来给命令创建一个别名。若直接输入该命令且不带任何参数，则列出当前 Shell 进程中使用了哪些别名。现在你应该能理解类似ll这样的命令为什么与ls -l的效果是一样的吧。
1、使用 alias 命令自定义别名，使用 alias 命令自定义别名的语法格式为：
alias new_name='command'
比如，一般的关机命令是shutdown-h now，写起来比较长，这时可以重新定义一个关机命令，以后就方便多了。
alias myShutdown='shutdown -h now'
别名只是临时的
在代码中使用 alias 命令定义的别名只能在当前 Shell 进程中使用，在子进程和其它进程中都不能使用。当前 Shell 进程结束后，别名也随之消失。
要想让别名对所有的 Shell 进程都有效，就得把别名写入 Shell 配置文件。Shell 进程每次启动时都会执行配置文件中的代码做一些初始化工作，将别名放在配置文件中，那么每次启动进程都会定义这个别名。
2、使用 unalias 命令删除别名
使用 unalias 内建命令可以删除当前 Shell 进程中的别名。unalias 有两种使用方法：
1）第一种用法是在命令后跟上某个命令的别名，用于删除指定的别名。
2）第二种用法是在命令后接-a参数，删除当前 Shell 进程中所有的别名。
同样，这两种方法都是在当前 Shell 进程中生效的。要想永久删除配置文件中定义的别名，只能进入该文件手动删除。
unalias ll # 删除 ll 别名
# 再次运行该命令时，报“找不到该命令”的错误，说明该别名被删除了
17、Shell echo命令：输出字符串
echo 是一个 Shell 内建命令，用来在终端输出字符串，
1、并在最后默认加上换行符。
echo "读者，你好！" #直接输出字符串
echo $url #输出变量
echo "${name}的网址是：${url}" #双引号包围的字符串中可以解析变量
echo '${name}的网址是：${url}' #单引号包围的字符串中不能解析变量
2、不换行，如果不希望换行，可以加上-n参数：
echo -n "${name} is ${age} years old, "
echo -n "${height}cm in height "
echo "and ${weight}kg in weight."
3、输出转义字符\n，默认情况下，echo 不会解析以反斜杠\开头的转义字符，-e参数来让 echo 命令解析转义字符：
echo -e "hello \nworld"
4、输出转义字符\c,有了-e参数，我们也可以使用转义字符\c来强制 echo 命令不换行了
echo -e "${name} is ${age} years old, \c"
echo -e "${height}cm in height \c"
18、Shell read命令：读取从键盘输入的数据：
read 是 Shell 内置命令，用来从标准输入中读取数据并赋值给变量。如果没有进行重定向，默认就是从键盘读取用户输入的数据；如果进行了重定向，那么可以从文件中读取数据。
read 命令的用法为：
read [-options] [variables]
options表示选项，如下表所示；variables表示用来存储数据的变量，可以有一个，也可以有多个。
options和variables都是可选的，如果没有提供变量名，那么读取的数据将存放到环境变量 REPLY 中。
Shell read 命令支持的选项
选项 说明
-a array 把读取的数据赋值给数组 array，从下标 0 开始。
-d delimiter 用字符串 delimiter 指定读取结束的位置，而不是一个换行符（读取到的数据不包括 delimiter）。
-e 在获取用户输入的时候，对功能键进行编码转换，不会直接显式功能键对应的字符。
-n num 读取 num 个字符，而不是整行字符。
-p prompt 显示提示信息，提示内容为 prompt。
-r 原样读取（Raw mode），不把反斜杠字符解释为转义字符。
-s 静默模式（Silent mode），不会在屏幕上显示输入的字符。当输入密码和其它确认信息的时候，这是很有必要的。
-t seconds 设置超时时间，单位为秒。如果用户没有在指定时间内输入完成，那么 read 将会返回一个非0的退出状态。表示读取失败。
-u fd 使用文件描述符 fd 作为输入源，而不是标准输入，类似于重定向。
1、使用 read 命令给多个变量赋值。
read -p "Enter some information > " name url age
注意，必须在一行内输入所有的值，不能换行，否则只能给第一个变量赋值，后续变量都会赋值失败。
本例还使用了-p选项，该选项会用一段文本来提示用户输入。
2、只读取一个字符。
read -n 1 -p "Enter a char > " char
-n 1表示只读取一个字符。运行脚本后，只要用户输入一个字符，立即读取结束，不用等待用户按下回车键。
printf "\n"语句用来达到换行的效果，否则 echo 的输出结果会和用户输入的内容位于同一行，不容易区分。
3、在指定时间内输入密码。
if
read -t 20 -sp "Enter password in 20 seconds(once) > " pass1 && printf "\n" && #第一次输入密码
read -t 20 -sp "Enter password in 20 seconds(again)> " pass2 && printf "\n" && #第二次输入密码
[ $pass1 == $pass2 ] #判断两次输入的密码是否相等
then
echo "Valid password"
else
echo "Invalid password"
fi
这段代码中，我们使用&&组合了多个命令，这些命令会依次执行，并且从整体上作为 if 语句的判断条件，只要其中一个命令执行失败（退出状态为非 0 值），整个判断条件就失败了，后续的命令也就没有必要执行了。
19、Shell exit命令：退出当前进程：
exit 是一个 Shell 内置命令，用来退出当前 Shell 进程，并返回一个退出状态；使用$?可以接收这个退出状态
exit 命令可以接受一个整数值作为参数，代表退出状态。如果不指定，默认状态值是 0。
一般情况下，退出状态为 0 表示成功，退出状态为非 0 表示执行失败（出错）了。
exit 退出状态只能是一个介于 0~255 之间的整数，其中只有 0 表示成功，其它值都表示失败。
Shell 进程执行出错时，可以根据退出状态来判断具体出现了什么错误，比如打开一个文件时，我们可以指定 1 表示文件不存在，2 表示文件没有读取权限，3 表示文件类型不对。
echo "befor exit"
exit 8
echo "after exit"
可以看到，"after exit"并没有输出，这说明遇到 exit 命令后，test.sh 执行就结束了。
注意，exit 表示退出当前 Shell 进程，我们必须在新进程中运行 test.sh，否则当前 Shell 会话（终端窗口）会被关闭，我们就无法看到输出结果了。
我们可以紧接着使用$?来获取 test.sh 的退出状态：
echo $?
8
20、Shell declare和typeset命令：设置变量属性：
declare 和 typeset 都是 Shell 内建命令，它们的用法相同，都用来设置变量的属性。不过 typeset 已经被弃用了，建议使用 declare 代替。
declare 命令的用法如下所示：
declare [+/-] [aAfFgilprtux] [变量名=变量值]
其中，-表示设置属性，+表示取消属性，aAfFgilprtux都是具体的选项，它们的含义如下表所示：
选项 含义
-f [name] 列出之前由用户在脚本中定义的函数名称和函数体。
-F [name] 仅列出自定义函数名称。
-g name 在 Shell 函数内部创建全局变量。
-p [name] 显示指定变量的属性和值。
-a name 声明变量为普通数组。
-A name 声明变量为关联数组（支持索引下标为字符串）。
-i name 将变量定义为整数型。
-r name[=value] 将变量定义为只读（不可修改和删除），等价于 readonly name。
-x name[=value] 将变量设置为环境变量，等价于 export name[=value]。
1、将变量声明为整数并进行计算。
declare -i m n ret #将多个变量声明为整数
m=10
n=30
ret=$m+$n
echo $ret
2、将变量定义为只读变量。
declare -r n=10
3、显示变量的属性和值。
declare -p n
21、Shell数学计算（算术运算，加减乘除运算）
如果要执行算术运算（数学计算），就离不开各种运算符号，和其他编程语言类似，Shell 也有很多算术运算符，下面就给大家介绍一下常见的 Shell 算术运算符，如下表所示。
Shell 算术运算符一览表
算术运算符 说明/含义
+、- 加法（或正号）、减法（或负号）
*、/、% 乘法、除法、取余（取模）
** 幂运算
++、-- 自增和自减，可以放在变量的前面也可以放在变量的后面
!、&&、|| 逻辑非（取反）、逻辑与（and）、逻辑或（or）
<、<=、>、>= 比较符号（小于、小于等于、大于、大于等于）
==、!=、= 比较符号（相等、不相等；对于字符串，= 也可以表示相当于）
<<、>> 向左移位、向右移位
~、|、 &、^ 按位取反、按位或、按位与、按位异或
=、+=、-=、*=、/=、%= 赋值运算符，例如 a+=1 相当于 a=a+1，a-=1 相当于 a=a-1
数学计算命令
要想让数学计算发挥作用，必须使用数学计算命令，Shell 中常用的数学计算命令如下表所示。
Shell 中常用的六种数学计算方式
运算操作符/运算命令 说明
(( )) 用于整数运算，效率很高，推荐使用。
let 用于整数运算，和 (()) 类似。
$[] 用于整数运算，不如 (()) 灵活。
expr 可用于整数运算，也可以处理字符串。比较麻烦，需要注意各种细节，不推荐使用。
bc Linux下的一个计算器程序，可以处理整数和小数。Shell 本身只支持整数运算，想计算小数就得使用 bc 这个外部的计算器。
declare -i 将变量定义为整数，然后再进行数学运算时就不会被当做字符串了。功能有限，仅支持最基本的数学运算（加减乘除和取余）
如果大家时间有限，只学习 (()) 和 bc 即可，不用学习其它的了：(()) 可以用于整数计算，bc 可以小数计算。
例子： (()) echo $((2+2))
let let ret=3+3 let ret=(3+4)
22、Shell (())：对整数进行数学运算：
双小括号 (( )) 是 Bash Shell 中专门用来进行整数运算的命令，它的效率很高，写法灵活，是企业运维中常用的运算命令。
注意：(( )) 只能进行整数运算，不能对小数（浮点数）或者字符串进行运算。后续讲到的 bc 命令可以用于小数运算。
双小括号 (( )) 的语法格式为：
((表达式)) 就是将数学运算表达式放在((和))之间。
表达式可以只有一个，也可以有多个，多个表达式之间以逗号,分隔。对于多个表达式的情况，以最后一个表达式的值作为整个 (( )) 命令的执行结果。
可以使用$获取 (( )) 命令的结果，这和使用$获得变量值是类似的。
(( )) 的用法
运算操作符/运算命令 说明
(a=10+66)
((b=a-15))
((c=a+b)) 这种写法可以在计算完成后给变量赋值。以 ((b=a-15)) 为例，即将 a-15 的运算结果赋值给变量 c。
注意，使用变量时不用加$前缀，(( )) 会自动解析变量名。
a=$((10+66)
b=$((a-15))
c=$((a+b)) 可以在 (( )) 前面加上$符号获取 (( )) 命令的执行结果，也即获取整个表达式的值。以 c=$((a+b)) 为例，即将 a+b 这个表达式的运算结果赋值给变量 c。
注意，类似 c=((a+b)) 这样的写法是错误的，不加$就不能取得表达式的结果。
((a>7 && b==c)) (( )) 也可以进行逻辑运算，在 if 语句中常会使用逻辑运算。
echo $((a+10)) 需要立即输出表达式的运算结果时，可以在 (( )) 前面加$符号。
((a=3+5, b=a+10)) 对多个表达式同时进行计算。
在 (( )) 中使用变量无需加上$前缀，(( )) 会自动解析变量名，这使得代码更加简洁，也符合程序员的书写习惯。
1、利用 (( )) 进行简单的数值计算：
echo $((1+1))
2、用 (( )) 进行稍微复杂一些的综合算术运算：
b=$((1+2**3-4%3)) #运算后将结果赋值给变量，变量放在了括号的外面。
echo $((1+2**3-4%3)) #也可以直接将表达式的结果输出，注意不要丢掉 $ 符号。
a=$((100*(100+1)/2)) #利用公式计算1+2+3+...+100的和。
echo $((100*(100+1)/2)) #也可以直接输出表达式的结果。
3、利用 (( )) 进行逻辑运算：
echo $((3<8)) #3<8 的结果是成立的，因此，输出了 1，1 表示真
echo $((8<3)) #8<3 的结果是不成立的，因此，输出了 0，0 表示假。
echo $((8==8)) #判断是否相等。
if ((8>7&&5==5))
> then
> echo yes
>else
>echo no
> fi
yes
最后是一个简单的 if 语句的格式，它的意思是，如果 8>7 成立，并且 5==5 成立，那么输出 yes。显然，这两个条件都是成立的，所以输出了 yes，不成立则输出no。
4、利用 (( )) 进行自增（++）和自减（--）运算：
a=10
echo $((a++)) #如果++在a的后面，那么在输出整个表达式时，会输出a的值,因为a为10，所以表达式的值为10。
echo $a #执行上面的表达式后，因为有a++，因此a会自增1，因此输出a的值为11。
echo $((a--)) #如果--在a的后面，那么在输出整个表达式时，会输出a的值，因为a为11，所以表达式的值的为11。
echo $a #执行上面的表达式后，因为有a--，因此a会自动减1，因此a为10。
echo $((--a)) #如果--在a的前面，那么在输出整个表达式时，先进行自增或自减计算，因为a为10，且要自减，所以表达式的值为9。
echo $((++a)) #如果++在a的前面，输出整个表达式时，先进行自增或自减计算，因为a为9，且要自增1，所以输出10。
5、利用 (( )) 同时对多个表达式进行计算：
((a=3+5, b=a+10)) #先计算第一个表达式，再计算第二个表达式，结果为：8 18
c=$((4+8, a+b)) #以最后一个表达式的结果作为整个(())命令的执行结果，结果为：26
23、Shell let命令：对整数进行数学运算：
let 命令和双小括号 (( )) 的用法是类似的，它们都是用来对整数进行运算
注意：和双小括号 (( )) 一样，let 命令也只能进行整数运算，不能对小数（浮点数）或者字符串进行运算。
Shell let 命令的语法格式为：
let 表达式 或者 let "表达式" 或者 let '表达式' 它们都等价于((表达式))。
当表达式中含有 Shell 特殊字符（例如 |）时，需要用双引号" "或者单引号' '将表达式包围起来。
和 (( )) 类似，let 命令也支持一次性计算多个表达式，并且以最后一个表达式的值作为整个 let 命令的执行结果。但是，对于多个表达式之间的分隔符，let 和 (( )) 是有区别的：
let 命令以空格来分隔多个表达式；
(( )) 以逗号,来分隔多个表达式。
1、给变量 i 加 8：
i=2
let i+=8
echo $i
10
2、let 后面可以跟多个表达式：
a=10 b=35
let a+=6 c=a+b #多个表达式以空格为分隔
echo $a $c
16 51
24、Shell if else语句（详解版）
Shell 也支持选择结构，并且有两种形式，分别是 if else 语句和 case in 语句。、
if 语句
最简单的用法就是只使用 if 语句，它的语法格式为：
if condition
then
statement(s)
fi
condition是判断条件，如果 condition 成立（返回“真”），那么 then 后边的语句将会被执行；如果 condition 不成立（返回“假”），那么不会执行任何语句。
从本质上讲，if 检测的是命令的退出状态，
注意，最后必须以fi来闭合，fi 就是 if 倒过来拼写。也正是有了 fi 来结尾，所以即使有多条语句也不需要用{ }包围起来。
如果你喜欢，也可以将 then 和 if 写在一行：
if condition; then
statement(s)
fi
请注意 condition 后边的分号;，当 if 和 then 位于同一行的时候，这个分号是必须的，否则会有语法错误。
1、使用 if 语句来比较两个数字的大小：
read a
read b
if (( $a == $b ))
then
echo "a和b相等"
fi
(())是一种数学计算命令，它除了可以进行最基本的加减乘除运算，还可以进行大于、小于、等于等关系运算，以及与、或、非逻辑运算。当 a 和 b 相等时，(( $a == $b ))判断条件成立，进入 if，执行 then 后边的 echo 语句。
2、在判断条件中也可以使用逻辑运算符：
read age
read iq
if (( $age > 18 && $iq < 60 ))
then
echo "你都成年了，智商怎么还不及格！"
echo "来C语言中文网（http://c.biancheng.net/）学习编程吧，能迅速提高你的智商。"
fi
&&就是逻辑“与”运算符，只有当&&两侧的判断条件都为“真”时，整个判断条件才为“真”。
即使 then 后边有多条语句，也不需要用{ }包围起来，因为有 fi 收尾呢。
3、if else 语句
如果有两个分支，就可以使用 if else 语句，它的格式为：
if condition
then
statement1
else
statement2
fi
如果 condition 成立，那么 then 后边的 statement1 语句将会被执行；否则，执行 else 后边的 statement2 语句。
4、if elif else 语句
Shell 支持任意数目的分支，当分支比较多时，可以使用 if elif else 结构，它的格式为：
if condition1
then
statement1
elif condition2
then
statement2
elif condition3
then
statement3
……
else
statementn
fi
注意，if 和 elif 后边都得跟着 then。
整条语句的执行逻辑为：
如果 condition1 成立，那么就执行 if 后边的 statement1；如果 condition1 不成立，那么继续执行 elif，判断 condition2。
如果 condition2 成立，那么就执行 statement2；如果 condition2 不成立，那么继续执行后边的 elif，判断 condition3。
如果 condition3 成立，那么就执行 statement3；如果 condition3 不成立，那么继续执行后边的 elif。
如果所有的 if 和 elif 判断都不成立，就进入最后的 else，执行 statementn。
25、Shell退出状态：
每一条 Shell 命令，不管是 Bash 内置命令（例如 cd、echo），还是外部的 Linux 命令（例如 ls、awk），还是自定义的 Shell 函数，当它退出（运行结束）时，都会返回一个比较小的整数值给调用（使用）它的程序，这就是命令的退出状态（exit statu）。
按照惯例来说，退出状态为 0 表示“成功”；也就是说，程序执行完成并且没有遇到任何问题。除 0 以外的其它任何退出状态都为“失败”。
Shell 的这个部分与你所熟悉的其它编程语言正好相反：在C语言、C++、Java、Python 中，0 表示“假”，其它值表示“真”。
退出状态和逻辑运算符的组合
Shell if 语句的一个神奇之处是允许我们使用逻辑运算符将多个退出状态组合起来，这样就可以一次判断多个条件了。
Shell 逻辑运算符
运算符 使用格式 说明
&& expression1 && expression2 逻辑与运算符，当 expression1 和 expression2 同时成立时，整个表达式才成立。
如果检测到 expression1 的退出状态为 0，就不会再检测 expression2 了，因为不管 expression2 的退出状态是什么，整个表达式必然都是不成立的，检测了也是多此一举。
|| expression1 || expression2 逻辑或运算符，expression1 和 expression2 两个表达式中只要有一个成立，整个表达式就成立。
如果检测到 expression1 的退出状态为 1，就不会再检测 expression2 了，因为不管 expression2 的退出状态是什么，整个表达式必然都是成立的，检测了也是多此一举。
! !expression 逻辑非运算符，相当于“取反”的效果。如果 expression 成立，那么整个表达式就不成立；如果 expression 不成立，那么整个表达式就成立。
1、将用户输入的 URL 写入到文件中。
read filename
read url
if test -w $filename && test -n $url
then
echo $url > $filename
echo "写入成功"
else
echo "写入失败"
fi
在 Shell 脚本文件所在的目录新建一个文本文件并命名为 urls.txt，然后运行 Shell 脚本，运行结果为：
urls.txt↙
http://c.biancheng.net/shell/↙
写入成功
test 是 Shell 内置命令，可以对文件或者字符串进行检测，其中，-w选项用来检测文件是否存在并且可写，-n选项用来检测字符串是否非空。
>表示重定向，默认情况下，echo 向控制台输出，这里我们将输出结果重定向到文件。
26、Shell test命令（Shell []）详解，附带所有选项及说明：
test 是 Shell 内置命令，用来检测某个条件是否成立。test 通常和 if 语句一起使用，并且大部分 if 语句都依赖 test。
test 命令有很多选项，可以进行数值、字符串和文件三个方面的检测。
Shell test 命令的用法为：
test expression
当 test 判断 expression 成立时，退出状态为 0，否则为非 0 值。
test 命令也可以简写为[]，它的用法为：
[ expression ]
注意[]和expression之间的空格，这两个空格是必须的，否则会导致语法错误。[]的写法更加简洁，比 test 使用频率高。
test 和 [] 是等价的，后续我们会交替使用 test 和 []，以让读者尽快熟悉。
1) 与文件检测相关的 test 选项
表1：test 文件检测相关选项列表
文件类型判断
选 项 作 用
-b filename 判断文件是否存在，并且是否为块设备文件。
-c filename 判断文件是否存在，并且是否为字符设备文件。
-d filename 判断文件是否存在，并且是否为目录文件。
-e filename 判断文件是否存在。
-f filename 判断文件是否存在，井且是否为普通文件。
-L filename 判断文件是否存在，并且是否为符号链接文件。
-p filename 判断文件是否存在，并且是否为管道文件。
-s filename 判断文件是否存在，并且是否为非空。
-S filename 判断该文件是否存在，并且是否为套接字文件。
文件权限判断
选 项 作 用
-r filename 判断文件是否存在，并且是否拥有读权限。
-w filename 判断文件是否存在，并且是否拥有写权限。
-x filename 判断文件是否存在，并且是否拥有执行权限。
-u filename 判断文件是否存在，并且是否拥有 SUID 权限。
-g filename 判断文件是否存在，并且是否拥有 SGID 权限。
-k filename 判断该文件是否存在，并且是否拥有 SBIT 权限。
文件比较
选 项 作 用
filename1 -nt filename2 判断 filename1 的修改时间是否比 filename2 的新。
filename -ot filename2 判断 filename1 的修改时间是否比 filename2 的旧。
filename1 -ef filename2 判断 filename1 是否和 filename2 的 inode 号一致，可以理解为两个文件是否为同一个文件。这个判断用于判断硬链接是很好的方法
2) 与数值比较相关的 test 选项
表2：test 数值比较相关选项列表
选 项 作 用
num1 -eq num2 判断 num1 是否和 num2 相等。
num1 -ne num2 判断 num1 是否和 num2 不相等。
num1 -gt num2 判断 num1 是否大于 num2 。
num1 -lt num2 判断 num1 是否小于 num2。
num1 -ge num2 判断 num1 是否大于等于 num2。
num1 -le num2 判断 num1 是否小于等于 num2。
注意，test 只能用来比较整数，小数相关的比较还得依赖 bc 命令。
3) 与字符串判断相关的 test 选项
表3：test 字符串判断相关选项列表
选 项 作 用
-z str 判断字符串 str 是否为空。
-n str 判断宇符串 str 是否为非空。
str1 = str2
str1 == str2 =和==是等价的，都用来判断 str1 是否和 str2 相等。
str1 != str2 判断 str1 是否和 str2 不相等。
str1 \> str2 判断 str1 是否大于 str2。\>是>的转义字符，这样写是为了防止>被误认为成重定向运算符。
str1 \< str2 判断 str1 是否小于 str2。同样，\<也是转义字符。
有C语言、C++、Python、Java 等编程经验的读者请注意，==、>、< 在大部分编程语言中都用来比较数字，而在 Shell 中，它们只能用来比较字符串，不能比较数字，这是非常奇葩的，大家要习惯。
其次，不管是比较数字还是字符串，Shell 都不支持 >= 和 <= 运算符，切记。
4) 与逻辑运算相关的 test 选项
表4：test 逻辑运算相关选项列表
选 项 作 用
expression1 -a expression 逻辑与，表达式 expression1 和 expression2 都成立，最终的结果才是成立的。
expression1 -o expression2 逻辑或，表达式 expression1 和 expression2 有一个成立，最终的结果就成立。
!expression 逻辑非，对 expression 进行取反。
5）在 test 中使用变量建议用双引号包围起来
test 和 [] 都是命令，一个命令本质上对应一个程序或者一个函数。即使是一个程序，它也有入口函数，所以也可以将一个程序等效为一个函数，这样我们就不用再区分函数和程序了，直接将一个命令和一个函数对应起来即可。
有了以上认知，就很容易看透命令的本质了：使用一个命令其实就是调用一个函数，命令后面附带的选项和参数最终都会作为实参传递给函数。
假设 test 命令对应的函数是 func()，使用test -z $str1命令时，会先将变量 $str1 替换成字符串：
如果 $str1 是一个正常的字符串，比如 abc123，那么替换后的效果就是test -z abc123，调用 func() 函数的形式就是func("-z abc123")。test 命令后面附带的所有选项和参数会被看成一个整体，并作为实参传递进函数。
如果 $str1 是一个空字符串，那么替换后的效果就是test -z ，调用 func() 函数的形式就是func("-z ")，这就比较奇怪了，因为-z选项没有和参数成对出现，func() 在分析时就会出错。
如果我们给 $str1 变量加上双引号，当 $str1 是空字符串时，test -z "$str1"就会被替换为test -z ""，调用 func() 函数的形式就是func("-z \"\"")，很显然，-z选项后面跟的是一个空字符串（\"表示转义字符），这样 func() 在分析时就不会出错了。
所以，当你在 test 命令中使用变量时，我强烈建议将变量用双引号""包围起来，这样能避免变量为空值时导致的很多奇葩问题。
6）总结
test 命令比较奇葩，>、<、== 只能用来比较字符串，不能用来比较数字，比较数字需要使用 -eq、-gt 等选项；不管是比较字符串还是数字，test 都不支持 >= 和 <=。有经验的程序员需要慢慢习惯 test 命令的这些奇葩用法。
对于整型数字的比较，我建议大家使用 (())，(()) 支持各种运算符，写法也符合数学规则。
几乎完全兼容 test ，并且比 test 更加强大，比 test 更加灵活的是[[ ]]；[[ ]]不是命令，而是 Shell 关键字。
27、Shell [[]]详解：检测某个条件是否成立：
[[ ]]是 Shell 内置关键字，它和 test 命令类似，也用来检测某个条件是否成立。
test 能做到的，[[ ]] 也能做到，而且 [[ ]] 做的更好；test 做不到的，[[ ]] 还能做到。可以认为 [[ ]] 是 test 的升级版，对细节进行了优化，并且扩展了一些功能。
[[ ]] 的用法为：
[[ expression ]]
当 [[ ]] 判断 expression 成立时，退出状态为 0，否则为非 0 值。注意[[ ]]和expression之间的空格，这两个空格是必须的，否则会导致语法错误。
1、[[ ]] 不需要注意某些细枝末节
[[ ]] 是 Shell 内置关键字，不是命令，在使用时没有给函数传递参数的过程，所以 test 命令的某些注意事项在 [[ ]] 中就不存在了，具体包括：
不需要把变量名用双引号""包围起来，即使变量是空值，也不会出错。
不需要、也不能对 >、< 进行转义，转义后会出错。
2、[[ ]] 支持逻辑运算符
对多个表达式进行逻辑运算时，可以使用逻辑运算符将多个 test 命令连接起来，例如：
[ -z "$str1" ] || [ -z "$str2" ]
你也可以借助选项把多个表达式写在一个 test 命令中，例如：
[ -z "$str1" -o -z "$str2" ]
但是，这两种写法都有点“别扭”，完美的写法是在一个命令中使用逻辑运算符将多个表达式连接起来。我们的这个愿望在 [[ ]] 中实现了，[[ ]] 支持 &&、|| 和 ! 三种逻辑运算符。
使用 [[ ]] 对上面的语句进行改进：
[[ -z $str1 || -z $str2 ]]
这种写法就比较简洁漂亮了。
注意，[[ ]] 剔除了 test 命令的-o和-a选项，你只能使用 || 和 &&。这意味着，你不能写成下面的形式：
[[ -z $str1 -o -z $str2 ]]
当然，使用逻辑运算符将多个 [[ ]] 连接起来依然是可以的，因为这是 Shell 本身提供的功能，跟 [[ ]] 或者 test 没有关系，如下所示：
[[ -z $str1 ]] || [[ -z $str2 ]]
3、 该表总结了各种写法的对错
test 或 [] [[ ]]
[ -z "$str1" ] || [ -z "$str2" ]√ [[ -z $str1 ]] || [[ -z $str2 ]] √
[ -z "$str1" -o -z "$str2" ] √ [[ -z $str1 -o -z $str2 ]] ×
[[ -z $str1 || -z $str2 ]] × [[ -z $str1 || -z $str2 ]] √
4、[[ ]] 支持正则表达式
在 Shell [[ ]] 中，可以使用=~来检测字符串是否符合某个正则表达式，它的用法为：
[[ str =~ regex ]]
str 表示字符串，regex 表示正则表达式。
read tel
if [[ $tel =~ ^1[0-9]{10}$ ]]
then
echo "你输入的是手机号码"
else
echo "你输入的不是手机号码"
fi
对^1[0-9]{10}$的说明：
^匹配字符串的开头（一个位置）；
[0-9]{10}匹配前面位的连续的十个数字；
$匹配字符串的末尾（一个位置）。
28、Shell case in语句详解：
Shell 也支持两种分支结构（选择结构），分别是 if else 语句和 case in 语句。在《Shell if else》一节中我们讲解了 if else 语句的用法，这节我们就来讲解 case in 语句。
当分支较多，并且判断条件比较简单时，使用 case in 语句就比较方便了。
1、接下来我们就正式开始讲解 case in的用法，它的基本格式如下：
case expression in
pattern1)
statement1
;;
pattern2)
statement2
;;
pattern3)
statement3
;;
……
*)
statementn
esac
1、case、in 和 esac 都是 Shell 关键字，expression 表示表达式，pattern 表示匹配模式。
2、expression 既可以是一个变量、一个数字、一个字符串，还可以是一个数学计算表达式，或者是命令的执行结果，只要能够得到 expression 的值就可以。
3、pattern 可以是一个数字、一个字符串，甚至是一个简单的正则表达式。
4、case 会将 expression 的值与 pattern1、pattern2、pattern3 逐个进行匹配：
5、如果 expression 和某个模式（比如 pattern2）匹配成功，就会执行这模式（比如 pattern2）后面对应的所有语句（该语句可以有一条，也可以有多条），直到遇见双分号;;才停止；然后整个 case 语句就执行完了，程序会跳出整个 case 语句，执行 esac 后面的其它语句。
6、如果 expression 没有匹配到任何一个模式，那么就执行*)后面的语句（*表示其它所有值），直到遇见双分号;;或者esac才结束。*)相当于多个 if 分支语句中最后的 else 部分。
7、如果你有C语言、C++、Java 等编程经验，这里的;;和*)就相当于其它编程语言中的 break 和 default。
8、对*)的几点说明：
1、Shell case in 语句中的*)用来“托底”，万一 expression 没有匹配到任何一个模式，*)部分可以做一些“善后”工作，或者给用户一些提示。
可以没有*)部分。如果 expression 没有匹配到任何一个模式，那么就不执行任何操作。
2、除最后一个分支外（这个分支可以是普通分支，也可以是*)分支），其它的每个分支都必须以;;结尾，;;代表一个分支的结束，不写的话会有语法错误。最后一个分支可以写;;，也可以不写，因为无论如何，执行到 esac 都会结束整个 case in 语句。
3、上面的代码是 case in 最常见的用法，即 expression 部分是一个变量，pattern 部分是一个数字或者表达式。
2、case in 和正则表达式
case in 的 pattern 部分支持简单的正则表达式，具体来说，可以使用以下几种格式：
格式 说明
* 表示任意字符串。
[abc] 表示 a、b、c 三个字符中的任意一个。比如，[15ZH] 表示 1、5、Z、H 四个字符中的任意一个。
[m-n] 表示从 m 到 n 的任意一个字符。比如，[0-9] 表示任意一个数字，[0-9a-zA-Z] 表示字母或数字。
| 表示多重选择，类似逻辑运算中的或运算。比如，abc | xyz 表示匹配字符串 "abc" 或者 "xyz"。
如果不加以说明，Shell 的值都是字符串，expression 和 pattern 也是按照字符串的方式来匹配的；本节第一段代码看起来是判断数字是否相等，其实是判断字符串是否相等。
最后一个分支*)并不是什么语法规定，它只是一个正则表达式，*表示任意字符串，所以不管 expression 的值是什么，*)总能匹配成功。
下面的例子演示了如何在 case in 中使用正则表达式：
#!/bin/bash
printf "Input a character: "
read -n 1 char
case $char in
[a-zA-Z])
printf "\nletter\n"
;;
[0-9])
printf "\nDigit\n"
;;
[0-9])
printf "\nDigit\n"
;;
[,.?!])
printf "\nPunctuation\n"
;;
*)
printf "\nerror\n"
esac
运行结果1：
Input integer number: S
letter
运行结果2：
Input integer number: ,
Punctuation
29、Shell while循环详解：
while 循环是 Shell 脚本中最简单的一种循环，当条件满足时，while 重复地执行一组语句，当条件不满足时，就退出 while 循环。
Shell while 循环的用法如下：
while condition
do
statements
done
condition表示判断条件，statements表示要执行的语句（可以只有一条，也可以有多条），do和done都是 Shell 中的关键字。
1、while 循环的执行流程为：
先对 condition 进行判断，如果该条件成立，就进入循环，执行 while 循环体中的语句，也就是 do 和 done 之间的语句。这样就完成了一次循环。
每一次执行到 done 的时候都会重新判断 condition 是否成立，如果成立，就进入下一次循环，继续执行 do 和 done 之间的语句，如果不成立，就结束整个 while 循环，执行 done 后面的其它 Shell 代码。
如果一开始 condition 就不成立，那么程序就不会进入循环体，do 和 done 之间的语句就没有执行的机会。
注意，在 while 循环体中必须有相应的语句使得 condition 越来越趋近于“不成立”，只有这样才能最终退出循环，否则 while 就成了死循环，会一直执行下去，永无休止。
while 语句和 if else 语句中的 condition 用法都是一样的，你可以使用 test 或 [] 命令，也可以使用 (()) 或 [[]]
2、实现一个简单的加法计算器，用户每行输入一个数字，计算所有数字的和。
#!/bin/bash
sum=0
echo "请输入您要计算的数字，按 Ctrl+D 组合键结束读取"
while read n
do
((sum += n))
done
echo "The sum is: $sum"
运行结果：
12↙
33↙
454↙
6767↙
1↙
2↙
The sum is: 7269
在终端中读取数据，可以等价为在文件中读取数据，按下 Ctrl+D 组合键表示读取到文件流的末尾，此时 read 就会读取失败，得到一个非 0 值的退出状态，从而导致判断条件不成立，结束循环。
30、Shell until循环用法详解：
unti 循环和 while 循环恰好相反，当判断条件不成立时才进行循环，一旦判断条件成立，就终止循环。
Shell until 循环的用法如下：
until condition
do
statements
done
condition表示判断条件，statements表示要执行的语句（可以只有一条，也可以有多条），do和done都是 Shell 中的关键字。
1、until 循环的执行流程为：
1、先对 condition 进行判断，如果该条件不成立，就进入循环，执行 until 循环体中的语句（do 和 done 之间的语句），这样就完成了一次循环。
2、每一次执行到 done 的时候都会重新判断 condition 是否成立，如果不成立，就进入下一次循环，继续执行循环体中的语句，如果成立，就结束整个 until 循环，执行 done 后面的其它 Shell 代码。
3、如果一开始 condition 就成立，那么程序就不会进入循环体，do 和 done 之间的语句就没有执行的机会。
4、注意，在 until 循环体中必须有相应的语句使得 condition 越来越趋近于“成立”，只有这样才能最终退出循环，否则 until 就成了死循环，会一直执行下去，永无休止。
2、如何求从 1 加到 100 的值，这节我们改用 until 循环，请看下面的代码：
#!/bin/bash
i=1
sum=0
until ((i > 100))
do
((sum += i))
((i++))
done
echo "The sum is: $sum"
运行结果：
The sum is: 5050
在 while 循环中，判断条件为((i<=100))，这里将判断条件改为((i>100))，两者恰好相反，请读者注意区分。
31、Shell for循环和for int循环详解：
除了 while 循环和 until 循环，Shell 脚本还提供了 for 循环，它更加灵活易用，更加简洁明了。Shell for 循环有两种使用形式，下面我们逐一讲解。
1、C语言风格的 for 循环：
for((exp1; exp2; exp3))
do
statements
done
几点说明：
exp1、exp2、exp3 是三个表达式，其中 exp2 是判断条件，for 循环根据 exp2 的结果来决定是否继续下一次循环；
statements 是循环体语句，可以有一条，也可以有多条；
do 和 done 是 Shell 中的关键字。
它的运行过程为：
1) 先执行 exp1。
2) 再执行 exp2，如果它的判断结果是成立的，则执行循环体中的语句，否则结束整个 for 循环。
3) 执行完循环体后再执行 exp3。
4) 重复执行步骤 2) 和 3)，直到 exp2 的判断结果不成立，就结束循环。
上面的步骤中，2) 和 3) 合并在一起算作一次循环，会重复执行，for 语句的主要作用就是不断执行步骤 2) 和 3)。
exp1 仅在第一次循环时执行，以后都不会再执行，可以认为这是一个初始化语句。exp2 一般是一个关系表达式，决定了是否还要继续下次循环，称为“循环条件”。exp3 很多情况下是一个带有自增或自减运算的表达式，以使循环条件逐渐变得“不成立”。
2、Python 风格的 for in 循环：
for variable in value_list
do
statements
done
variable 表示变量，value_list 表示取值列表，in 是 Shell 中的关键字。
in value_list 部分可以省略，省略后的效果相当于 in $@，本文末尾的「value_list 使用特殊变量」将会详细讲解。
每次循环都会从 value_list 中取出一个值赋给变量 variable，然后进入循环体（do 和 done 之间的部分），执行循环体中的 statements。直到取完 value_list 中的所有值，循环就结束了。
1、Shell for in 循环举例：
#!/bin/bash
sum=0
for n in 1 2 3 4 5 6
do
echo $n
((sum+=n))
done
echo "The sum is "$sum
2、对 value_list 的说明：
取值列表 value_list 的形式有多种，你可以直接给出具体的值，也可以给出一个范围，还可以使用命令产生的结果，甚至使用通配符，下面我们一一讲解。
1) 直接给出具体的值
可以在 in 关键字后面直接给出具体的值，多个值之间以空格分隔，比如1 2 3 4 5、"abc" "390" "tom"等。
2) 给出一个取值范围：
{start..end}
start 表示起始值，end 表示终止值；注意中间用两个点号相连，而不是三个点号。根据笔者的实测，这种形式只支持数字和字母。
Shell 是根据 ASCII 码表来输出的。
3) 使用命令的执行结果
使用反引号``或者$()都可以取得命令的执行结果，我们在《Shell变量》一节中已经进行了详细讲解，并对比了两者的优缺点。本节我们使用$()这种形式，因为它不容易产生混淆。
计算从 1 到 100 之间所有偶数的和：
#!/bin/bash
sum=0
for n in $(seq 2 2 100)
do
((sum+=n))
done
echo $sum
运行结果：
2550
seq 是一个 Linux 命令，用来产生某个范围内的整数，并且可以设置步长，不了解的读者请自行百度。seq 2 2 100表示从 2 开始，每次增加 2，到 100 结束。
再如，列出当前目录下的所有 Shell 脚本文件：
#!/bin/bash
for filename in $(ls *.sh)
do
echo $filename
done
运行结果：
demo.sh
test.sh
abc.sh
ls 是一个 Linux 命令，用来列出当前目录下的所有文件，*.sh表示匹配后缀为.sh的文件，也就是 Shell 脚本文件。
4) 使用 Shell 通配符
Shell 通配符可以认为是一种精简化的正则表达式，通常用来匹配目录或者文件，而不是文本。
有了 Shell 通配符，不使用 ls 命令也能显示当前目录下的所有脚本文件，请看下面的代码：
#!/bin/bash
for filename in *.sh
do
echo $filename
done
运行结果：
demo.sh
test.sh
abc.sh
5) 使用特殊变量
Shell 中有多个特殊的变量，例如 $#、$*、$@、$?、$$ 等（不了解的读者请猛击《Shell特殊变量》），在 value_list 中就可以使用它们。
#!/bin/bash
function func(){
for str in $@
do
echo $str
done
}
func C++ Java Python C#
运行结果：
C++
Java
Python
C#
其实，我们也可以省略 value_list，省略后的效果和使用$@一样。请看下面的演示：
#!/bin/bash
function func(){
for str
do
echo $str
done
}
func C++ Java Python C#
运行结果：
C++
Java
Python
C#
32、Shell select in循环详解：
select in 循环用来增强交互性，它可以显示出带编号的菜单，用户输入不同的编号就可以选择不同的菜单，并执行不同的功能。
select in 是 Shell 独有的一种循环，非常适合终端（Terminal）这样的交互场景
Shell select in 循环的用法如下：
select variable in value_list
do
statements
done
variable 表示变量，value_list 表示取值列表，in 是 Shell 中的关键字。你看，select in 和 for in 的语法是多么地相似。
1、看一个 select in 循环的例子：
#!/bin/bash
echo "What is your favourite OS?"
select name in "Linux" "Windows" "Mac OS" "UNIX" "Android"
do
echo $name
done
echo "You have selected $name"
运行结果：
What is your favourite OS?
1) Linux
2) Windows
3) Mac OS
4) UNIX
5) Android
#? 4↙
You have selected UNIX
#? 1↙
You have selected Linux
#? 9↙
You have selected
#? 2↙
You have selected Windows
#?^D
#?用来提示用户输入菜单编号；^D表示按下 Ctrl+D 组合键，它的作用是结束 select in 循环。
运行到 select 语句后，取值列表 value_list 中的内容会以菜单的形式显示出来，用户输入菜单编号，就表示选中了某个值，这个值就会赋给变量 variable，然后再执行循环体中的 statements（do 和 done 之间的部分）。
每次循环时 select 都会要求用户输入菜单编号，并使用环境变量 PS3 的值作为提示符，PS3 的默认值为#?，修改 PS3 的值就可以修改提示符。
如果用户输入的菜单编号不在范围之内，例如上面我们输入的 9，那么就会给 variable 赋一个空值；如果用户输入一个空值（什么也不输入，直接回车），会重新显示一遍菜单。
注意，select 是无限循环（死循环），输入空值，或者输入的值无效，都不会结束循环，只有遇到 break 语句，或者按下 Ctrl+D 组合键才能结束循环。
2、select in 通常和 case in 一起使用，在用户输入不同的编号时可以做出不同的反应。
加入 case in 语句：
#!/bin/bash
echo "What is your favourite OS?"
select name in "Linux" "Windows" "Mac OS" "UNIX" "Android"
do
case $name in
"Linux")
echo "Linux是一个类UNIX操作系统，它开源免费，运行在各种服务器设备和嵌入式设备。"
break
;;
"Windows")
echo "Windows是微软开发的个人电脑操作系统，它是闭源收费的。"
break
;;
"Mac OS")
echo "Mac OS是苹果公司基于UNIX开发的一款图形界面操作系统，只能运行与苹果提供的硬件之上。"
break
;;
"UNIX")
echo "UNIX是操作系统的开山鼻祖，现在已经逐渐退出历史舞台，只应用在特殊场合。"
break
;;
"Android")
echo "Android是由Google开发的手机操作系统，目前已经占据了70%的市场份额。"
break
;;
*)
echo "输入错误，请重新输入"
esac
done
用户只有输入正确的编号才会结束循环，如果输入错误，会要求重新输入。
33、Shell break和continue跳出循环详解：
使用 while、until、for、select 循环时，如果想提前结束循环（在不满足结束条件的情况下结束循环），可以使用 break 或者 continue 关键字。
在C语言、C++、C#、Python、Java 等大部分编程语言中，break 和 continue 只能跳出当前层次的循环，内层循环中的 break 和 continue 对外层循环不起作用；但是 Shell 中的 break 和 continue 却能够跳出多层循环，也就是说，内层循环中的 break 和 continue 能够跳出外层循环。
在实际开发中，break 和 continue 一般只用来跳出当前层次的循环，很少有需要跳出多层循环的情况。
break 关键字
Shell break 关键字的用法为：
break n
n 表示跳出循环的层数，如果省略 n，则表示跳出当前的整个循环。break 关键字通常和 if 语句一起使用，即满足条件时便跳出循环。
1、使用 break 跳出双层循环。
如果 break 后面不跟数字的话，表示跳出当前循环，对于有两层嵌套的循环，就得使用两个 break 关键字。例如，输出一个 4*4 的矩阵：
#!/bin/bash
i=0
while ((++i)); do #外层循环
if((i>4)); then
break #跳出外层循环
fi
j=0;
while ((++j)); do #内层循环
if((j>4)); then
break #跳出内层循环
fi
printf "%-4d" $((i*j))
done
printf "\n"
done
运行结果：
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
当 j>4 成立时，执行第二个 break，跳出内层循环；外层循环依然执行，直到 i>4 成立，跳出外层循环。内层循环共执行了 4 次，外层循环共执行了 1 次。
2、也可以在 break 后面跟一个数字，让它一次性地跳出两层循环，请看下面的代码：
#!/bin/bash
i=0
while ((++i)); do #外层循环
j=0;
while ((++j)); do #内层循环
if((i>4)); then
break 2 #跳出内外两层循环
fi
if((j>4)); then
break #跳出内层循环
fi
printf "%-4d" $((i*j))
done
printf "\n"
done
修改后的代码将所有 break 都移到了内层循环里面。读者需要重点关注break 2这条语句，它使得程序可以一次性跳出两层循环，也就是先跳出内层循环，再跳出外层循环。
3、continue 关键字
Shell continue 关键字的用法为：
continue n
n 表示循环的层数：
如果省略 n，则表示 continue 只对当前层次的循环语句有效，遇到 continue 会跳过本次循环，忽略本次循环的剩余代码，直接进入下一次循环。
如果带上 n，比如 n 的值为 2，那么 continue 对内层和外层循环语句都有效，不但内层会跳过本次循环，外层也会跳过本次循环，其效果相当于内层循环和外层循环同时执行了不带 n 的 continue。这么说可能有点难以理解，稍后我们通过代码来演示。
4、不断从终端读取用户输入的 100 以内的正数，求它们的和：
#!/bin/bash
sum=0
while read n; do
if((n<1 || n>100)); then
continue
fi
((sum+=n))
done
echo "sum=$sum"
运行结果：
10↙
20↙
-1000↙
5↙
9999↙
25↙
sum=60
变量 sum 最终的值为 60，-1000 和 9999 并没有计算在内，这是因为 -1000 和 9999 不在 1~100 的范围内，if 判断条件成立，所以执行了 continue 语句，跳过了当次循环，也就是跳过了((sum+=n))这条语句。
注意，只有按下 Ctrl+D 组合键输入才会结束，read n才会判断失败，while 循环才会终止。
5、使用 continue 跳出多层循环，请看下面的代码：
#!/bin/bash
for((i=1; i<=5; i++)); do
for((j=1; j<=5; j++)); do
if((i*j==12)); then
continue 2
fi
printf "%d*%d=%-4d" $i $j $((i*j))
done
printf "\n"
done
运行结果：
1*1=1 1*2=2 1*3=3 1*4=4 1*5=5
2*1=2 2*2=4 2*3=6 2*4=8 2*5=10
3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
从运行结果可以看出，遇到continue 2时，不但跳过了内层 for 循环，也跳过了外层 for 循环。
6、break 和 continue 的区别
break 用来结束所有循环，循环语句不再有执行的机会；continue 用来结束本次循环，直接跳到下一次循环，如果循环条件成立，还会继续循环。
34、Shell函数详解（函数定义、函数调用）：
Shell 函数的本质是一段可以重复使用的脚本代码，这段代码被提前编写好了，放在了指定的位置，使用时直接调取即可。
Shell 中的函数和C++、Java、Python、C# 等其它编程语言中的函数类似，只是在语法细节有所差别。
Shell 函数定义的语法格式如下：
function name() {
statements
[return value]
}
对各个部分的说明：
function是 Shell 中的关键字，专门用来定义函数；
name是函数名；
statements是函数要执行的代码，也就是一组语句；
return value表示函数的返回值，其中 return 是 Shell 关键字，专门用在函数中返回一个值；这一部分可以写也可以不写。
由{ }包围的部分称为函数体，调用一个函数，实际上就是执行函数体中的代码。
函数定义的简化写法
如果你嫌麻烦，函数定义时也可以不写 function 关键字：
name() {
statements
[return value]
}
如果写了 function 关键字，也可以省略函数名后面的小括号：
function name {
statements
[return value]
}
我建议使用标准的写法，这样能够做到“见名知意”，一看就懂。
函数调用
调用 Shell 函数时可以给它传递参数，也可以不传递。如果不传递参数，直接给出函数名字即可：
name
如果传递参数，那么多个参数之间以空格分隔：
name param1 param2 param3
不管是哪种形式，函数名字后面都不需要带括号。
和其它编程语言不同的是，Shell 函数在定义时不能指明参数，但是在调用时却可以传递参数，并且给它传递什么参数它就接收什么参数。
Shell 也不限制定义和调用的顺序，你可以将定义放在调用的前面，也可以反过来，将定义放在调用的后面。
1) 定义一个函数，输出 Shell 教程的地址：
#!/bin/bash
#函数定义
function url(){
echo "http://c.biancheng.net/shell/"
}
#函数调用
url
运行结果：
http://c.biancheng.net/shell/
你可以将调用放在定义的前面，也就是写成下面的形式：
#!/bin/bash
#函数调用
url
#函数定义
function url(){
echo "http://c.biancheng.net/shell/"
}
2) 定义一个函数，计算所有参数的和：
#!/bin/bash
function getsum(){
local sum=0
for n in $@
do
((sum+=n))
done
return $sum
}
getsum 10 20 55 15 #调用函数并传递参数
echo $?
运行结果：
100
$@表示函数的所有参数，$?表示函数的退出状态（返回值）。
35、Shell函数参数：
Shell 中的函数在定义时不能指明参数，但是在调用时却可以传递参数。
函数参数是 Shell 位置参数的一种，在函数内部可以使用$n来接收，例如，$1 表示第一个参数，$2 表示第二个参数，依次类推。
除了$n，还有另外三个比较重要的变量：
$#可以获取传递的参数的个数；
$@或者$*可以一次性获取所有的参数。
$n、$#、$@、$* 都属于特殊变量，。
1、【实例1】使用 $n 来接收函数参数。
#!/bin/bash
#定义函数
function show(){
echo "Tutorial: $1"
echo "URL: $2"
echo "Author: "$3
echo "Total $# parameters"
}
#调用函数
show C# http://c.biancheng.net/csharp/ Tom
运行结果：
Tutorial: C#
URL: http://c.biancheng.net/csharp/
Author: Tom
Total 3 parameters
注意，第 7 行代码的写法有点不同，这里使用了 Shell 字符串拼接技巧。
2、【实例2】使用 $@ 来遍历函数参数。
定义一个函数，计算所有参数的和：
#!/bin/bash
function getsum(){
local sum=0
for n in $@
do
((sum+=n))
done
echo $sum
return 0
}
#调用函数并传递参数，最后将结果赋值给一个变量
total=$(getsum 10 20 55 15)
echo $total
#也可以将变量省略
echo $(getsum 10 20 55 15)
运行结果：
100
100
36、Linux Shell重定向（输入输出重定向）精讲：
1、Linux Shell 重定向分为两种，一种输入重定向，一种是输出重定向；从字面上理解，输入输出重定向就是「改变输入与输出的方向」的意思。
2、那么，什么是输入输出方向呢？标准的输入输出方向又是什么呢？
一般情况下，我们都是从键盘读取用户输入的数据，然后再把数据拿到程序（C语言程序、Shell 脚本程序等）中使用；这就是标准的输入方向，也就是从键盘到程序。
反过来说，程序中也会产生数据，这些数据一般都是直接呈现到显示器上，这就是标准的输出方向，也就是从程序到显示器。
3、我们可以把观点提炼一下，其实输入输出方向就是数据的流动方向：
输入方向就是数据从哪里流向程序。数据默认从键盘流向程序，如果改变了它的方向，数据就从其它地方流入，这就是输入重定向。
输出方向就是数据从程序流向哪里。数据默认从程序流向显示器，如果改变了它的方向，数据就流向其它地方，这就是输出重定向。
4、硬件设备和文件描述符
计算机的硬件设备有很多，常见的输入设备有键盘、鼠标、麦克风、手写板等，输出设备有显示器、投影仪、打印机等。不过，在 Linux 中，标准输入设备指的是键盘，标准输出设备指的是显示器。
5、Linux 中一切皆文件，包括标准输入设备（键盘）和标准输出设备（显示器）在内的所有计算机硬件都是文件。
为了表示和区分已经打开的文件，Linux 会给每个文件分配一个 ID，这个 ID 就是一个整数，被称为文件描述符（File Descriptor）。
表1：与输入输出有关的文件描述符
文件描述符 文件名 类型 硬件
0 stdin 标准输入文件 键盘
1 stdout 标准输出文件 显示器
2 stderr 标准错误输出文件 显示器
6、Linux 程序在执行任何形式的 I/O 操作时，都是在读取或者写入一个文件描述符。一个文件描述符只是一个和打开的文件相关联的整数，它的背后可能是一个硬盘上的普通文件、FIFO、管道、终端、键盘、显示器，甚至是一个网络连接。
stdin、stdout、stderr 默认都是打开的，在重定向的过程中，0、1、2 这三个文件描述符可以直接使用。
7、Linux Shell 输出重定向
输出重定向是指命令的结果不再输出到显示器上，而是输出到其它地方，一般是文件中。这样做的最大好处就是把命令的结果保存起来，当我们需要的时候可以随时查询。Bash 支持的输出重定向符号如下表所示。
表2：Bash 支持的输出重定向符号
类 型 符 号 作 用
标准输出重定向 command >file 以覆盖的方式，把 command 的正确输出结果输出到 file 文件中。
command >>file 以追加的方式，把 command 的正确输出结果输出到 file 文件中。
标准错误输出重定向 command 2>file 以覆盖的方式，把 command 的错误信息输出到 file 文件中。
command 2>>file 以追加的方式，把 command 的错误信息输出到 file 文件中。
正确输出和错误信息同时保存 command >file 2>&1 以覆盖的方式，把正确输出和错误信息同时保存到同一个文件（file）中。
command >>file 2>&1 以追加的方式，把正确输出和错误信息同时保存到同一个文件（file）中。
command >file1 2>file2 以覆盖的方式，把正确的输出结果输出到 file1 文件中，把错误信息输出到 file2 文件中。
command >>file1 2>>file2 以追加的方式，把正确的输出结果输出到 file1 文件中，把错误信息输出到 file2 文件中。
command >file 2>file 【不推荐】这两种写法会导致 file 被打开两次，引起资源竞争，所以 stdout 和 stderr 会互相覆盖，
command >>file 2>>file
在输出重定向中，>代表的是覆盖，>>代表的是追加。
注意
输出重定向的完整写法其实是fd>file或者fd>>file，其中 fd 表示文件描述符，如果不写，默认为 1，也就是标准输出文件。
当文件描述符为 1 时，一般都省略不写，如上表所示；当然，如果你愿意，也可以将command >file写作command 1>file，但这样做是多此一举。
当文件描述符为大于 1 的值时，比如 2，就必须写上。
需要重点说明的是，fd和>之间不能有空格，否则 Shell 会解析失败；>和file之间的空格可有可无。为了保持一致，我习惯在>两边都不加空格。
1、【实例1】将 echo 命令的输出结果以追加的方式写入到 demo.txt 文件中。
#!/bin/bash
for str in "C语言中文网" "http://c.biancheng.net/" "成立7年了" "日IP数万"
do
echo $str >>demo.txt #将输入结果以追加的方式重定向到文件
done
运行以上脚本，使用cat demo.txt查看文件内容，显示如下：
C语言中文网
http://c.biancheng.net/
成立7年了
日IP数万
2、【实例2】将ls -l命令的输出结果重定向到文件中。
[c.biancheng.net]$ ls -l #先预览一下输出结果
总用量 16
drwxr-xr-x. 2 root root 21 7月 1 2016 abc
-rw-r--r--. 1 mozhiyan mozhiyan 399 3月 11 17:12 demo.sh
-rw-rw-r--. 1 mozhiyan mozhiyan 67 3月 22 17:16 demo.txt
-rw-rw-r--. 1 mozhiyan mozhiyan 278 3月 16 17:17 main.c
-rwxr-xr-x. 1 mozhiyan mozhiyan 187 3月 22 17:16 test.sh
[c.biancheng.net]$ ls -l >demo.txt #重定向
[c.biancheng.net]$ cat demo.txt #查看文件内容
总用量 12
drwxr-xr-x. 2 root root 21 7月 1 2016 abc
-rw-r--r--. 1 mozhiyan mozhiyan 399 3月 11 17:12 demo.sh
-rw-rw-r--. 1 mozhiyan mozhiyan 0 3月 22 17:21 demo.txt
-rw-rw-r--. 1 mozhiyan mozhiyan 278 3月 16 17:17 main.c
-rwxr-xr-x. 1 mozhiyan mozhiyan 187 3月 22 17:16 test.sh
3、错误输出重定向举例
命令正确执行是没有错误信息的，我们必须刻意地让命令执行出错，如下所示：
[c.biancheng.net]$ ls java #先预览一下错误信息
ls: 无法访问java: 没有那个文件或目录
[c.biancheng.net]$ ls java 2>err.log #重定向
[c.biancheng.net]$ cat err.log #查看文件
ls: 无法访问java: 没有那个文件或目录
4、正确输出和错误信息同时保存
1、【实例1】把正确结果和错误信息都保存到一个文件中，例如：
[c.biancheng.net]$ ls -l >out.log 2>&1
[c.biancheng.net]$ ls java >>out.log 2>&1
[c.biancheng.net]$ cat out.log
总用量 12
drwxr-xr-x. 2 root root 21 7月 1 2016 abc
-rw-r--r--. 1 mozhiyan mozhiyan 399 3月 11 17:12 demo.sh
-rw-rw-r--. 1 mozhiyan mozhiyan 278 3月 16 17:17 main.c
-rw-rw-r--. 1 mozhiyan mozhiyan 0 3月 22 17:39 out.log
-rwxr-xr-x. 1 mozhiyan mozhiyan 187 3月 22 17:16 test.sh
ls: 无法访问java: 没有那个文件或目录
out.log 的最后一行是错误信息，其它行都是正确的输出结果。
2、【实例2】上面的实例将正确结果和错误信息都写入同一个文件中，这样会导致视觉上的混乱，不利于以后的检索，所以我建议把正确结果和错误信息分开保存到不同的文件中，也即写成下面的形式：
ls -l >>out.log 2>>err.log
这样一来，正确的输出结果会写入到 out.log，而错误的信息则会写入到 err.log。
/dev/null 文件
5、如果你既不想把命令的输出结果保存到文件，也不想把命令的输出结果显示到屏幕上，干扰命令的执行，那么可以把命令的所有结果重定向到 /dev/null 文件中。如下所示：
ls -l &>/dev/null
大家可以把 /dev/null 当成 Linux 系统的垃圾箱，任何放入垃圾箱的数据都会被丢弃，不能恢复。
6、Linux Shell 输入重定向
输入重定向就是改变输入的方向，不再使用键盘作为命令输入的来源，而是使用文件作为命令的输入。
表3：Bash 支持的输出重定向符号
符号 说明
command <file 将 file 文件中的内容作为 command 的输入。
command <<END 从标准输入（键盘）中读取数据，直到遇见分界符 END 才停止（分界符可以是任意的字符串，用户自己定义）。
command <file1 >file2 将 file1 作为 command 的输入，并将 command 的处理结果输出到 file2。
和输出重定向类似，输入重定向的完整写法是fd<file，其中 fd 表示文件描述符，如果不写，默认为 0，也就是标准输入文件。
输入重定向举例
1、【示例1】统计文档中有多少行文字。
Linux wc 命令可以用来对文本进行统计，包括单词个数、行数、字节数，它的用法如下：
wc [选项] [文件名]
其中，-c选项统计字节数，-w选项统计单词数，-l选项统计行数。
统计 readme.txt 文件中有多少行文本：
[c.biancheng.net]$ cat readme.txt #预览一下文件内容
C语言中文网
http://c.biancheng.net/
成立7年了
日IP数万
[c.biancheng.net]$ wc -l <readme.txt #输入重定向
4
2、【实例2】逐行读取文件内容。
#!/bin/bash
while read str; do
echo $str
done <readme.txt
运行结果：
C语言中文网
http://c.biancheng.net/
成立7年了
日IP数万
这种写法叫做代码块重定向，也就是把一组命令同时重定向到一个文件。
3、【实例3】统计用户在终端输入的文本的行数。
此处我们使用输入重定向符号<<，这个符号的作用是使用特定的分界符作为命令输入的结束标志，而不使用 Ctrl+D 键。
[c.biancheng.net]$ wc -l <<END
> 123
> 789
> abc
> xyz
> END
4
wc 命令会一直等待用输入，直到遇见分界符 END 才结束读取。
<<之后的分界符可以自由定义，只要再碰到相同的分界符，两个分界符之间的内容将作为命令的输入（不包括分界符本身）。
37、Linux Shell管道详解：
Shell 还有一种功能，就是可以将两个或者多个命令（程序或者进程）连接到一起，把一个命令的输出作为下一个命令的输入，以这种方式连接的两个或者多个命令就形成了管道（pipe）。
Linux 管道使用竖线|连接多个命令，这被称为管道符。Linux 管道的具体语法格式如下：
command1 | command2
command1 | command2 [ | commandN... ]
当在两个命令之间设置管道时，管道符|左边命令的输出就变成了右边命令的输入。只要第一个命令向标准输出写入，而第二个命令是从标准输入读取，那么这两个命令就可以形成一个管道。大部分的 Linux 命令都可以用来形成管道。
这里需要注意，command1 必须有正确输出，而 command2 必须可以处理 command2 的输出结果；而且 command2 只能处理 command1 的正确输出结果，不能处理 command1 的错误信息。
1、重定向和管道的区别
乍看起来，管道也有重定向的作用，它也改变了数据输入输出的方向，那么，管道和重定向之间到底有什么不同呢？
简单地说，重定向操作符>将命令与文件连接起来，用文件来接收命令的输出；而管道符|将命令与命令连接起来，用第二个命令来接收第一个命令的输出。如下所示：
command > file
command1 | command1
2、Linux管道实例
1、【实例1】将 ls 命令的输出发送到 grep 命令：
[c.biancheng.net]$ ls | grep log.txt
log.txt
上述命令是查看文件 log.txt 是否存在于当前目录下。
我们可以在命令的后面使用选项，例如使用-al选项：
[c.biancheng.net]$ ls -al | grep log.txt
-rw-rw-r--. 1 mozhiyan mozhiyan 0 4月 15 17:26 log.txt
管道符|与两侧的命令之间也可以不存在空格，例如将上述命令写作ls -al|grep log.txt；然而我还是推荐在管道符|和两侧的命令之间使用空格，以增加代码的可读性。
我们也可以重定向管道的输出到一个文件，比如将上述管道命令的输出结果发送到文件 output.txt 中：
[c.biancheng.net]$ ls -al | grep log.txt >output.txt
[c.biancheng.net]$ cat output.txt
-rw-rw-r--. 1 mozhiyan mozhiyan 0 4月 15 17:26 log.txt
2、【实例2】使用管道将 cat 命令的输出作为 less 命令的输入，这样就可以将 cat 命令的输出每次按照一个屏幕的长度显示，这对于查看长度大于一个屏幕的文件内容很有帮助。
cat /var/log/message | less
3、管道与输入重定向
输入重定向操作符<可以在管道中使用，以用来从文件中获取输入，其语法类似下面这样：
command1 < input.txt | command2
command1 < input.txt | command2 -option | command3
38、Shell过滤器：
将几个命令通过管道符组合在一起就形成一个管道。通常，通过这种方式使用的命令就被称为过滤器。过滤器会获取输入，通过某种方式修改其内容，然后将其输出。
简单地说，过滤器可以概括为以下两点：
如果一个 Linux 命令是从标准输入接收它的输入数据，并在标准输出上产生它的输出数据（结果），那么这个命令就被称为过滤器。
过滤器通常与 Linux 管道一起使用。
常用的被作为过滤器使用的命令如下所示：
命令 说明
awk 用于文本处理的解释性程序设计语言，通常被作为数据提取和报告的工具。
cut 用于将每个输入文件（如果没有指定文件则为标准输入）的每行的指定部分输出到标准输出。
grep 用于搜索一个或多个文件中匹配指定模式的行。
tar 用于归档文件的应用程序。
head 用于读取文件的开头部分（默认是 10 行）。如果没有指定文件，则从标准输入读取。
paste 用于合并文件的行。
sed 用于过滤和转换文本的流编辑器。
sort 用于对文本文件的行进行排序。
split 用于将文件分割成块。
strings 用于打印文件中可打印的字符串。
tac 与 cat 命令的功能相反，用于倒序地显示文件或连接文件。
tail 用于显示文件的结尾部分。
tee 用于从标准输入读取内容并写入到标准输出和文件。
tr 用于转换或删除字符。
uniq 用于报告或忽略重复的行。
wc 用于打印文件中的总行数、单词数或字节数。
1、在管道中使用 awk 命令
关于 awk 命令的具体用法，请大家自行学习，来了解一下 awk 命令在管道中的使用。
1、实例1
查看系统中的所有的账号名称，并按名称的字母顺序排序。
[c.biancheng.net]$ awk -F: '{print $1}' /etc/passwd | sort
adm
apache
avahi
avahi-autoipd
bin
daemon
dbus
ftp
games
...
在上例中，使用冒号:作为列分隔符，将文件 /etc/passwd 的内容分为了多列，并打印了第一列的信息（即用户名），然后将输出通过管道发送到了 sort 命令。
2、实例2
列出当前账号最常使用的 10 个命令。
[c.biancheng.net]$ history | awk '{print $2}' | sort | uniq -c | sort -rn | head
140 echo
75 man
71 cat
63 su
53 ls
50 vi
47 cd
40 date
26 let
25 paste
在上例中，history 命令将输出通过管道发送到 awk 命令，awk 命令默认使用空格作为列分隔符，将 history 的输出分为了两列，并把第二列内容作为输出通过管道发送到了 sort 命令，使用 sort 命令进行排序后，再将输出通过管道发送到了 uniq 命令，使用 uniq 命令 统计了历史命令重复出现的次数，再用 sort 命令将 uniq 命令的输出按照重复次数从高到低排序，最后使用 head 命令默认列出前 10 个的信息。
3、实例3
显示当前系统的总内存大小，单位为 KB。
[c.biancheng.net]$ free | grep Mem | awk '{print $2}'
2029860
2、在管道中使用 cut 命令
cut 命令被用于文本处理。你可以使用这个命令来提取文件中指定列的内容。
1、实例1
查看系统中登录 Shell 是“/bin/bash”的用户名和对应的用户主目录的信息：
[c.biancheng.net]$ grep "bin/bash" /etc/passwd | cut -d: -f1,6
root:/root
mozhiyan:/home/mozhiyan
如果你对 Linux 系统有所了解，你会知道，/ctc/passwd 文件被用来存放用户账号的信息，此文件中的每一行会记录一个账号的信息，每个字段之间用冒号分隔，第一个字段即是账号的账户名，而第六个字段就是账号的主目录的路径。
2、实例2
查看当前机器的CPU类型。
[c.biancheng.net]$ cat /proc/cpuinfo | grep name | cut -d: -f2 | uniq
Intel(R) Core(TM) i5-2520M CPU @ 2.50GHz
上例中，执行命令cat /proc/cpuinfo | grep name得到的内容如下所示：
[c.biancheng.net]$ cat /proc/cpuinfo | grep name
model name : Intel(R) Core(TM) i5-2520M CPU @ 2.50GHz
model name : Intel(R) Core(TM) i5-2520M CPU @ 2.50GHz
model name : Intel(R) Core(TM) i5-2520M CPU @ 2.50GHz
model name : Intel(R) Core(TM) i5-2520M CPU 0 2.50GHz
然后，我们使用 cut 命令将上述输出内容以冒号作为分隔符，将内容分为了两列， 并显示第二列的内容，最后使用 uniq 命令去掉了重复的行。
3、实例3
查看当前目录下的子目录数。
[c.biancheng.net]$ ls -l | cut -c 1 | grep d | wc -l
5
上述管道命令主要做了如下操作：
命令ls -l输出的内容中，每行的第一个字符表示文件的类型，如果第一个字符是d，就表示文件的类型是目录。
命令cut -c 1是截取每行的第一个字符。
命令grep d来获取文件类型是目录的行。
命令wc -l用来获得 grep 命令输出结果的行数，即目录个数。
3、在管道中使用grep命令
grep 命令是在管道中比较常用的一个命令。
1、实例1
查看系统日志文件中的错误信息。
[c.biancheng.net]$ grep -i "error:" /var/log/messages | less
2、实例2
查看系统中 HTTP 服务的进程信息。
[c.biancheng.net]$ ps auxwww | grep httpd
apache 18968 0.0 0.0 26472 10404 ? S Dec15 0:01 /usr/sbin/httpd
apache 18969 0.0 0.0 25528 8308 ? S Dec15 0:01 /usr/sbin/httpd
apache 18970 0.0 0.0 26596 10524 ? S Dec15 0:01 /usr/sbin/httpd
3、实例3
查找我们的程序列表中所有命令名中包含关键字 zip 的命令。
[c.biancheng.net]$ ls /bin /usr/bin | sort | uniq | grep zip
bunzip2
bzip2
bzip2recover
gunzip
gzip
4、实例4
查看系统安装的 kernel 版本及相关的 kernel 软件包。
[c.biancheng.net]$ rpm -qa | grep kernel
kernel-2.6.18-92.e15
kernel-debuginfo-2.6.18-92.e15
kernel-debuginfo-common-2.6.18-92.e15
kernel-devel-2.6.18-92.e15
5、实例5
查找 /etc 目录下所有包含 IP 地址的文件。
[c.biancheng.net]$ find /etc -type f -exec grep '[0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*' {} \;
4、在管道中使用 tar 命令
tar 命令是 Linux 系统中最常用的打包文件的程序。
1、实例1
你可以使用 tar 命令复制一个目录的整体结构。
[c.biancheng.net]$ tar cf - /home/mozhiyan | ( cd /backup/; tar xf - )
2、实例2
跨网络地复制一个目录的整体结构。
[c.biancheng.net]$ tar cf - /home/mozhiyan | ssh remote_host "( cd /backup/; tar xf - )"
3、实例3
跨网络地压缩复制一个目录的整体结构。
[c.biancheng.net]$ tar czf - /home/mozhiyan | ssh remote_host "( cd /backup/; tar xzf - )"
4、实例4
检査 tar 归档文件的大小，单位为字节。
[c.biancheng.net]$ cd /; tar cf - etc | wc -c
215040
5、实例5
检查 tar 归档文件压缩为 tar.gz 归裆文件后所占的大小。
[c.biancheng.net]$ tar czf - etc.tar | wc -c
58006
6、实例6
检查 tar 归档文件压缩为 tar.bz2 归裆文件后所占的大小。
[c.biancheng.net]$ tar cjf - etc.tar | wc -c
50708
5、在管道中使用 head 命令
有时，你不需要一个命令的全部输出，可能只需要命令的前几行输出。这时，就可以使用 head 命令，它只打印命令的前几行输出。默认的输出行数为 10 行。
1、实例1
显示 ls 命令的前 10 行输出。
[c.biancheng.net]$ ls /usr/bin | head
addftinfo
afmtodit
apropos
arch
ash
awk
base64
basename
bash
bashbug
2、实例2
显示 ls 命令的前 5 行内容。
[c.biancheng.net]$ ls / | head -n 5
bin
cygdrive
Cygwin.bat
Cygwin.ico
Cygwin-Terminal.ico
6、在管道中使用 uniq 命令
uniq 命令用于报告或删除重复的行。
使用一个测试文件进行管道中使用 uniq 命令的实例讲解，其内容如下所示：
[c.biancheng.net]$ cat testfile
This line occurs only once.
This line occurs twice.
This line occurs twice.
This line occurs three times.
This line occurs three times.
This line occurs three times.
1、实例1
去掉输出中重复的行。
[c.biancheng.net]$ sort testfile | uniq
This line occurs only once.
This line occurs three times.
This line occurs twice.
2、实例2
显示输出中各重复的行出现的次数，并按次数多少倒序显示。
[c.biancheng.net]$ sort testfile | uniq -c | sort -nr
3 This line occurs three times.
2 This line occurs twice.
1 This line occurs only once.
7、在管道中使用 wc 命令
wc 命令用于统计包含在文本流中的字符数、单同数和行数。
1、实例1
统计当前登录到系统的用户数。
[c.biancheng.net]$ who | wc -l
2、实例2
统计当前的 Linux 系统中的进程数。
[c.biancheng.net]$ ps -ef | wc -l
651
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
