Linux之shell编程
walkingLL 2018-09-22 08:51:26 14717 收藏 129
shell历史
Shell的作用是解释执行用户的命令，用户输入一条命令，Shell就解释执行一条，这种方式称为交互式（Interactive），Shell还有一种执行命令的方式称为批处理（Batch），用户事先写一个Shell脚本（Script），其中有很多条命令，让Shell一次把这些命令执行完，而不必一条一条地敲命令。Shell脚本和编程语言很相似，也有变量和流程控制语句，但Shell脚本是解释执行的，不需要编译，Shell程序从脚本中一行一行读取并执行这些命令，相当于一个用户把脚本中的命令一行一行敲到Shell提示符下执行。
由于历史原因，UNIX系统上有很多种Shell：
(1) sh（Bourne Shell）：由Steve Bourne开发，各种UNIX系统都配有sh。
(2) csh（C Shell）：由Bill Joy开发，随BSD UNIX发布，它的流程控制语句很像C语言，支持很多Bourne Shell所不支持的功能：作业控制，命令历史，命令行编辑。
(3) ksh（Korn Shell）：由David Korn开发，向后兼容sh的功能，并且添加了csh引入的新功能，是目前很多UNIX系统标准配置的Shell，在这些系统上/bin/sh往往是指向/bin/ksh的符号链接。
(4) tcsh（TENEX C Shell）：是csh的增强版本，引入了命令补全等功能，在FreeBSD、MacOS X等系统上替代了csh。
(5) bash（Bourne Again Shell）：由GNU开发的Shell，主要目标是与POSIX标准保持一致，同时兼顾对sh的兼容，bash从csh和ksh借鉴了很多功能，是各种Linux发行版标准配置的Shell，在Linux系统上/bin/sh往往是指向/bin/bash的符号链接。虽然如此，bash和sh还是有很多不同的，一方面，bash扩展了一些命令和参数，另一方面，bash并不完全和sh兼容，有些行为并不一致，所以bash需要模拟sh的行为：当我们通过sh这个程序名启动bash时，bash可以假装自己是sh，不认扩展的命令，并且行为与sh保持一致。
itcast$ vim /etc/passwd #其中最后一列显示了用户对应的shell类型
root:\x:0:0:root:/root:/bin/bash
nobody:\x:65534:65534:nobody:/nonexistent:/bin/sh
syslog:\x:101:103::/home/syslog:/bin/false
itcast:\x:1000:1000:itcast,:/home/itcast:/bin/bash
ftp:\x:115:125:ftp daemon,:/srv/ftp:/bin/false
用户在命令行输入命令后，一般情况下Shell会fork并exec该命令，但是Shell的内建命令例外，执行内建命令相当于调用Shell进程中的一个函数，并不创建新的进程。以前学过的cd、alias、umask、exit等命令即是内建命令，凡是用which命令查不到程序文件所在位置的命令都是内建命令，内建命令没有单独的man手册，要在man手册中查看内建命令，应该执行
itcast$ man bash-builtins
如export、shift、if、eval、[、for、while等等。内建命令虽然不创建新的进程，但也会有Exit Status，通常也用0表示成功非零表示失败，虽然内建命令不创建新的进程，但执行结束后也会有一个状态码，也可以用特殊变量$?读出。
执行脚本
编写一个简单的脚本test.sh：
#! /bin/sh
cd …
ls
Shell脚本中用#表示注释，相当于C语言的//注释。但如果#位于第一行开头，并且是#!（称为Shebang）则例外，它表示该脚本使用后面指定的解释器/bin/sh解释执行。如果把这个脚本文件加上可执行权限然后执行：
itcast$ chmod a+x test.sh
itcast$ ./test.sh
Shell会fork一个子进程并调用exec执行./test.sh这个程序，exec系统调用应该把子进程的代码段替换成./test.sh程序的代码段，并从它的_start开始执行。然而test.sh是个文本文件，根本没有代码段和_start函数，怎么办呢？其实exec还有另外一种机制，如果要执行的是一个文本文件，并且第一行用Shebang指定了解释器，则用解释器程序的代码段替换当前进程，并且从解释器的_start开始执行，而这个文本文件被当作命令行参数传给解释器。因此，执行上述脚本相当于执行程序
itcast$ /bin/sh ./test.sh
以这种方式执行不需要test.sh文件具有可执行权限。如果将命令行下输入的命令用()括号括起来，那么也会fork出一个子Shell执行小括号中的命令，一行中可以输入由分号;隔开的多个命令，比如：
itcast$ (cd …;ls -l)和上面两种方法执行Shell脚本的效果是相同的，cd …命令改变的是子Shell的PWD，而不会影响到交互式Shell。然而命令
itcast$ cd …;ls -l
则有不同的效果，cd …命令是直接在交互式Shell下执行的，改变交互式Shell的PWD，然而这种方式相当于这样执行Shell脚本：
itcast$ source ./test.sh
或者
itcast$ . ./test.sh
source或者.命令是Shell的内建命令，这种方式也不会创建子Shell，而是直接在交互式Shell下逐行执行脚本中的命令。
基本语法
变量
按照惯例，Shell变量通常由字母加下划线开头，由任意长度的字母、数字、下划线组成。有两种类型的Shell变量：
环境变量
环境变量可以从父进程传给子进程，因此Shell进程的环境变量可以从当前Shell进程传给fork出来的子进程。用printenv命令可以显示当前Shell进程的环境变量。
本地变量
只存在于当前Shell进程，用set命令可以显示当前Shell进程中定义的所有变量（包括本地变量和环境变量）和函数。
环境变量是任何进程都有的概念，而本地变量是Shell特有的概念。在Shell中，环境变量和本地变量的定义和用法相似。在Shell中定义或赋值一个变量：
itcast$ VARNAME=value
注意等号两边都不能有空格，否则会被Shell解释成命令和命令行参数。
一个变量定义后仅存在于当前Shell进程，它是本地变量，用export命令可以把本地变量导出为环境变量，定义和导出环境变量通常可以一步完成：
itcast$ export VARNAME=value
也可以分两步完成：
itcast$ VARNAME=value
itcast$ export VARNAME
用unset命令可以删除已定义的环境变量或本地变量。
itcast$ unset VARNAME
如果一个变量叫做VARNAME，用 ’ VARNAME ’ 可以表示它的值，在不引起歧义的情况下也可以用VARNAME表示它的值。通过以下例子比较这两种表示法的不同：
itcast$ echo $SHELL
注意，在定义变量时不用"’"取变量值时要用。和C语言不同的是，Shell变量不需要明确定义类型，事实上Shell变量的值都是字符串，比如我们定义VAR=45，其实VAR的值是字符串45而非整数。Shell变量不需要先定义后使用，如果对一个没有定义的变量取值，则值为空字符串。
文件名代换（Globbing）
这些用于匹配的字符称为通配符（Wildcard），如：* ? [ ] 具体如下：
* 匹配0个或多个任意字符
? 匹配一个任意字符
[若干字符] 匹配方括号中任意一个字符的一次出现
itcast$ ls /dev/ttyS*
itcast$ ls ch0?.doc
itcast$ ls ch0[0-2].doc
itcast$ ls ch[012] [0-9].doc
注意，Globbing所匹配的文件名是由Shell展开的，也就是说在参数还没传给程序之前已经展开了，比如上述ls ch0[012].doc命令，如果当前目录下有ch00.doc和ch02.doc，则传给ls命令的参数实际上是这两个文件名，而不是一个匹配字符串。
命令代换
由"`"反引号括起来的也是一条命令，Shell先执行该命令，然后将输出结果立刻代换到当前命令行中。例如定义一个变量存放date 命令的输出：
itcast$ DATE=date
itcast$ echo $DATE
命令代换也可以用$()表示：
itcast$ DATE=$(date)
算术代换
使用$(())，用于算术计算，(())中的Shell变量取值将转换成整数，同样含义的$[ ]等价例如：
itcast$ VAR=45
itcast$ echo $(($VAR+3)) 等价于 echo $[VAR+3]或 $[$VAR+3]
$(())中只能用±*/和()运算符，并且只能做整数运算。
$[base#n]，其中base表示进制，n按照base进制解释，后面再有运算数，按十进制解释。
echo $[2#10+11]
echo $[8#10+11]
echo $[16#10+11]
反引号
反引号（``） ：命令替换，通常用于把命令输出结果传给入变量中。
命令替换是指shell能够将一个命令的标准输出插在一个命令行中任何位置。shell中有两种方法作命令替换：把shell命令用反引号或者$(…)结构括起来，其中，$(…)格式受到POSIX标准支持，也利于嵌套。
# echo The date and time is `date`
The date and time is 三 6月 15 06:10:35 CST 2005
# echo Your current working directory is $(pwd)
Your current working directory is /home/howard/script
转义字符
和C语言类似，\在Shell中被用作转义字符，用于去除紧跟其后的单个字符的特殊意义（回车除外），换句话说，紧跟其后的字符取字面值。例如：
itcast$ echo $SHELL
/bin/bash
itcast$ echo \$SHELL
$SHELL
itcast$ echo \
\
比如创建一个文件名为"$ $"的文件（$间含有空格）可以这样：
itcast$ touch \$\ \$
还有一个字符虽然不具有特殊含义，但是要用它做文件名也很麻烦，就是-号。如果要创建一个文件名以-号开头的文件，这样是不正确的：
itcast$ touch -hello
touch: invalid option – h
Try `touch --help’ for more information.
即使加上转义也还是报错：
itcast$ touch \-hello
touch: invalid option – h
Try `touch --help’ for more information.
因为各种UNIX命令都把-号开头的命令行参数当作命令的选项，而不会当作文件名。如果非要处理以-号开头的文件名，可以有两种办法：
itcast$ touch ./-hello
或者
itcast$ touch – -hello
还有一种用法，在后敲回车表示续行，Shell并不会立刻执行命令，而是把光标移到下一行，给出一个续行提示符>，等待用户继续输入，最后把所有的续行接到一起当作一个命令执行。例如：
itcast$ ls \
-l
（ls -l命令的输出）
反斜杠的另一种作用，就是当反斜杠用于一行的最后一个字符时，Shell把行尾的反斜杠作为续行，这种结构在分几行输入长命令时经常使用。
单引号
单引号：所见即所得。
单引号字符串的限制：单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的。单引号字串中不能出现单引号（对单引号使用转义符后也不行）。
和C语言同，Shell脚本中的单引号和双引号一样都是字符串的界定符（双引号下一节介绍），而不是字符的界定符。单引号用于保持引号内所有字符的字面值，即使引号内的和回车也不例外，但是字符串中不能出现单引号。如果引号没有配对就输入回车，Shell会给出续行提示符，要求用户把引号配上对。例如：
itcast$ echo ‘$SHELL’
SHELLitcastSHELL itcastSHELLitcast echo ‘ABC（回车）
DE’（再按一次回车结束命令）
ABC
DE
双引号
双引号：所见非所得，它会先把变量解析之后，再输出。
双引号的优点：双引号里可以有变量。双引号里可以出现转义字符。
被双引号用括住的内容，将被视为单一字串。它防止通配符扩展，但允许变量扩展。这点与单引号的处理方式不同。
itcast$ DATE=$(date)
itcast$ echo “$DATE”
itcast$ echo ‘$DATE’
再比如：
itcast$ VAR=200
itcast$ echo $VAR
200
itcast$ echo ‘$VAR’
$VAR
itcast$ echo “$VAR”
200
$'String’和$“String”
(1)如果没有特殊定制bash环境或有特殊需求，$“string"和"string"是完全等价的，使用$”"只是为了保证本地化。
以下是man bash关于""的解释：Adouble−quotedstringprecededbyadollarsign(""的解释： A double-quoted string preceded by a dollar sign (""的解释：Adouble−quotedstringprecededbyadollarsign("string") will cause the string to be translated according to the current locale. If the current locale is C or POSIX, the dollar sign is ignored. If the string is translated and replaced, the replacement is double-quoted.
(2)还有$后接单引号的$‘string’，这在bash中被特殊对待：会将某些反斜线序列(如n，t，"，'等)继续转义，而不认为它是字面符号(如果没有$符号，单引号会强制将string翻译为字面符号，包括反斜线)。简单的例子：
[root@xuexi ~]# echo ‘a\nb’
anb
[root@xuexi ~]# echo $‘a\nb’
a
b
$#,$@,$0,$1,$2的含义
变量说明:
$$
Shell本身的PID（ProcessID）
$!
Shell最后运行的后台Process的PID
$?
最后运行的命令的结束代码（返回值）
$-
使用Set命令设定的Flag一览
$*
所有参数列表。如"$*“用「”」括起来的情况、以"$1 $2 … $n"的形式输出所有参数。
$@
所有参数列表。如"$@“用「”」括起来的情况、以"$1" “2"..."2" ... "2"..."n” 的形式输出所有参数。
$#
添加到Shell的参数个数
$0
Shell本身的文件名
$1～$n
添加到Shell的各参数值。$1是第1参数、$2是第2参数…。
各种括号()、(())、[]、[[]]、{}
更新时间：2017年09月07日 09:10:09 作者：QuintinX 脚本之家
小括号，圆括号（）
单小括号 ()
①命令组。括号中的命令将会新开一个子shell顺序执行，所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开，最后一个命令可以没有分号，各命令和括号之间不必有空格。
②命令替换。等同于`cmd`，shell扫描一遍命令行，发现了$(cmd)结构，便将$(cmd)中的cmd执行一次，得到其标准输出，再将此输出放到原来命令。有些shell不支持，如tcsh。
③用于初始化数组。如：array=(a b c d)
双小括号 (( ))
①整数扩展。这种扩展计算是整数型的计算，不支持浮点型。((exp))结构扩展并计算一个算术表达式的值，如果表达式的结果为0，那么返回的退出状态码为1，或者 是"假"，而一个非零值的表达式所返回的退出状态码将为0，或者是"true"。若是逻辑判断，表达式exp为真则为1,假则为0。
②只要括号中的运算符、表达式符合C语言运算规则，都可用在$((exp))中，甚至是三目运算符。作不同进位(如二进制、八进制、十六进制)运算时，输出结果全都自动转化成了十进制。如：echo $((16#5f)) 结果为95 (16进位转十进制)
③单纯用 (( )) 也可重定义变量值，比如 a=5; ((a++)) 可将 $a 重定义为6
④常用于算术运算比较，双括号中的变量可以不使用$符号前缀。括号内支持多个表达式用逗号分开。 只要括号中的表达式符合C语言运算规则,比如可以直接使用for((i=0;i<5;i++)), 如果不使用双括号, 则为for i in seq 0 4或者for i in {0…4}。再如可以直接使用if (($i<5)), 如果不使用双括号, 则为if [ $i -lt 5 ]。
中括号，方括号[]
单中括号 []
①bash 的内部命令，[和test是等同的。如果我们不用绝对路径指明，通常我们用的都是bash自带的命令。if/test结构中的左中括号是调用test的命令标识，右中括号是关闭条件判断的。这个命令把它的参数作为比较表达式或者作为文件测试，并且根据比较的结果来返回一个退出状态码。if/test结构中并不是必须右中括号，但是新版的Bash中要求必须这样。
②Test和[]中可用的比较运算符只有==和!=，两者都是用于字符串比较的，不可用于整数比较，整数比较只能使用-eq，-gt这种形式。无论是字符串比较还是整数比较都不支持大于号小于号。如果实在想用，对于字符串比较可以使用转义形式，如果比较"ab"和"bc"：[ ab \< bc ]，结果为真，也就是返回状态为0。[ ]中的逻辑与和逻辑或使用-a 和-o 表示。
③字符范围。用作正则表达式的一部分，描述一个匹配的字符范围。作为test用途的中括号内不能使用正则。
④在一个array 结构的上下文中，中括号用来引用数组中每个元素的编号。
双中括号[[ ]]
①[[是 bash 程序语言的关键字。并不是一个命令，[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割，但是会发生参数扩展和命令替换。
②支持字符串的模式匹配，使用=~操作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式，而不仅仅是一个字符串，比如[[ hello == hell? ]]，结果为真。[[ ]] 中匹配字符串或通配符，不需要引号。
③使用[[ … ]]条件判断结构，而不是[ … ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。
④bash把双中括号中的表达式看作一个单独的元素，并返回一个退出状态码。
例子：
if ($i<5)
if [ $i -lt 5 ]
if [ $a -ne 1 -a $a != 2 ]
if [ $a -ne 1] && [ $a != 2 ]
if [[ $a != 1 && $a != 2 ]]
for i in $(seq 0 4);do echo $i;done
for i in `seq 0 4`;do echo $i;done
for ((i=0;i<5;i++));do echo $i;done
for i in {0…4};do echo $i;done
大括号、花括号 {}
常规用法
①大括号拓展。(通配(globbing))将对大括号中的文件名做扩展。在大括号中，不允许有空白，除非这个空白被引用或转义。第一种：对大括号中的以逗号分割的文件列表进行拓展。如 touch {a,b}.txt 结果为a.txt b.txt。第二种：对大括号中以点点（…）分割的顺序文件列表起拓展作用，如：touch {a…d}.txt 结果为a.txt b.txt c.txt d.txt
# ls {ex1,ex2}.sh
ex1.sh ex2.sh
# ls {ex{1…3},ex4}.sh
ex1.sh ex2.sh ex3.sh ex4.sh
# ls {ex[1-3],ex4}.sh
ex1.sh ex2.sh ex3.sh ex4.sh
②代码块，又被称为内部组，这个结构事实上创建了一个匿名函数 。与小括号中的命令不同，大括号内的命令不会新开一个子shell运行，即脚本余下部分仍可使用括号内变量。括号内的命令间用分号隔开，最后一个也必须有分号。{}的第一个命令和左括号之间必须要有一个空格。
几种特殊的替换结构 ${var:-string}
${var:-string},${var:+string},${var:=string},${var:?string}
①${var:-string}和${var:=string}:若变量var为空，则用在命令行中用string来替换${var:-string}，否则变量var不为空时，则用变量var的值来替换${var:-string}；对于${var:=string}的替换规则和${var:-string}是一样的，所不同之处是${var:=string}若var为空时，用string替换${var:=string}的同时，把string赋给变量var： ${var:=string}很常用的一种用法是，判断某个变量是否赋值，没有的话则给它赋上一个默认值。
② ${var:+string}的替换规则和上面的相反，即只有当var不是空的时候才替换成string，若var为空时则不替换或者说是替换成变量 var的值，即空值。(因为变量var此时为空，所以这两种说法是等价的)
③${var:?string}替换规则为：若变量var不为空，则用变量var的值来替换${var:?string}；若变量var为空，则把string输出到标准错误中，并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。
补充扩展：在上面这五种替换结构中string不一定是常值的，可用另外一个变量的值或是一种命令的输出。
四种模式匹配替换结构 ${var%%pattern}
模式匹配记忆方法：
# 是去掉左边(在键盘上#在$之左边)
% 是去掉右边(在键盘上%在$之右边)
#和%中的单一符号是最小匹配，两个相同符号是最大匹配。
${var%pattern},${var%%pattern},${var#pattern},${var##pattern}
第一种模式：${variable%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最短的匹配模式
第二种模式： ${variable%%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉右边最长的匹配模式
第三种模式：${variable#pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern开始，如果是，就从命令行把variable中的内容去掉左边最短的匹配模式
第四种模式： ${variable##pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，就从命令行把variable中的内容去掉左边最长的匹配模式
这四种模式中都不会改变variable的值，其中，只有在pattern中使用了*匹配符号时，%和%%，#和##才有区别。结构中的pattern支持通配符，*表示零个或多个任意字符，?表示仅与一个任意字符匹配，[…]表示匹配中括号里面的字符，[!..]表示不匹配中括号里面的字符。
# var=testcase
# echo $var
testcase
# echo ${var%s*e}
testca
# echo $var
testcase
# echo ${var%%s*e}
te
# echo ${var#?e}
stcase
# echo ${var##?e}
stcase
# echo ${var##*e}
# echo ${var##*s}
e
# echo ${var##test}
case
字符串提取和替换，蛮有用 ${var:num1:num2}
${var:num},${var:num1:num2},${var/pattern/pattern},${var//pattern/pattern}
第一种模式：${var:num}，这种模式时，shell在var中提取第num个字符到末尾的所有字符。若num为正数，从左边0处开始；若num为负数，从右边开始提取字串，但必须使用在冒号后面加空格或一个数字或整个num加上括号，如${var: -2}、${var:1-3}或${var:(-2)}。
第二种模式：${var:num1:num2}，num1是位置，num2是长度。表示从$var字符串的第$num1个位置开始提取长度为$num2的子串。不能为负数。
第三种模式：${var/pattern/pattern}表示将var字符串的第一个匹配的pattern替换为另一个pattern。
第四种模式：${var//pattern/pattern}表示将var字符串中的所有能匹配的pattern替换为另一个pattern。
[root@centos ~]# var=/home/centos
[root@centos ~]# echo $var
/home/centos
[root@centos ~]# echo ${var:5}
/centos
[root@centos ~]# echo ${var: -6}
centos
[root@centos ~]# echo ${var:(-6)}
centos
[root@centos ~]# echo ${var:1:4}
home
[root@centos ~]# echo ${var/o/h}
/hhme/centos
[root@centos ~]# echo ${var//o/h}
/hhme/cenths
符号$后的括号
（1）${a} 变量a的值, 在不引起歧义的情况下可以省略大括号。
（2）$(cmd) 命令替换，和`cmd`效果相同，结果为shell命令cmd的输，过某些Shell版本不支持$()形式的命令替换, 如tcsh。
（3）$((expression)) 和`exprexpression`效果相同, 计算数学表达式exp的数值, 其中exp只要符合C语言的运算规则即可, 甚至三目运算符和逻辑表达式都可以计算。
{}()单独使用
1、多条命令执行
（1）单小括号，(cmd1;cmd2;cmd3) 新开一个子shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后可以没有分号。
（2）单大括号，{ cmd1;cmd2;cmd3;} 在当前shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后必须有分号, 第一条命令和左括号之间必须用空格隔开。
对{}和()而言, 括号中的重定向符只影响该条命令， 而括号外的重定向符影响到括号中的所有命令。
Shell脚本语法
条件测试
命令test或 [ 可以测试一个条件是否成立，如果测试结果为真，则该命令的Exit Status为0，如果测试结果为假，则命令的Exit Status为1（注意与C语言的逻辑表示正好相反）。例如测试两个数的大小关系：
itcast@ubuntu:~$ var=2
itcast@ubuntu:~$ test var−gt1itcast@ubuntu:var -gt 1 itcast@ubuntu:~var−gt1itcast@ubuntu: echo $?
0
itcast@ubuntu:~$ test var−gt3itcast@ubuntu:var -gt 3 itcast@ubuntu:~var−gt3itcast@ubuntu: echo $?
1
itcast@ubuntu:~$ [ var−gt3]itcast@ubuntu:var -gt 3 ] itcast@ubuntu:~var−gt3]itcast@ubuntu: echo $?
1
虽然看起来很奇怪，但左方括号 [ 确实是一个命令的名字，传给命令的各参数之间应该用空格隔开，比如：$VAR、-gt、3、] 是 [ 命令的四个参数，它们之间必须用空格隔开。命令test或 [ 的参数形式是相同的，只不过test命令不需要 ] 参数。以 [ 命令为例，常见的测试命令如下表所示：
[ -d DIR ] 如果DIR存在并且是一个目录则为真
[ -f FILE ] 如果FILE存在且是一个普通文件则为真
[ -z STRING ] 如果STRING的长度为零则为真
[ -n STRING ] 如果STRING的长度非零则为真
[ STRING1 = STRING2 ] 如果两个字符串相同则为真
[ STRING1 != STRING2 ] 如果字符串不相同则为真
[ ARG1 OP ARG2 ] ARG1和ARG2应该是整数或者取值为整数的变量，OP是-eq（等于）-ne（不等于）-lt（小于）-le（小于等于）-gt（大于）-ge（大于等于）之中的一个。
和C语言类似，测试条件之间还可以做与、或、非逻辑运算：
[ ! EXPR ] EXPR可以是上表中的任意一种测试条件，!表示"逻辑反(非)"
[ EXPR1 -a EXPR2 ] EXPR1和EXPR2可以是上表中的任意一种测试条件，-a表示"逻辑与"
[ EXPR1 -o EXPR2 ] EXPR1和EXPR2可以是上表中的任意一种测试条件，-o表示"逻辑或"
例如：
$ VAR=abc
$ [ -d Desktop -a $VAR = ‘abc’ ]
$ echo $?
0
注意，如果上例中的$VAR变量事先没有定义，则被Shell展开为空字符串，会造成测试条件的语法错误（展开为[ -d Desktop -a = ‘abc’ ]），作为一种好的Shell编程习惯，应该总是把变量取值放在双引号之中（展开为[ -d Desktop -a “” = ‘abc’ ]）：
$ unset VAR
$ [ -d Desktop -a $VAR = ‘abc’ ]
bash: [: too many arguments
$ [ -d Desktop -a “$VAR” = ‘abc’ ]
$ echo $?
1
分支if/then/elif/else/fi
if的基本语法
if [ command ];then
符合该条件执行的语句
elif [ command ];then
符合该条件执行的语句
else
符合该条件执行的语句
fi
文件/文件夹(目录)判断
[ -b FILE ] 如果 FILE 存在且是一个块特殊文件则为真。
[ -c FILE ] 如果 FILE 存在且是一个字特殊文件则为真。
[ -d DIR ] 如果 FILE 存在且是一个目录则为真。
[ -e FILE ] 如果 FILE 存在则为真。
[ -f FILE ] 如果 FILE 存在且是一个普通文件则为真。
[ -g FILE ] 如果 FILE 存在且已经设置了SGID则为真。
[ -k FILE ] 如果 FILE 存在且已经设置了粘制位则为真。
[ -p FILE ] 如果 FILE 存在且是一个名字管道(F如果O)则为真。
[ -r FILE ] 如果 FILE 存在且是可读的则为真。
[ -s FILE ] 如果 FILE 存在且大小不为0则为真。
[ -t FD ] 如果文件描述符 FD 打开且指向一个终端则为真。
[ -u FILE ] 如果 FILE 存在且设置了SUID (set user ID)则为真。
[ -w FILE ] 如果 FILE存在且是可写的则为真。
[ -x FILE ] 如果 FILE 存在且是可执行的则为真。
[ -O FILE ] 如果 FILE 存在且属有效用户ID则为真。
[ -G FILE ] 如果 FILE 存在且属有效用户组则为真。
[ -L FILE ] 如果 FILE 存在且是一个符号连接则为真。
[ -N FILE ] 如果 FILE 存在 and has been mod如果ied since it was last read则为真。
[ -S FILE ] 如果 FILE 存在且是一个套接字则为真。
[ FILE1 -nt FILE2 ] 如果 FILE1 has been changed more recently than FILE2, or 如果 FILE1 exists and FILE2 does not则为真。
[ FILE1 -ot FILE2 ] 如果 FILE1 比 FILE2 要老, 或者 FILE2 存在且 FILE1 不存在则为真。
[ FILE1 -ef FILE2 ] 如果 FILE1 和 FILE2 指向相同的设备和节点号则为真。
字符串判断
[ -z STRING ] 如果STRING的长度为零则为真 ，即判断是否为空，空即是真；
[ -n STRING ] 如果STRING的长度非零则为真 ，即判断是否为非空，非空即是真；
[ STRING1 = STRING2 ] 如果两个字符串相同则为真 ；
[ STRING1 != STRING2 ] 如果字符串不相同则为真 ；
[ STRING1 ] 如果字符串不为空则为真,与-n类似
数值判断
[ INT1 -eq INT2 ] INT1和INT2两数相等为真 ,=
[ INT1 -ne INT2 ] INT1和INT2两数不等为真 ,<>
[ INT1 -gt INT2 ] INT1大于INT1为真 ,>
[ INT1 -ge INT2 ] INT1大于等于INT2为真,>=
[ INT1 -lt INT2 ] INT1小于INT2为真 ,<
[ INT1 -le INT2 ] INT1小于等于INT2为真,<=
复杂逻辑判断
-a 与
-o 或
! 非
举例
和C语言类似，在Shell中用if、then、elif、else、fi这几条命令实现分支控制。这种流程控制语句本质上也是由若干条Shell命令组成的，例如先前讲过的
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
其实是三条命令，if [ -f ∼/.bashrc ]是第一条，then . ∼/.bashrc是第二条，fi是第三条。如果两条命令写在同一行则需要用;号隔开，一行只写一条命令就不需要写;号了，另外，then后面有换行，但这条命令没写完，Shell会自动续行，把下一行接在then后面当作一条命令处理。和[命令一样，要注意命令和各参数之间必须用空格隔开。if命令的参数组成一条子命令，如果该子命令的Exit Status为0（表示真），则执行then后面的子命令，如果Exit Status非0（表示假），则执行elif、else或者fi后面的子命令。if后面的子命令通常是测试命令，但也可以是其它命令。Shell脚本没有{}括号，所以用fi表示if语句块的结束。见下例：
#! /bin/sh
if [ -f /bin/bash ]
thenecho "/bin/bash is a file"
elseecho "/bin/bash is NOT a file"
fi
if :; then echo "always true"; fi
":"是一个特殊的命令，称为空命令，该命令不做任何事，但Exit Status总是真。此外，也可以执行/bin/true或/bin/false得到真或假的Exit Status。再看一个例子：
#! /bin/shecho "Is it morning? Please answer yes or no."read YES_OR_NOif [ "$YES_OR_NO" = "yes" ]; thenecho "Good morning!"
elif [ "$YES_OR_NO" = "no" ]; thenecho "Good afternoon!"
elseecho "Sorry, $YES_OR_NO not recognized. Enter yes or no."exit 1
fi
exit 0
上例中的read命令的作用是等待用户输入一行字符串，将该字符串存到一个Shell变量中。
此外，Shell还提供了&&和||语法，和C语言类似，具有Short-circuit特性，很多Shell脚本喜欢写成这样：
test “$(whoami)” != ‘root’ && (echo you are using a non-privileged account; exit 1)
&&相当于"if…then…"，而||相当于"if not…then…"。&&和||用于连接两个命令，而上面讲的-a和-o仅用于在测试表达式中连接两个测试条件，要注意它们的区别，例如：
test “$VAR” -gt 1 -a “$VAR” -lt 3
和以下写法是等价的
test “$VAR” -gt 1 && test “$VAR” -lt 3
case/esac
case命令可类比C语言的switch/case语句，esac表示case语句块的结束。C语言的case只能匹配整型或字符型常量表达式，而Shell脚本的case可以匹配字符串和Wildcard，每个匹配分支可以有若干条命令，末尾必须以;;结束，执行时找到第一个匹配的分支并执行相应的命令，然后直接跳到esac之后，不需要像C语言一样用break跳出。
除了以;;结束之外，还可以用**;&连接执行多个条件**。
(1) 实例1：
#! /bin/shecho "Is it morning? Please answer yes or no."read YES_OR_NOcase "$YES_OR_NO" inyes|y|Yes|YES)echo "Good Morning!";;[nN]*)echo "Good Afternoon!";;*)echo "Sorry, $YES_OR_NO not recognized. Enter yes or no."exit 1;;
esacexit 0
(2) 实例2：
for option in ${OPTIONS}; doecho "processing option: $option"case $option inBoardConfig*.mk)option=device/rockchip/$RK_TARGET_PRODUCT/$option;& #继续执行后面的条件*.mk)CONF=$(realpath $option)echo "switching to board: $CONF"if [ ! -f $CONF ]; thenecho "not exist!"exit 1filn -rsf $CONF $BOARD_CONFIG;;lunch) build_select_board ;;all) build_all ;;info) build_info ;;app/*|external/*) build_pkg $option ;;*) usage ;;esac
done
(3) 实例3：
使用case语句的例子可以在系统服务的脚本目录/etc/init.d中找到。这个目录下的脚本大多具有这种形式（以/etc/init.d/nfs-kernel-server为例）：
case "$1" instart)...;;stop)...;;reload | force-reload)...;;restart)...*)log_success_msg"Usage: nfs-kernel-server {start|stop|status|reload|force-reload|restart}"exit 1;;
esac
启动nfs-kernel-server服务的命令是
$ sudo /etc/init.d/nfs-kernel-server start
$1是一个特殊变量，在执行脚本时自动取值为第一个命令行参数，也就是start，所以进入start)分支执行相关的命令。同理，命令行参数指定为stop、reload或restart可以进入其它分支执行停止服务、重新加载配置文件或重新启动服务的相关命令。
循环for/do/done
Shell脚本的for循环结构和C语言很不一样，它类似于某些编程语言的foreach循环。例如：
#! /bin/sh
for FRUIT in apple banana pear; do
echo “I like $FRUIT”
done
FRUIT是一个循环变量，第一次循环$FRUIT的取值是apple，第二次取值是banana，第三次取值是pear。再比如，要将当前目录下的chap0、chap1、chap2等文件名改为chap0、chap1、chap2等（按惯例，末尾有字符的文件名表示临时文件），这个命令可以这样写：
$ for FILENAME in chap?; do mv $FILENAME $FILENAME~; done
也可以这样写：
$ for FILENAME in `ls chap?`; do mv $FILENAME $FILENAME~; done
while/do/done
while的用法和C语言类似。比如一个验证密码的脚本：
#! /bin/sh
echo “Enter password:”
read TRY
while [ “$TRY” != “secret” ]; do
echo “Sorry, try again”
read TRY
done
下面的例子通过算术运算控制循环的次数：
#! /bin/sh
COUNTER=1
while [ “$COUNTER” -lt 10 ]; do
echo “Here we go again”
COUNTER=$(($COUNTER+1))
done
另，Shell还有until循环，类似C语言的do…while。如有兴趣可在课后自行扩展学习。
break和continue
break[n]可以指定跳出几层循环；continue跳过本次循环，但不会跳出循环。
即break跳出，continue跳过。
练习：将上面验证密码的程序修改一下，如果用户输错五次密码就报错退出。
位置参数和特殊变量 $X
有很多特殊变量是被Shell自动赋值的，我们已经遇到了$?和$1。其他常用的位置参数和特殊变量在这里总结一下：
$0 相当于C语言main函数的argv[0]
$1、$2… 这些称为位置参数（Positional Parameter），相当于C语言main函数的argv[1]、argv[2]…
$# 相当于C语言main函数的argc - 1，注意这里的#后面不表示注释
$@ 表示参数列表"$1" “$2” …，例如可以用在for循环中的in后面。
$* 表示参数列表"$1" “$2” …，同上
$? 上一条命令的Exit Status
$$ 当前进程号
位置参数可以用shift命令左移。比如shift 3表示原来的$4现在变成$1，原来的$5现在变成$2等等，原来的$1、$2、$3丢弃，$0不移动。不带参数的shift命令相当于shift 1。例如：
#! /bin/sh
echo “The program $0 is now running”
echo “The first parameter is $1”
echo “The second parameter is $2”
echo “The parameter list is $@”
shift
echo “The first parameter is $1”
echo “The second parameter is $2”
echo “The parameter list is $@”
read
要与Linux交互，脚本获取键盘输入的结果是必不可少的，read可以读取键盘输入的字符。shell的read就是按行从文件(或标准输入或给定文件描述符)中读取数据的最佳选择。当使用管道、重定向方式组合命令时感觉达不到自己的需求时，不妨考虑下while read line。
read [-rs] [-a ARRAY] [-d delim] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [var_name1 var_name2 …]
read命令用于从标准输入中读取输入单行，并将读取的单行根据IFS变量分裂成多个字段，并将分割后的字段分别赋值给指定的变量列表var_name。第一个字段分配给第一个变量var_name1，第二个字段分配给第二个变量var_name2，依次到结束。如果指定的变量名少于字段数量，则多出的字段数量也同样分配给最后一个var_name，如果指定的变量命令多于字段数量，则多出的变量赋值为空。
如果没有指定任何var_name，则分割后的所有字段都存储在特定变量REPLY中。
选项说明
-a：将分裂后的字段依次存储到指定的数组中，存储的起始位置从数组的index=0开始。
-d：指定读取行的结束符号。默认结束符号为换行符。
-n：限制读取N个字符就自动结束读取，如果没有读满N个字符就按下回车或遇到换行符，也会结束读取。
-N：严格要求读满N个字符才自动结束读取，即使中途按下了回车或遇到了换行符也不结束。其中换行符或回车算一个字符。
-p：给出提示符。默认不支持"n"换行，要换行需要特殊处理，见下文示例。例如，"-p 请输入密码："
-r：禁止反斜线的转义功能。这意味着""会变成文本的一部分。
-s：静默模式。输入的内容不会回显在屏幕上。
-t：超时时间，在达到超时时间时，read退出并返回错误。不会读取任何内容，即使已经输入了一部分。
-u：从给定文件描述符(fd=N)中读取数据。
基本用法示例
(1)将读取的内容分配给数组变量，从索引号0开始分配。
[root@xuexi ~]# read -a array_test
what is you name?
[root@xuexi ~]# echo ${array_test[@]}
what is you name?
[root@xuexi ~]# echo ${array_test[0]}
what
(2)指定读取行的结束符号，而不再使用换行符。
[root@xuexi ~]# read -d ‘/’
what is you name // # 输入完尾部的"/"，自动结束read
由于没有指定var_name，所以通过$REPLY变量查看read读取的行。
[root@xuexi ~]# echo $REPLY
what is you name /
(3)限制输入字符。
例如，输入了5个字符后就结束。
[root@xuexi tmp]# read -n 5
12345
[root@xuexi tmp]# echo $REPLY # 输入12345共5个字符
12345
如果输入的字符数小于5，按下回车会立即结束读取。
[root@xuexi ~]# read -n 5
123
[root@xuexi ~]# echo $REPLY
123
但如果使用的是"-N 5"而不是"-n 5"，则严格限制读满5个字符才结束读取。
[root@xuexi ~]# read -N 5
123n4
[root@xuexi ~]# read -N 5
123 # 3后的回车(换行)算是一个字符
4
(4)使用-p选项给出输入提示。
[root@xuexi ~]# read -p "pls enter you name: "
pls enter you name: Junmajinlong
[root@xuexi ~]# echo $REPLY
Junmajinlong
"-p"选项默认不带换行功能，且也不支持"n"换行。但通过$'string’的方式特殊处理，就可以实现换行的功能。例如：
[root@node2 ~]# read -p $‘Enter your name: \n’
Enter your name:
JunMaJinLong
关于$'String’和$"String"的作用，见http://www.cnblogs.com/f-ck-need-u/p/8454364.html
(5)禁止反斜线转义功能。
[root@xuexi ~]# read -r
what is you name ?
[root@xuexi ~]# echo $REPLY
what is you name ?
(6)不回显输入的字符。比如输入密码的时候，不回显输入密码。
[root@xuexi ~]# read -s -p "please enter your password: "
please enter your password:
[root@xuexi ~]# echo $REPLY
123456
(7)将读取的行分割后赋值给变量。
[root@xuexi ~]# read var1 var2 var3
abc def galsl djks
[root@xuexi ~]# echo $var1:::$var2:::$var3
abc:::def:::galsl djks
(8)给出输入时间限制。没完成的输入将被丢弃，所以变量将赋值为空(如果在执行read前，变量已被赋值，则此变量在read超时后将被覆盖为空)。
[root@xuexi ~]# var=5
[root@xuexi ~]# read -t 3 var
1
[root@xuexi ~]# echo $var
while read line
如果read不明确指定按字符数读取文件(或标准输入)，那么默认是按行读取的，而且每读一行都会在那一行处打上标记(即文件指针。当然，按字符数读取也一样会打上标记)，表示这一次已经读取到了这个地方，使得下次仍然能够从这里开始继续向下读取。这使得read结合while使用的时候，是按行读数据非常好的方式。
例如：
[root@xuexi ~]# cat test1
a
b
c
d
# 用法示例1
[root@xuexi ~]# cat test1 | while read line;do echo $line;done
a
b
c
d
# 用法示例2
[root@xuexi ~]# while read line;do echo $line;done <test1
a
b
c
d
# 用法示例3：请对比下面这条命令和上面的
[root@xuexi ~]# while read line <test1;do echo $line;done
关于while read line，需要注意几个事项：
1.强烈建议，不要在管道后面使用while read line。正如上面第1个示例中 cat test1|while read line。因为管道会开启子shell，使得while中的命令都在子shell中执行，而且，cat test1会一次性将test1文件所有数据装入内存，如果test1文件足够大，会直接占用巨量内存。而第二个示例使用输入重定向的方式则每次只占用一行数据的内存，而且是在当前shell环境下执行的，while内的变量赋值、数组赋值在退出while后仍然有效。
2.不要使用示例3，因为测试了就知道为什么不用，它会在每次循环的时候都重新打开test1文件，使得每次都从头开始读数据，而不是每次从上一次标记的地方继续读数据。
所以，在使用while read line的时候，能用示例2的方式就用示例2，如果你还不理解或者找不到其它方式，那么直接记住这个结论。
输入输出echo
显示文本行或变量，或者把字符串输入到文件。
echo [option] string
-e 解析转义字符
-n 不回车换行。默认情况echo回显的内容后面跟一个回车换行。
echo “hellonn”
echo -e “hellonn”
echo “hello”
echo -n “hello”
管道 |
可以通过 | 把一个命令的输出传递给另一个命令做输入。
cat myfile | more
ls -l | grep “myfile”
df -k | awk ‘{print $1}’ | grep -v “文件系统”
df -k 查看磁盘空间，找到第一列，去除"文件系统"，并输出
Tee 输出内容到文件
tee命令把结果输出到标准输出，另一个副本输出到相应文件。
df -k | awk ‘{print $1}’ | grep -v “文件系统” | tee a.txt
tee -a a.txt表示追加操作。
df -k | awk ‘{print $1}’ | grep -v “文件系统” | tee -a a.txt
文件重定向
cmd > file 把标准输出重定向到新文件中
cmd >> file 追加
cmd > file 2>&1 标准出错也重定向到1所指向的file里
cmd >> file 2>&1
cmd < file1 > file2 输入输出都定向到文件里
cmd < &fd 把文件描述符fd作为标准输入
cmd > &fd 把文件描述符fd作为标准输出
cmd < &- 关闭标准输入
函数
和C语言类似，Shell中也有函数的概念，但是函数定义中没有返回值也没有参数列表。例如：
#! /bin/sh
foo(){ echo “Function foo is called”;}
echo “-=start=-”
foo
echo “-=end=-”
注意函数体的左花括号 { 和后面的命令之间必须有空格或换行，如果将最后一条命令和右花括号 } 写在同一行，命令末尾必须有分号;。但，不建议将函数定义写至一行上，不利于脚本阅读。
在定义foo()函数时并不执行函数体中的命令，就像定义变量一样，只是给foo这个名一个定义，到后面调用foo函数的时候（注意Shell中的函数调用不写括号）才执行函数体中的命令。Shell脚本中的函数必须先定义后调用，一般把函数定义语句写在脚本的前面，把函数调用和其它命令写在脚本的最后（类似C语言中的main函数，这才是整个脚本实际开始执行命令的地方）。
Shell函数没有参数列表并不表示不能传参数，事实上，函数就像是迷你脚本，调用函数时可以传任意个参数，在函数内同样是用$0、$1、$2等变量来提取参数，函数中的位置参数相当于函数的局部变量，改变这些变量并不会影响函数外面的$0、$1、$2等变量。函数中可以用return命令返回，如果return后面跟一个数字则表示函数的Exit Status。
下面这个脚本可以一次创建多个目录，各目录名通过命令行参数传入，脚本逐个测试各目录是否存在，如果目录不存在，首先打印信息然后试着创建该目录。
#! /bin/shis_directory()
{DIR_NAME=$1if [ ! -d $DIR_NAME ]; thenreturn 1elsereturn 0fi
}for DIR in "$@"; doif is_directory "$DIR"then :elseecho "$DIR doesn't exist. Creating it now..."mkdir $DIR > /dev/null 2>&1if [ $? -ne 0 ]; thenecho "Cannot create directory $DIR"exit 1fifi
done
注意：is_directory()返回0表示真返回1表示假。
判断变量是否为空
当需要忽略全空格的时候，用[ $NAME ]。
不能忽略全空格的时候，用[ “$NAME” != “” ]。
(1) 变量通过" "引号引起来
#!/bin/sh
para1=
if [ ! -n “$para1” ]; then
echo “IS NULL”
else
echo “NOT NULL”
fi
【输出结果】“IS NULL”
(2) 直接通过变量判断
#!/bin/sh
para1=
if [ ! $para1 ]; then
echo “IS NULL”
else
echo “NOT NULL”
fi
【输出结果】“IS NULL”
(3) 使用test判断
#!/bin/sh
dmin=
if test -z “$dmin”
then
echo “dmin is not set!”
else
echo “dmin is set !”
fi
【输出结果】“dmin is not set!”
(4) 使用""判断
#!/bin/sh
dmin=
if [ “$dmin” = “” ]
then
echo “dmin is not set!”
else
echo “dmin is set !”
fi
&& 和 || 的单独实用
&&：用来执行条件成立后执行的命令
||：用来执行条件不成立后的执行命令
例如：
(cd ${LICHEE_BR_DIR} && [ -x ${build_script} ] && ./${build_script})
[ $? -ne 0 ] && mk_error “build buildroot Failed” && return 1
shell脚本返回值
获取执行结果代码。使用"$?"获取。
shell 返回码 "保留的"退出码
shell返回码与函数返回码、命令返回码的区别
(1) shell返回码，标识整个脚本的执行结果状态，用"exit 返回码"表示。
(2) 函数返回码，标识一个函数的执行结果状态，用"return 返回码"表示。
(3) 命令返回码，标识一个命令的执行结果状态，在命令执行后，紧跟着获取返回码，用"$?"获取。
数组
数组定义
declare定义
使用declare -a 命令定义数组（数组的索引是从0开始计数的），接下来就可以通过[]操作符为不同索引位置的元素赋值。
declare -a names
names[0]=tom
names[1]=jack
注意：shell变量是弱类型的，数组中元素类型可以不相同
在定义数组的同时，可以同时赋值，用()表示，各元素之间用空格隔开
#定义的同时直接赋值
declare -a names=(tom jack)
#增加元素
names[2]=sue
直接定义
创建数组最简单的方法是使用()直接定义数组，括号中元素用空格隔开；在括号中也可以声明下标。实例：
#使用()直接数组
Days=()#声明一个空数组
days1=(one two three four five)#字符串不加引号也可以
#或者在()中声明下标，默认从0开始
days2=([0]=‘one’ [1]=‘two’ [2]=‘three’ [3]=‘four’)
#下标可以不连续
days3=([0]=‘one’ [2]=‘three’)
带下标定义
使用[]操作符，为每一个指定下标赋值，下标也可以不连续
header[0]=‘user’
header[1]=‘pid’
header[2]=’%CPU’
header[3]=’%MEM’
从文件读取数组
days=(`cat days.txt`)
数组操作
赋值
指定下标，使用[]操作符为元素赋值，当下标不存在时，相当于为数组增加元素
declare -a names
names[0]=tom
取值
指定下标，使用[]操作符从数组中对应元素，然后使用$取值，格式：${数组名[索引]}
days=(one two three four five)
#取出第1个元素
echo ${days[0]}
#取出第3个元素
echo ${days[2]}
获得数组中所有值：${数组名[@]}、${数组名[]}
${数组名[@]}得到是以空格隔开的元素，${数组名[]}得到的是一整个字符串。用在数组遍历中时，如果不加""，他们的效果是一样的，如果加了""，${数组名[*]}会是一个元素的字符串。
注意：${数组名}并不会获得所有值，它只会获得到第一个元素的值。即${数组名}等价于${数组名[0]}
示例：
#!/bin/bash
#数组取值
days=(one two three four)
echo ${days}
echo ${days[0]}
echo ${days[1]}
echo ${days[@]}
echo ${days[*]}
echo “**********”
names=()
names[1]=tom
names[2]=jack
echo ${names}
echo ${names[1]}
echo ${names[@]}
结果：
长度
利用"@“或”*“字符，将数组扩展成列表，然后使用”#"来获取数组元素的个数。
示例：
#!/bin/bash
#数组个数
days=(one two three four)
echo “数组days的元素个数为：${#days[@]}”
echo “*********"
names=()
names[1]=tom
names[2]=jack
echo "数组names的元素个数为：${#names[]}”
结果：
注意：如果某个元素是字符串，可以通过制定索引的方式获得该元素的长度。
遍历
存在以下三种方式：
（1）${数组名[@]}、${数组名[*]}均可以获得所有元素（不管是元素列表，还是一整个字符串），使用for循环遍历即可
（2）带数组下标的遍历，当需要使用到数组的下标时，可以使用${!数组名[@]}
（3）while循环：根据元素的个数遍历，但对于稀疏数组，可能会丢失数据
示例：
#!/bin/bash
#数组遍历
days=(one two three four)
#for循环遍历
for day in ${days[]} #或${days[@]}，但是如果加了""，就只能用"${days[@]}"
do
echo $day
done
echo "**************"
#fou循环带下标遍历
for i in ${!days[@]}
do
echo ${days[$i]}
done
echo “***************”
#while循环
names=() #数组names是一个稀疏数组
names[1]=tom
names[2]=jack
i=0
while [ $i -lt ${#names[*]} ]
do
echo ${names[$i]}
let i++
done
结果：
删除
删除一个数组或数组中元素用unset命令。
unset 数组名[索引] #删除索引下的元素
unset 数组名 #删除整个数组
连接
用()将多个数组连接在一起，()中各个数组用空格隔开。
days=(one two three four)
names=(tom jack)
days=(${days[@]} ${names[@]})
Shell脚本调试方法
Shell提供了一些用于调试脚本的选项，如：
-n 读一遍脚本中的命令但不执行，用于检查脚本中的语法错误。
-v 一边执行脚本，一边将执行过的脚本命令打印到标准错误输出。
-x 提供跟踪执行信息，将执行的每一条命令和结果依次打印出来。
这些选项有三种常见的使用方法。
在命令行提供参数
如：
$ sh -x ./script.sh
在脚本开头提供参数
如：
#! /bin/sh -x
在脚本中用set命令启用或禁用参数
set -x和set +x分别表示启用和禁用-x参数，这样可以只对脚本中的某一段进行跟踪调试。
如：
#! /bin/sh
if [ -z “$1” ]; then
set -x
echo “ERROR: Insufficient Args.”
exit 1
set +x
fi
shell中set指令的用法详解 更新时间：2020年10月16日 11:46:49 作者：曹灰灰 脚本之家
语法
set [-可选参数] [-o 选项]
功能说明
set 指令可根据不同的需求来设置当前所使用 shell 的执行方式，同时也可以用来设置或显示 shell 变量的值。当指定某个单一的选项时将设置 shell 的常用特性，如果在选项后使用 -o 参数将打开特殊特性，若是 +o 将关闭相应的特殊特性。而不带任何参数的 set 指令将显示当前 shell 中的全部变量，且总是返回 true，除非遇到非法的选项。
参数说明
可选参数及其说明如下：
-a 标示已修改的变量，以供输出至环境变量
-b 使被中止的后台程序立刻回报执行状态
-d Shell预设会用杂凑表记忆使用过的指令，以加速指令的执行。使用-d参数可取消
-e 若指令传回值不等于0，则立即退出shell
-f 取消使用通配符
-h 自动记录函数的所在位置
-k 指令所给的参数都会被视为此指令的环境变量
-l 记录for循环的变量名称
-m 使用监视模式
-n 测试模式，只读取指令，而不实际执行
-p 启动优先顺序模式
-P 启动-P参数后，执行指令时，会以实际的文件或目录来取代符号连接
-t 执行完随后的指令，即退出shell
-u 当执行时使用到未定义过的变量，则显示错误信息
-v 显示shell所读取的输入值
-H shell 可利用"!"加<指令编号>的方式来执行 history 中记录的指令
-x 执行指令后，会先显示该指令及所下的参数
+<参数> 取消某个set曾启动的参数。与-<参数>相反
-o option 特殊属性有很多，大部分与上面的可选参数功能相同，这里就不列了
重点参数
最常用的两个参数就是 -e 与 -x ，一般写在 shell 代码逻辑之前，这两个组合在一起用，可以在 debug 的时候替你节省许多时间 。
set -x 会在执行每一行 shell 脚本时，把执行的内容输出来。它可以让你看到当前执行的情况，里面涉及的变量也会被替换成实际的值。
set -e 会在执行出错时结束程序，就像其他语言中的"抛出异常"一样。（准确说，不是所有出错的时候都会结束程序，见下面的注）
注：set -e结束程序的条件比较复杂，在man bash里面，足足用了一段话描述各种情景。大多数执行都会在出错时退出，除非 shell 命令位于以下情况：
1.一个 pipeline 的非结尾部分，比如error | ok
2.一个组合语句的非结尾部分，比如ok && error || other
3.一连串语句的非结尾部分，比如error; ok
4.位于判断语句内，包括test、if、while等等。
其他用法
set：初始化位置参数。调用 set 是接一个或多个参数时，set 会把参数的值赋予位置参数，从 $1 开始赋值。如下例子：
$ cat set-it.sh
#!/bin/bash
set first second third
echo $3 $2 $1
$ ./set-it.sh
third second first
如上，在执行 set-it.sh 脚本时并没有输入参数，但是使用 set 指令后会对位置参数进行赋值。
set：显示 shell 变量。如果不带任何参数的使用 set 命令，set 指令就会显示一列已设置的 shell 变量，包括用户定义的变量和关键字变量。
$ set
BASH_VERSION=‘4.2.24(1)-release’
COLORS=/etc/DIR_COLORS
MAIL=/var/spool/mail/username
…
正则表达式及常用命令
以前我们用grep在一个文件中找出包含某些字符串的行，比如在头文件中找出一个宏定义。其实grep还可以找出符合某个模式（Pattern）的一类字符串。例如找出所有符合xxxxx@xxxx.xxx模式的字符串（也就是email地址），要求x字符可以是字母、数字、下划线、小数点或减号，email地址的每一部分可以有一个或多个x字符，例如abc.d@ef.com、1_2@987-6.54，当然符合这个模式的不全是合法的email地址，但至少可以做一次初步筛选，筛掉a.b、c@d等肯定不是email地址的字符串。再比如，找出所有符合yyy.yyy.yyy.yyy模式的字符串（也就是IP地址），要求y是0-9的数字，IP地址的每一部分可以有1-3个y字符。
如果要用grep查找一个模式，如何表示这个模式，这一类字符串，而不是一个特定的字符串呢？从这两个简单的例子可以看出，要表示一个模式至少应该包含以下信息：
字符类（Character Class）：如上例的x和y，它们在模式中表示一个字符，但是取值范围是一类字符中的任意一个。
数量限定符（Quantifier）： 邮件地址的每一部分可以有一个或多个x字符，IP地址的每一部分可以有1-3个y字符。
各种字符类以及普通字符之间的位置关系：例如邮件地址分三部分，用普通字符@和.隔开，IP地址分四部分，用.隔开，每一部分都可以用字符类和数量限定符描述。为了表示位置关系，还有位置限定符（Anchor）的概念，将在下面介绍。
规定一些特殊语法表示字符类、数量限定符和位置关系，然后用这些特殊语法和普通字符一起表示一个模式，这就是正则表达式（Regular Expression）。例如email地址的正则表达式可以写成[a-zA-Z0-9.-]+@[a-zA-Z0-9.-]+.[a-zA-Z0-9_.-]+，IP地址的正则表达式可以写成[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}。下一节介绍正则表达式的语法，我们先看看正则表达式在grep中怎么用。例如有这样一个文本文件testfile：
192.168.1.1
1234.234.04.5678
123.4234.045.678
abcde
$ egrep ‘[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}’ testfile
192.168.1.1
1234.234.04.5678
egrep相当于grep -E，表示采用Extended正则表达式语法。grep的正则表达式有Basic和Extended两种规范，它们之间的区别下一节再解释。另外还有fgrep命令，相当于grep -F，表示只搜索固定字符串而不搜索正则表达式模式，不会按正则表达式的语法解释后面的参数。
注意正则表达式参数用单引号括起来了，因为正则表达式中用到的很多特殊字符在Shell中也有特殊含义（例如），只有用单引号括起来才能保证这些字符原封不动地传给grep命令，而不会被Shell解释掉。
192.168.1.1符合上述模式，由三个.隔开的四段组成，每段都是1到3个数字，所以这一行被找出来了，可为什么1234.234.04.5678也被找出来了呢？因为grep找的是包含某一模式的行，这一行包含一个符合模式的字符串234.234.04.567。相反，123.4234.045.678这一行不包含符合模式的字符串，所以不会被找出来。
grep是一种查找过滤工具，正则表达式在grep中用来查找符合模式的字符串。其实正则表达式还有一个重要的应用是验证用户输入是否合法，例如用户通过网页表单提交自己的email地址，就需要用程序验证一下是不是合法的email地址，这个工作可以在网页的Javascript中做，也可以在网站后台的程序中做，例如PHP、Perl、Python、Ruby、Java或C，所有这些语言都支持正则表达式，可以说，目前不支持正则表达式的编程语言实在很少见。除了编程语言之外，很多UNIX命令和工具也都支持正则表达式，例如grep、vi、sed、awk、emacs等等。"正则表达式"就像"变量"一样，它是一个广泛的概念，而不是某一种工具或编程语言的特性。
基本语法
我们知道C的变量和Shell脚本变量的定义和使用方法很不相同，表达能力也不相同，C的变量有各种类型，而Shell脚本变量都是字符串。同样道理，各种工具和编程语言所使用的正则表达式规范的语法并不相同，表达能力也各不相同，有的正则表达式规范引入很多扩展，能表达更复杂的模式，但各种正则表达式规范的基本概念都是相通的。本节介绍egrep(1)所使用的正则表达式，它大致上符合POSIX正则表达式规范，详见regex(7)（看这个man page对你的英文绝对是很好的锻炼）。希望读者仿照上一节的例子，一边学习语法，一边用egrep命令做实验。
字符类
(1) 数量限定符
再次注意grep找的是包含某一模式的行，而不是完全匹配某一模式的行。
例如有如下文本：
aaabc
aad
efg
查找a这个模式的结果。会发现，三行都被找了出来。
$ egrep 'a’ testfile
aaabc
aad
efg
a匹配0个或多个a，而第三行包含0个a，所以也包含了这一模式。单独用a这样的正则表达式做查找没什么意义，一般是把a作为正则表达式的一部分来用。
(2) 位置限定符
位置限定符可以帮助grep更准确地查找。
例如上一节我们用[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}查找IP地址，找到这两行
192.168.1.1
1234.234.04.5678
如果用^[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}$查找，就可以把1234.234.04.5678这一行过滤掉了。
(3) 其它特殊字符
Basic正则和Extended正则区别
以上介绍的是grep正则表达式的Extended规范，Basic规范也有这些语法，只是字符?+{}|()应解释为普通字符，要表示上述特殊含义则需要加转义。如果用grep而不是egrep，并且不加-E参数，则应该遵照Basic规范来写正则表达式。
grep
作用
Linux系统中grep命令是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹 配的行打印出来。grep全称是Global Regular Expression Print，表示全局正则表达式版本，它的使用权限是所有用户。
grep家族包括grep、egrep和fgrep。egrep和fgrep的命令只跟grep有很小不同。egrep是grep的扩展，支持更多的re元字符， fgrep就是fixed grep或fast grep，它们把所有的字母都看作单词，也就是说，正则表达式中的元字符表示回其自身的字面意义，不再特殊。linux使用GNU版本的grep。它功能更强，可以通过-G、-E、-F命令行选项来使用egrep和fgrep的功能。
格式及主要参数
grep [options] pattern
主要参数：grep --help可查看
-a --text # 不要忽略二进制数据。
-A <显示行数> --after-context=<显示行数> # 除了显示符合范本样式的那一行之外，并显示该行之后的内容。
-b --byte-offset # 在显示符合范本样式的那一行之外，并显示该行之前的内容。
-B<显示行数> --before-context=<显示行数> # 除了显示符合样式的那一行之外，并显示该行之前的内容。
-c --count # 计算符合范本样式的行数。
-C<显示行数> --context=<显示行数>或-<显示行数> # 除了显示符合范本样式的那一列之外，并显示该列之前后的内容。
-d<进行动作> --directories=<动作> # 当指定要查找的是目录而非文件时，必须使用这项参数，否则grep命令将回报信息并停止动作。
-e<范本样式> --regexp=<范本样式> # 指定字符串作为查找文件内容的范本样式。
-E --extended-regexp # 将范本样式为延伸的普通表示法来使用，意味着使用能使用扩展正则表达式。
-f<范本文件> --file=<规则文件> # 指定范本文件，其内容有一个或多个范本样式，让grep查找符合范本条件的文件内容，格式为每一列的范本样式。
-F --fixed-regexp # 将范本样式视为固定字符串的列表。
-G --basic-regexp # 将范本样式视为普通的表示法来使用。
-h --no-filename # 在显示符合范本样式的那一列之前，不标示该列所属的文件名称。
-H --with-filename # 在显示符合范本样式的那一列之前，标示该列的文件名称。
-i --ignore-case # 忽略字符大小写的差别。
-l --file-with-matches # 列出文件内容符合指定的范本样式的文件名称。
-L --files-without-match # 列出文件内容不符合指定的范本样式的文件名称。
-n --line-number # 在显示符合范本样式的那一列之前，标示出该列的编号。
-q --quiet或–silent # 不显示任何信息。
-R/-r --recursive # 此参数的效果和指定"-d recurse"参数相同。
-s --no-messages # 不显示错误信息。
-v --revert-match # 反转查找。
-V --version # 显示版本信息。
-w --word-regexp # 只显示全字符合的列。
-x --line-regexp # 只显示全列符合的列。
-y # 此参数效果跟"-i"相同。
-o # 只输出文件中匹配到的部分。
–color=auto ：可以将找到的关键词部分加上颜色的显示。
pattern正则表达式主要参数:
^ # 锚定行的开始 如：’^grep’匹配所有以grep开头的行。
$ # 锚定行的结束 如：'grep$'匹配所有以grep结尾的行。
. # 匹配一个非换行符的字符 如：'gr.p’匹配gr后接一个任意字符，然后是p。
* # 匹配零个或多个先前字符 如：'grep’匹配所有一个或多个空格后紧跟grep的行。
.* # 一起用代表任意字符。 [] # 匹配一个指定范围内的字符，如’[Gg]rep’匹配Grep和grep。
[^] # 匹配一个不在指定范围内的字符，如：’[^A-FH-Z]rep’匹配不包含A-R和T-Z的一个字母开头，紧跟rep的行。
(…) # 标记匹配字符，如’(love)’，love被标记为1。
< # 锚定单词的开始，如:’<grep’匹配包含以grep开头的单词的行。
> # 锚定单词的结束，如’grep>'匹配包含以grep结尾的单词的行。
x{m} # 重复字符x，m次，如：'0{5}'匹配包含5个o的行。
x{m,} # 重复字符x,至少m次，如：'o{5,}'匹配至少有5个o的行。x{m,n} # 重复字符x，至少m次，不多于n次，如：'o{5,10}'匹配5–10个o的行。
w # 匹配文字和数字字符，也就是[A-Za-z0-9]，如：'Gwp’匹配以G后跟零个或多个文字或数字字符，然后是p。
W # w的反置形式，匹配一个或多个非单词字符，如点号句号等。
b # 单词锁定符，如: 'bgrepb’只匹配grep。
grep命令使用简单实例
itcast$ grep ‘test’ d*
显示所有以d开头的文件中包含 test的行
itcast $ grep ‘test’ aa bb cc
显示在aa，bb，cc文件中匹配test的行。
itcast $ grep ‘[a-z]{5}’ aa
显示所有包含每个字符串至少有5个连续小写字符的字符串的行。
itcast $ grep 'wesest.1′ aa
如果west被匹配，则es就被存储到内存中，并标记为1，然后搜索任意个字符(.)，这些字符后面紧跟着 另外一个es(1)，找到就显示该行。如果用egrep或grep -E，就不用""号进行转义，直接写成’w(es)t.*1′就可以了。
grep命令使用复杂实例
明确要求搜索子目录：
grep -r
或忽略子目录
grep -d skip
如果有很多输出时，您可以通过管道将其转到’less’上阅读：
itcast$ grep magic /usr/src/Linux/Documentation/* | less
这样，您就可以更方便地阅读。
有一点要注意，您必需提供一个文件过滤方式(搜索全部文件的话用 *)。如果您忘了，'grep’会一直等着，直到该程序被中断。如果您遇到了这样的情况，按 ，然后再试。
下面还有一些有意思的命令行参数：
grep -i pattern files ：不区分大小写地搜索。默认情况区分大小写，
grep -l pattern files ：只列出匹配的文件名，
grep -L pattern files ：列出不匹配的文件名，
grep -w pattern files ：只匹配整个单词，而不是字符串的一部分(如匹配’magic’，而不是’magical’)，
grep -C number pattern files ：匹配的上下文分别显示[number]行，
grep pattern1 | pattern2 files ：显示匹配 pattern1 或 pattern2 的行，
例如：grep “abc|xyz” testfile 表示过滤包含abc或xyz的行
grep pattern1 files | grep pattern2 ：显示既匹配 pattern1 又匹配 pattern2 的行。
grep -n pattern files 即可显示行号信息
grep -c pattern files 即可查找总行数
还有些用于搜索的特殊符号：< 和 > 分别标注单词的开始与结尾。
例如：
grep man * 会匹配 ‘Batman’、‘manic’、‘man’等，
grep ‘<man’ * 匹配’manic’和’man’，但不是’Batman’，
grep ‘’ 只匹配’man’，而不是’Batman’或’manic’等其他的字符串。
‘^’： 指匹配的字符串在行首，
‘$’： 指匹配的字符串在行 尾，
find
由于find具有强大的功能，所以它的选项也很多，其中大部分选项都值得我们花时间来了解一下。即使系统中含有网络文件系统( NFS)，find命令在该文件系统中同样有效，只要你具有相应的权限。
在运行一个非常消耗资源的find命令时，很多人都倾向于把它放在后台执行，因为遍历一个大的文件系统可能会花费很长的时间(这里是指30G字节以上的文件系统)。
find 命令格式
1、find命令的一般形式为
find pathname -options [-print -exec -ok …]
2、find命令的参数；
pathname: find命令所查找的目录路径。例如用.来表示当前目录，用/来表示系统根目录，递归查找。
-print： find命令将匹配的文件输出到标准输出。
-exec： find命令对匹配的文件执行该参数所给出的shell命令。相应命令的形式为’command’ {} \;，注意{}内部无空格，和\；之间含有一个空格分隔符。
-ok： 和-exec的作用相同，只不过以一种更为安全的模式来执行该参数所给出的shell命令，在执行每一个命令之前，都会给出提示，让用户来确定是否执行。
3、find命令选项
-name 按照文件名查找文件。
-perm 按照文件权限来查找文件。
-prune 使用这一选项可以使find命令不在当前指定的目录中查找，如果同时使用-depth选项，那么-prune将被find命令忽略。
-user 按照文件属主来查找文件。
-group 按照文件所属的组来查找文件。
-mtime -n +n 按照文件的更改时间来查找文件，-n表示文件更改时间距现在n天以内，+n表示文件更改时间距现在n天以前。find命令还有-atime和-ctime 选项，但它们都和-m time选项。
-nogroup 查找无有效所属组的文件，即该文件所属的组在/etc/groups中不存在。
-nouser 查找无有效属主的文件，即该文件的属主在/etc/passwd中不存在。
-newer file1 ! file2 查找更改时间比文件file1新但比文件file2旧的文件。
-type 查找某一类型的文件，诸如：
b - 块设备文件。
d - 目录。
c - 字符设备文件。
p - 管道文件。
l - 符号链接文件。
f - 普通文件。
-xtype<文件类型> 文件类型和-type一样，区别在于查找有问题的相关文件。
-size n：[c] 查找文件长度为n块的文件，带有c时表示文件长度以字节计。
-depth 在查找文件时，首先查找当前目录中的文件，然后再在其子目录中查找。
-maxdepth 查找目录深度，-maxdepth 1 只查找当前目录
-fstype 查找位于某一类型文件系统中的文件，这些文件系统类型通常可以在配置文件/etc/fstab中找到，该配置文件中包含了本系统中有关文件系统的信息。
-mount 在查找文件时不跨越文件系统mount点。
-follow 如果find命令遇到符号链接文件，就跟踪至链接所指向的文件。
另外,下面三个的区别:
-amin n 查找系统中最后N分钟访问的文件
-atime n 查找系统中最后n24小时访问的文件
-cmin n 查找系统中最后N分钟被改变文件状态的文件
-ctime n 查找系统中最后n24小时被改变文件状态的文件
-mmin n 查找系统中最后N分钟被改变文件数据的文件
-mtime n 查找系统中最后n*24小时被改变文件数据的文件
-amin<分钟> 查找在指定时间曾被存取过的文件或目录，单位以分钟计算。
-anewer<参考文件或目录> 查找其存取时间较指定文件或目录的存取时间更接近现在的文件或目录。
-atime<24小时数> 查找在指定时间曾被存取过的文件或目录，单位以24小时计算。
-cmin<分钟> 查找在指定时间之时被更改的文件或目录。
-cnewer<参考文件或目录> 查找其更改时间较指定文件或目录的更改时间更接近现在的文件或目录。
-ctime<24小时数> 查找在指定时间之时被更改的文件或目录，单位以24小时计算。
-daystart 从本日开始计算时间。
-depth 从指定目录下最深层的子目录开始查找。
-expty 寻找文件大小为0 Byte的文件，或目录下没有任何子目录或文件的空目录。
-exec<执行指令> 假设find指令的回传值为True，就执行该指令。
-false 将find指令的回传值皆设为False。
-fls<列表文件> 此参数的效果和指定"-ls"参数类似，但会把结果保存为指定的列表文件。
-follow 排除符号连接。
-fprint<列表文件> 此参数的效果和指定"-print"参数类似，但会把结果保存成指定的列表文件。
-fprint0<列表文件> 此参数的效果和指定"-print0"参数类似，但会把结果保存成指定的列表文件。
-fprintf<列表文件><输出格式> 此参数的效果和指定"-printf"参数类似，但会把结果保存成指定的列表文件。
-fstype<文件系统类型> 只寻找该文件系统类型下的文件或目录。
-gid<群组识别码> 查找符合指定之群组识别码的文件或目录。
-group<群组名称> 查找符合指定之群组名称的文件或目录。
-help或–help 在线帮助。
-ilname<范本样式> 此参数的效果和指定"-lname"参数类似，但忽略字符大小写的差别。
-iname<范本样式> 此参数的效果和指定"-name"参数类似，但忽略字符大小写的差别。
-inum<inode编号> 查找符合指定的inode编号的文件或目录。
-ipath<范本样式> 此参数的效果和指定"-ipath"参数类似，但忽略字符大小写的差别。
-iregex<范本样式> 此参数的效果和指定"-regexe"参数类似，但忽略字符大小写的差别。
-links<连接数目> 查找符合指定的硬连接数目的文件或目录。
-iname<范本样式> 指定字符串作为寻找符号连接的范本样式。
-ls 假设find指令的回传值为True，就将文件或目录名称列出到标准输出。
-maxdepth<目录层级> 设置最大目录层级。
-mindepth<目录层级> 设置最小目录层级。
-mmin<分钟> 查找在指定时间曾被更改过的文件或目录，单位以分钟计算。
-mount 此参数的效果和指定"-xdev"相同。
-mtime<24小时数> 查找在指定时间曾被更改过的文件或目录，单位以24小时计算。
-name<范本样式> 指定字符串作为寻找文件或目录的范本样式。
-newer<参考文件或目录> 查找其更改时间较指定文件或目录的更改时间更接近现在的文件或目录。
-nogroup 找出不属于本地主机群组识别码的文件或目录。
-noleaf 不去考虑目录至少需拥有两个硬连接存在。
-nouser 找出不属于本地主机用户识别码的文件或目录。
-ok<执行指令> 此参数的效果和指定"-exec"参数类似，但在执行指令之前会先询问用户，若回答"y"或"Y"，则放弃执行指令。
-path<范本样式> 指定字符串作为寻找目录的范本样式。
-perm<权限数值> 查找符合指定的权限数值的文件或目录。
-print 假设find指令的回传值为True，就将文件或目录名称列出到标准输出。格式为每列一个名称，每个名称之前皆有"./"字符串。
-print0 假设find指令的回传值为True，就将文件或目录名称列出到标准输出。格式为全部的名称皆在同一行。
-printf<输出格式> 假设find指令的回传值为True，就将文件或目录名称列出到标准输出。格式可以自行指定。
-prune 不寻找字符串作为寻找文件或目录的范本样式。
-regex<范本样式> 指定字符串作为寻找文件或目录的范本样式。
-size<文件大小> 查找符合指定的文件大小的文件。
-true 将find指令的回传值皆设为True。
-uid<用户识别码> 查找符合指定的用户识别码的文件或目录。
-used<日数> 查找文件或目录被更改之后在指定时间曾被存取过的文件或目录，单位以日计算。
-user<拥有者名称> 查找符合指定的拥有者名称的文件或目录。
-version或–version 显示版本信息。
-xdev 将范围局限在先行的文件系统中。
4、使用exec或ok来执行shell命令
使用find时，只要把想要的操作写在一个文件里，就可以用exec来配合find查找，很方便的。
在有些操作系统中只允许-exec选项执行诸如ls或ls -l这样的命令。大多数用户使用这一选项是为了查找旧文件并删除它们。建议在真正执行rm命令删除文件之前，最好先用ls命令看一下，确认它们是所要删除的文件。
exec选项后面跟随着所要执行的命令或脚本，然后是一对儿{}，一个空格和一个，最后是一个分号。为了使用exec选项，必须要同时使用print选项。如果验证一下find命令，会发现该命令只输出从当前路径起的相对路径及文件名。
例如：为了用ls -l命令列出所匹配到的文件，可以把ls -l命令放在find命令的-exec选项中
# find . -type f -exec ls -l {} \;
上面的例子中，find命令匹配到了当前目录下的所有普通文件，并在-exec选项中使用ls -l命令将它们列出。
在/logs目录中查找更改时间在5日以前的文件并删除它们：
$ find logs -type f -mtime +5 -exec rm {} \;
记住：在shell中用任何方式删除文件之前，应当先查看相应的文件，一定要小心！当使用诸如mv或rm命令时，可以使用-exec选项的安全模式。它将在对每个匹配到的文件进行操作之前提示你。
在下面的例子中， find命令在当前目录中查找所有文件名以.conf结尾、更改时间在5日以上的文件，并删除它们，只不过在删除之前先给出提示。
$ find . -name “*.conf” -mtime +5 -ok rm {} \;
< rm … ./conf/httpd.conf > ? n
按y键删除文件，按n键不删除。
任何形式的命令都可以在-exec选项中使用。
在下面的例子中我们使用grep命令。find命令首先匹配所有文件名为" passwd*"的文件，例如passwd、passwd.old、passwd.bak，然后执行grep命令看看在这些文件中是否存在一个itcast用户。
# find /etc -name “passwd*” -exec grep “itcast” {} \;
itcast:\x:1000:1000::/home/itcast:/bin/bash
find命令的例子
1、查找当前用户主目录下的所有文件：
下面两种方法都可以使用
$ find $HOME -print
$ find ~ -print
2、让当前目录中文件属主具有读、写权限，并且文件所属组的用户和其他用户具有读权限的文件；
$ find . -type f -perm 644 -exec ls -l {} \;
3、为了查找系统中所有文件长度为0的普通文件，并列出它们的完整路径；
$ find / -type f -size 0 -exec ls -l {} \;
4、查找/var/logs目录中更改时间在7日以前的普通文件，并在删除之前询问它们；
$ find /var/logs -type f -mtime +7 -ok rm {} \;
5、为了查找系统中所有属于root组的文件；
$find . -group root -exec ls -l {} \;
6、find命令将删除当目录中访问时间在7日以来、含有数字后缀的admin.log文件。
该命令只检查三位数字，所以相应文件的后缀不要超过999。先建几个admin.log*的文件 ，才能使用下面这个命令
$ find . -name “admin.log[0-9][0-9][0-9]” -atime -7 -ok rm {} \;
7、为了查找当前文件系统中的所有目录并排序；
$ find . -type d | sort
find 命令的参数
(1) 使用name选项
文件名选项是find命令最常用的选项，要么单独使用该选项，要么和其他选项一起使用。可以使用某种文件名模式来匹配文件，记住要用引号将文件名模式引起来。不管当前路径是什么，如果想要在自己的根目录HOME中查找文件名符合∗.txt的文件，使用’~'作为 ‘pathname’ 的参数，波浪号代表了你的HOME目录。
$ find ~ -name “*.txt” -print
想要在当前目录及子目录中查找所有的’ .txt’文件，可以用：
$ find . -name ".txt" -print
想要的当前目录及子目录中查找文件名以一个大写字母开头的文件，可以用：
$ find . -name “[A-Z]*” -print
想要在/etc目录中查找文件名以host开头的文件，可以用：
$ find /etc -name “host*” -print
想要查找$HOME目录中的文件，可以用：
$ find ~ -name “*” -print 或find . --print
要想让系统高负荷运行，就从根目录开始查找所有的文件：
$ find / -name “*” -print
如果想在当前目录查找文件名以两个小写字母开头，跟着是两个数字，最后是.txt的文件，下面的命令就能够返回例如名为ax37.txt的文件：
$find . -name “[a-z][a-z][0-9][0-9].txt” -print
(2) 用perm选项
按照文件权限模式用-perm选项,按文件权限模式来查找文件的话。最好使用八进制的权限表示法。如在当前目录下查找文件权限位为755的文件，即文件属主可以读、写、执行，其他用户可以读、执行的文件，可以用：
$ find . -perm 755 -print
还有一种表达方法：在八进制数字前面要加一个横杠-，表示都匹配，如-007就相当于777，-006相当于666
# ls -l
# find . -perm 006
# find . -perm -006
-perm mode:文件许可正好符合mode
-perm +mode:文件许可部分符合mode
-perm -mode: 文件许可完全符合mode
(3) prune忽略某个目录
如果在查找文件时希望忽略某个目录，因为你知道那个目录中没有你所要查找的文件，那么可以使用-prune选项来指出需要忽略的目录。在使用-prune选项时要当心，因为如果你同时使用了-depth选项，那么-prune选项就会被find命令忽略。
如果希望在/apps目录下查找文件，但不希望在/apps/bin目录下查找，可以用：
$ find /apps -path “/apps/bin” -prune -o -print
比如要在/home/itcast目录下查找不在dir1子目录之内的所有文件
find /home/itcast -path “/home/itcast/dir1” -prune -o -print
避开多个文件夹
find /usr/sam ( -path /usr/sam/dir1 -o -path /usr/sam/file1 ) -prune -o -print
注意()前后的空格。
(5) 使用user和nouser选项
按文件属主查找文件，如在$HOME目录中查找文件属主为itcast的文件，可以用：
$ find ~ -user itcast -print
在/etc目录下查找文件属主为uucp的文件：
$ find /etc -user uucp -print
为了查找属主帐户已经被删除的文件，可以使用-nouser选项。这样就能够找到那些属主在/etc/passwd文件中没有有效帐户的文件。在使用-nouser选项时，不必给出用户名；find命令能够为你完成相应的工作。
例如，希望在/home目录下查找所有的这类文件，可以用：
$ find /home -nouser -print
(6) 使用group和nogroup选项
就像user和nouser选项一样，针对文件所属于的用户组， find命令也具有同样的选项，为了在/apps目录下查找属于itcast用户组的文件，可以用：
$ find /apps -group itcast -print
要查找没有有效所属用户组的所有文件，可以使用nogroup选项。下面的find命令从文件系统的根目录处查找这样的文件
$ find / -nogroup -print
(7) 按照更改时间或访问时间等查找文件
如果希望按照更改时间来查找文件，可以使用mtime,atime或ctime选项。如果系统突然没有可用空间了，很有可能某一个文件的长度在此期间增长迅速，这时就可以用mtime选项来查找这样的文件。用减号-来限定更改时间在距今n日以内的文件，而用加号+来限定更改时间在距今n日以前的文件。
希望在系统根目录下查找更改时间在5日以内的文件，可以用：
$ find / -mtime -5 -print
为了在/var/adm目录下查找更改时间在3日以前的文件，可以用：
$ find /var/adm -mtime +3 -print
(8) 查找比某个文件新或旧的文件
如果希望查找更改时间比某个文件新但比另一个文件旧的所有文件，可以使用-newer选项。它的一般形式为：
newest_file_name ! oldest_file_name
其中，！是逻辑非符号。
(9) 使用type选项
在/etc目录下查找所有的目录，可以用：
$ find /etc -type d -print
在当前目录下查找除目录以外的所有类型的文件，可以用：
$ find . ! -type d -print
在/etc目录下查找所有的符号链接文件，可以用
$ find /etc -type l -print
(10) 使用size选项
可以按照文件长度来查找文件，这里所指的文件长度既可以用块（block）来计量，也可以用字节来计量。以字节计量文件长度的表达形式为N c；以块计量文件长度只用数字表示即可。在按照文件长度查找文件时，一般使用这种以字节表示的文件长度，在查看文件系统的大小，因为这时使用块来计量更容易转换。 在当前目录下查找文件长度大于1 M字节的文件：
$ find . -size +1000000c -print
在/home/apache目录下查找文件长度恰好为100字节的文件：
$ find /home/apache -size 100c -print
在当前目录下查找长度超过10块的文件（一块等于512字节）：
$ find . -size +10 -print
(11) 使用depth选项
在使用find命令时，可能希望先匹配所有的文件，再在子目录中查找。使用depth选项就可以使find命令这样做。这样做的一个原因就是，当在使用find命令向磁带上备份文件系统时，希望首先备份所有的文件，其次再备份子目录中的文件。在下面的例子中， find命令从文件系统的根目录开始，查找一个名为CON.FILE的文件。
它将首先匹配所有的文件然后再进入子目录中查找。
$ find / -name “CON.FILE” -depth -print
(12) 使用mount选项
在当前的文件系统中查找文件（不进入其他文件系统），可以使用find命令的mount选项。
从当前目录开始查找位于本文件系统中文件名以XC结尾的文件：
$ find . -name “*.XC” -mount -print
练习：请找出你10天内所访问或修改过的.c和.cpp文件。
xargs
xargs是给命令传递参数的一个过滤器，也是组合多个命令的一个工具。它把一个数据流分割为一些足够小的块，以方便过滤器和命令进行处理。通常情况下，xargs从管道或者stdin中读取数据，但是它也能够从文件的输出中读取数据。xargs的默认命令是echo，这意味着通过管道传递给xargs的输入将会包含换行和空白，不过通过xargs的处理，换行和空白将被空格取代。
xargs是一个强有力的命令，它能够捕获一个命令的输出，然后传递给另外一个命令，下面是一些如何有效使用xargs 的实用例子。
xargs命令的格式
$ xargs [-options] [command]
真正执行的命令，紧跟在xargs后面，接受xargs传来的参数。
xargs 命令的作用
xargs命令的作用，是将标准输入转为命令行参数。
$ echo “hello world” | xargs echo
hello world
上面的代码将管道左侧的标准输入，转为命令行参数hello world，传给第二个echo命令。
xargs的作用在于，大多数命令（比如rm、mkdir、ls）与管道一起使用时，都需要xargs将标准输入转为命令行参数。
$ echo “one two three” | xargs mkdir
上面的代码等同于mkdir one two three。如果不加xargs就会报错，提示mkdir缺少操作参数。
xargs 的单独使用
xargs后面的命令默认是echo。
$ xargs # 等同于
$ xargs echo
大多数时候，xargs命令都是跟管道一起使用的。但是，它也可以单独使用。
输入xargs按下回车以后，命令行就会等待用户输入，作为标准输入。你可以输入任意内容，然后按下Ctrl d，表示输入结束，这时echo命令就会把前面的输入打印出来。
$ xargs
hello (Ctrl + d)
hello
再看一个例子。
$ xargs find -name
“*.txt”
./foo.txt
./hello.txt
上面的例子输入xargs find -name以后，命令行会等待用户输入所要搜索的文件。用户输入"*.txt"，表示搜索当前目录下的所有 TXT 文件，然后按下Ctrl d，表示输入结束。这时就相当执行find -name *.txt。
-d 参数与分隔符
默认情况下，xargs将换行符和空格作为分隔符，把标准输入分解成一个个命令行参数。
$ echo “one two three” | xargs mkdir
上面代码中，mkdir会新建三个子目录，因为xargs将one two three分解成三个命令行参数，执行mkdir one two three。
-d参数可以更改分隔符。
$ echo -e “atbtc” | xargs -d “t” echo
a b c
上面的命令指定制表符t作为分隔符，所以atbtc就转换成了三个命令行参数。echo命令的-e参数表示解释转义字符。
-p 参数，-t 参数
使用xargs命令以后，由于存在转换参数过程，有时需要确认一下到底执行的是什么命令。
-p参数打印出要执行的命令，询问用户是否要执行。
$ echo ‘one two three’ | xargs -p touch
touch one two three ?..
上面的命令执行以后，会打印出最终要执行的命令，让用户确认。用户输入y以后（大小写皆可），才会真正执行。
-t参数则是打印出最终要执行的命令，然后直接执行，不需要用户确认。
$ echo ‘one two three’ | xargs -t rm
rm one two three
-0 参数与 find 命令
由于xargs默认将空格作为分隔符，所以不太适合处理文件名，因为文件名可能包含空格。
find命令有一个特别的参数-print0，指定输出的文件列表以null分隔。然后，xargs命令的-0参数表示用null当作分隔符。
$ find /path -type f -print0 | xargs -0 rm
上面命令删除/path路径下的所有文件。由于分隔符是null，所以处理包含空格的文件名，也不会报错。
还有一个原因，使得xargs特别适合find命令。有些命令（比如rm）一旦参数过多会报错"参数列表过长"，而无法执行，改用xargs就没有这个问题，因为它对每个参数执行一次命令。
$ find . -name “*.txt” | xargs grep “abc”
上面命令找出所有 TXT 文件以后，对每个文件搜索一次是否包含字符串abc。
-L 参数
如果标准输入包含多行，-L参数指定多少行作为一个命令行参数。
$ xargs find -name
“.txt"
".md”
find: paths must precede expression: `*.md’
上面命令同时将".txt"和.md两行作为命令行参数，传给find命令导致报错。
使用-L参数，指定每行作为一个命令行参数，就不会报错。
$ xargs -L 1 find -name
“.txt"
./foo.txt
./hello.txt
".md”
./README.md
上面命令指定了每一行（-L 1）作为命令行参数，分别运行一次命令（find -name）。
下面是另一个例子。
$ echo -e “a\nb\nc” | xargs -L 1 echo
a
b
c
上面代码指定每行运行一次echo命令，所以echo命令执行了三次，输出了三行。
-n 参数
-L参数虽然解决了多行的问题，但是有时用户会在同一行输入多项。
$ xargs find -name
“.txt" ".md”
find: paths must precede expression: `*.md’
上面的命令将同一行的两项作为命令行参数，导致报错。
-n参数指定每次将多少项，作为命令行参数。
$ xargs -n 1 find -name
上面命令指定将每一项（-n 1）标准输入作为命令行参数，分别执行一次命令（find -name）。
下面是另一个例子。
$ echo {0…9} | xargs -n 2 echo
0 1
2 3
4 5
6 7
8 9
上面命令指定，每两个参数运行一次echo命令。所以，10个阿拉伯数字运行了五次echo命令，输出了五行。
-I 参数
如果xargs要将命令行参数传给多个命令，可以使用-I参数。
-I指定每一项命令行参数的替代字符串。
$ cat foo.txt
one
two
three
$ cat foo.txt | xargs -I file sh -c ‘echo file; mkdir file’
one
two
three
$ ls
one two three
上面代码中，foo.txt是一个三行的文本文件。我们希望对每一项命令行参数，执行两个命令（echo和mkdir），使用-I file表示file是命令行参数的替代字符串。执行命令时，具体的参数会替代掉echo file; mkdir file里面的两个file。
–max-procs 参数
xargs默认只用一个进程执行命令。如果命令要执行多次，必须等上一次执行完，才能执行下一次。
–max-procs参数指定同时用多少个进程并行执行命令。–max-procs 2表示同时最多使用两个进程，–max-procs 0表示不限制进程数。
$ docker ps -q | xargs -n 1 --max-procs 0 docker kill
上面命令表示，同时关闭尽可能多的 Docker 容器，这样运行速度会快很多。
cut
小小工匠 2016-09-17 15:17:01 58409 收藏 59
cut是一个选取命令，一般来说，选取信息通常是针对"行"来进行分析的，并不是整篇信息分析的。
语法
cut 命令从文件的每一行剪切字节、字符和字段并将这些字节、字符和字段写至标准输出。
如果不指定 File 参数，cut 命令将读取标准输入。
必须指定 -b、-c 或 -f 标志之一。
cut 默认以制表符为分隔符。
参数说明
-b ：以字节为单位进行分割。这些字节位置将忽略多字节字符边界，除非也指定了 -n 标志。
-c ：以字符为单位进行分割。
-d ：自定义分隔符，默认为制表符。
-f ：与-d一起使用，指定显示哪个区域。
-n ：取消分割多字节字符。仅和 -b 标志一起使用。如果字符的最后一个字节落在由 -b 标志的 List 参数指示的
范围之内，该字符将被写出；否则，该字符将被排除。
cut命令主要是接受三个定位方法：
第一，字节（bytes），用选项-b
第二，字符（characters），用选项-c
第三，域（fields），用选项-f
举例
提取第3,4,5,9的字节： cut -b 3-5,9
注意：cut命令如果使用-b选项，执行时会先把-b后面所有的定位进行从小到大排序，然后再提取，不能颠倒顺序。
-3 表示从第一字节到第三字节；
3.表示从第三字节到结尾。
对于中文提取，-c 会以字符为单位，输出正常；-b以字节（8位二进制）计算。
当遇到多字节字符时，使用-n选项，不会将多字节字符拆开。cut -nb 1,2,3
对于非固定格式信息，需要域。之前需要先设置间隔符，再提取第几个域。
cut -d : -f 1
-d设置间隔符为：，-f 1 为提取第一个域。
注意：如果遇到空格和制表符时，怎么辨认？
先检查这段空格是由空格组成还是制表符组成：
cat tab_space.txt
sed -n l tab_space.txt
如果是制表位（TAB），就会显示t, 如果是空格，就会原样显示。（sed中n后面的l是小写的L）
cut -d 用什么符号表示制表符或空格？
cut -d 默认间隔为制表符，可以省略。若设置空格为间隔符，则 cut -d ’ ’ -f 4
(两个单引号中要有一个空格)
而且只能在-d 后面设置一个空格，不允许有多个空格。cut允许的间隔符是一个字符。
cut的缺陷和不足
处理多空格…
如果文件里面的某些域是由若干个空格来间隔的，那么用cut就有点麻烦了，因为cut只擅长处理"以一个字符间隔"的文本内容。
sed
sed意为流编辑器（Stream Editor），在Shell脚本和Makefile中作为过滤器使用非常普遍，也就是把前一个程序的输出引入sed的输入，经过一系列编辑命令转换为另一种格式输出。sed和vi都源于早期UNIX的ed工具，所以很多sed命令和vi的末行命令是相同的。
命令格式
sed [options] ‘command’ file(s)
sed [options] -f scriptfile file(s)
选项
-e<script>或–expression=<script>：以选项中的指定的script来处理输入的文本文件；
-f<script文件>或–file=<script文件>：以选项中指定的script文件来处理输入的文本文件；
-h或–help：显示帮助；
-n或–quiet或------silent：仅显示script处理后的结果；
-V或–version：显示版本信息。
文件：指定待处理的文本文件列表。
sed命令
a 在当前行下面插入文本。
i 在当前行上面插入文本。
c 把选定的行改为新的文本。
d 删除，删除选择的行。
D 删除模板块的第一行。
s 替换指定字符
h 拷贝模板块的内容到内存中的缓冲区。
H 追加模板块的内容到内存中的缓冲区。
g 获得内存缓冲区的内容，并替代当前模板块中的文本。
G 获得内存缓冲区的内容，并追加到当前模板块文本的后面。
l 列表不能打印字符的清单。
n 读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。
N 追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。
p 打印模板块的行。
P(大写) 打印模板块的第一行。
q 退出Sed。
b lable 分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。
r file 从file中读行。
t label if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
T label 错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。
w file 写并追加模板块到file末尾。
W file 写并追加模板块的第一行到file末尾。
! 表示后面的命令对所有没有被选定的行发生作用。
= 打印当前行号码。
# 把注释扩展到下一个换行符以前。
sed替换标记
g 表示行内全面替换。
p 表示打印行。
w 表示把行写入一个文件。
x 表示互换模板块中的文本和缓冲区中的文本。
y 表示把一个字符翻译为另外的字符（但是不用于正则表达式）1 子串匹配标记& 已匹配字符串标记
sed元字符集
^ 匹配行开始，如：/^sed/匹配所有以sed开头的行。
$ 匹配行结束，如：/sed$/匹配所有以sed结尾的行。
. 匹配一个非换行符的任意字符，如：/s.d/匹配s后接一个任意字符，最后是d。
* 匹配0个或多个其前面的字符，如：/ sed/匹配所有模板是一个或多个空格后紧跟sed的行。
+ 与星号()相同，只是至少重复1次，GNU的扩展功能。
? 与星号(*)相同，只是最多重复1次，GNU的扩展功能。
[] 匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
[^] 匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
(…) 匹配子串，保存匹配的字符，如s/(love)able/1rs，loveable被替换成lovers。
& 保存搜索字符用来替换其他字符，如s/love/&/，love这成love。
< 匹配单词的开始，如:/<love/匹配包含以love开头的单词的行。
> 匹配单词的结束，如/love>/匹配包含以love结尾的单词的行。
x{m} 重复字符x，m次，如：/0{5}/匹配包含5个0的行。
x{m,} 重复字符x，至少m次，如：/0{5,}/匹配至少有5个0的行。
x{m,n} 重复字符x，至少m次，不多于n次，如：/0{5,10}/匹配5~10个0的行。
sed用法实例
注意：sed的操作是基于行的，如果指定行，用x p，或者x s，可以有空格。
(1) 替换操作：s命令
替换文本中的字符串：
sed ‘s/book/books/’ file
-n选项和p命令一起使用表示只打印那些发生替换的行：
sed -n ‘s/test/TEST/p’ file
直接编辑文件选项-i，会匹配file文件中每一行的第一个book替换为books：
sed -i ‘s/book/books/’ file
全面替换标记g
使用后缀 /g 标记会替换每一行中的所有匹配：
sed ‘s/book/books/g’ file
当需要从第N处匹配开始替换时，可以使用 /Ng：
echo sksksksksksk | sed ‘s/sk/SK/2g’
skSKSKSKSKSK
echo sksksksksksk | sed ‘s/sk/SK/3g’
skskSKSKSKSK
echo ksksksksksk | sed ‘s/sk/SK/4g’
skskskSKSKSK
上面的g，仅对行有效，不能用来替换文件中的第几个，如果替换文件的第几个，可以指定行，用：
sed “x s/s1/s2/g” file
(2) 定界符
以上命令中字符 / 在sed中作为定界符使用，也可以使用任意的定界符：
sed ‘s:test:TEXT:g’
sed ‘s|test|TEXT|g’
定界符出现在样式内部时，需要进行转义：
sed ‘s//bin//usr/local/bin/g’
(3) 删除操作：d命令
删除空白行：
sed ‘/^$/d’ file
删除文件的第2行：
sed ‘2d’ file
删除文件的第2行到末尾所有行：
sed ‘2,$d’ file
删除文件最后一行：
sed ‘$d’ file
删除文件中所有开头是test的行：
sed '/^test/'d file
(4) 已匹配字符串标记&
正则表达式 w+ 匹配每一个单词，使用 [&] 替换它，& 对应于之前所匹配到的单词：
echo this is a test line | sed ‘s/w+/[&]/g’
[this] [is] [a] [test] [line]
所有以192.168.0.1开头的行都会被替换成它自已加localhost：
sed ‘s/^192.168.0.1/&localhost/’ file
192.168.0.1localhost
(5) 子串匹配标记1
匹配给定样式的其中一部分：
echo this is digit 7 in a number | sed ‘s/digit ([0-9])/1/’
this is 7 in a number
命令中 digit 7，被替换成了 7。样式匹配到的子串是 7，(…) 用于匹配子串，对于匹配到的第一个子串就标记为 1，依此类推匹配到的第二个结果就是 2，例如：
echo aaa BBB | sed ‘s/([a-z]+) ([A-Z]+)/2 1/’
BBB aaa
love被标记为1，所有loveable会被替换成lovers，并打印出来：
sed -n ‘s/(love)able/1rs/p’ file
(6) 组合多个表达式 " ; "
sed ‘表达式’ | sed ‘表达式’
等价于：
sed ‘表达式; 表达式’
(7) 引用 ’ ’ " "
sed表达式可以使用单引号来引用，但是如果表达式内部包含变量字符串，就需要使用双引号。
test=hello
echo hello WORLD | sed “s/$test/HELLO”
HELLO WORLD
(8) 选定行的范围：,（逗号）
所有在模板test和check所确定的范围内的行都被打印：
sed -n ‘/test/,/check/p’ file
打印从第5行开始到第一个包含以test开始的行之间的所有行：
sed -n ‘5,/^test/p’ file
对于模板test和west之间的行，每行的末尾用字符串aaa bbb替换：
sed ‘/test/,/west/s/$/aaa bbb/’ file
(9) 多点编辑：e命令
-e选项允许在同一行里执行多条命令：
sed -e ‘1,5d’ -e ‘s/test/check/’ file
上面sed表达式的第一条命令删除1至5行，第二条命令用check替换test。命令的执行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。
和 -e 等价的命令是 --expression：
sed --expression=‘s/test/check/’ --expression=’/love/d’ file
(10) 从文件读入：r命令
file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面：
sed ‘/test/r file’ filename
(11) 写入文件：w命令
在example中所有包含test的行都被写入file里：
sed -n ‘/test/w file’ example
(12) 追加（行下）：a命令
将 this is a test line 追加到 以test 开头的行后面：
sed ‘/^test/athis is a test line’ file
在 test.conf 文件第2行之后插入 this is a test line：
sed -i ‘2athis is a test line’ test.conf
(13) 插入（行上）：i命令
将 this is a test line 追加到以test开头的行前面：
sed ‘/^test/ithis is a test line’ file
在test.conf文件第5行之前插入this is a test line：
sed -i ‘5ithis is a test line’ test.conf
(14) 下一个：n命令
如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续：
sed ‘/test/{ n; s/aa/bb/; }’ file
(15) 变形：y命令
把1~10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令：
sed ‘1,10y/abcde/ABCDE/’ file
(16) 退出：q命令
打印完第10行后，退出sed
sed ‘10q’ file
(17) 保持和获取：h命令和G命令
在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将 打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。
sed -e ‘/test/h’ -e ‘$G’ file
在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中的行的末尾。在这个例子中就是追加到最后一行。简单来说，任何包含test的行都被复制并追加到该文件的末尾。
(18) 保持和互换：h命令和x命令
互换模式空间和保持缓冲区的内容。也就是把包含test与check的行互换：
sed -e ‘/test/h’ -e ‘/check/x’ file
(19) 脚本scriptfile
sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。
sed [options] -f scriptfile file(s)
(20) 打印奇数行或偶数行
方法1：
sed -n ‘p;n’ test.txt #奇数行
sed -n ‘n;p’ test.txt #偶数行
方法2：
sed -n ‘1~2p’ test.txt #奇数行
sed -n ‘2~2p’ test.txt #偶数行
(21) 打印匹配字符串的下一行
grep -A 1 SCC URFILE
sed -n ‘/SCC/{n;p}’ URFILE
awk ‘/SCC/{getline; print}’ URFILE
awk
StoneStore 2019-04-25 11:09:45 36765 收藏 249
sed以行为单位处理文件，awk比sed强的地方在于不仅能以行为单位还能以列为单位处理文件。awk缺省的行分隔符是换行，缺省的列分隔符是连续的空格和Tab，但是行分隔符和列分隔符都可以自定义，比如/etc/passwd文件的每一行有若干个字段，字段之间以:分隔，就可以重新定义awk的列分隔符为:并以列为单位处理这个文件。awk实际上是一门很复杂的脚本语言，还有像C语言一样的分支和循环结构，但是基本用法和sed类似。
命令格式
awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file
[-F|-f|-v] 大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=value
’ ’ 引用代码块
BEGIN 初始化代码块，在对每一行进行处理之前，初始化代码，主要是引用全局变量，设置FS分隔符
// 匹配代码块，可以是字符串或正则表达式
{} 命令代码块，包含一条或多条命令
； 多条命令使用分号分隔
END 结尾代码块，在对每一行进行处理之后再执行的代码块，主要是进行最终计算或输出结尾摘要信息
特殊要点
$0 表示整个当前行
$1 每行第一个字段
NF 字段数量变量
NR 每行的记录号，多文件记录递增
FNR 与NR类似，不过多文件记录不递增，每个文件都从1开始
t 制表符
n 换行符
FS BEGIN时定义分隔符
RS 输入的记录分隔符， 默认为换行符(即文本是按一行一行输入)
~ 匹配，与==相比不是精确比较
!~ 不匹配，不精确比较
== 等于，必须全部相等，精确比较
!= 不等于，精确比较
&& 逻辑与
|| 逻辑或
+ 匹配时表示1个或1个以上
/[0-9][0-9]+/ 两个或两个以上数字
/[0-9][0-9]*/ 一个或一个以上数字
FILENAME 文件名
OFS 输出字段分隔符， 默认也是空格，可以改为制表符等
ORS 输出的记录分隔符，默认为换行符,即处理结果也是一行一行输出到屏幕
-F’[:#/]’ 定义三个分隔符
实例
(1) print
print 是awk打印指定内容的主要命令
awk ‘{print}’ /etc/passwd 等价于 awk ‘{print $0}’ /etc/passwd
awk ‘{print " "}’ /etc/passwd //不输出passwd的内容，而是输出相同个数的空行
awk -F: ‘{print $1; print $2}’ /etc/passwd //将每一行的前二个字段，分行输出
awk -F: ‘{print $1,$3,$6; OFS=“t”}’ /etc/passwd //输出字段1,3,6，以制表符作为分隔符
(2) -f指定脚本文件
awk -f script.awk file
awk ‘BEGIN{X=0} /^$/{ X+=1 } END{print “I find”,X,“blank lines.”}’ test //空行数
I find 4 blank lines.
ls -l|awk ‘BEGIN{sum=0} !/^d/{sum+=$5} END{print “total size is”,sum}’ //计算文件数量
total size is 17487
(3) -F指定分隔符
$1 指指定分隔符后，第一个字段，$3第三个字段， t是制表符
一个或多个连续的空格或制表符看做一个定界符，即多个空格看做一个空格
awk -F":" ‘{print $1}’ /etc/passwd
awk -F":" ‘{print $1 $3}’ /etc/passwd //$1与$3相连输出，不分隔
awk -F":" ‘{print $1,$3}’ /etc/passwd //多了一个逗号，$1与$3使用空格分隔
awk -F":" ‘{print $1 " " $3}’ /etc/passwd //$1与$3之间手动添加空格分隔
awk -F":" ‘{print “Username:” $1 “tt Uid:” $3 }’ /etc/passwd //自定义输出
awk -F: ‘{print NF}’ /etc/passwd //显示每行有多少字段
awk -F: ‘{print $NF}’ /etc/passwd //将每行第NF个字段的值打印出来
awk -F: ‘NF==4 {print }’ /etc/passwd //显示只有4个字段的行
awk -F: ‘NF>2{print $0}’ /etc/passwd //显示每行字段数量大于2的行
awk ‘{print NR,KaTeX parse error: Expected 'EOF', got '}' at position 2: 0}̲' /etc/passwd /…NF,“t”,$0}’ /etc/passwd //依次打印行号，字段数，最后字段值，制表符，每行内容
awk -F: ‘NR==5{print}’ /etc/passwd //显示第5行
awk -F: ‘NR==5 || NR==6{print}’ /etc/passwd //显示第5行和第6行
route -n|awk ‘NR!=1{print}’ //不显示第一行
(4) //匹配代码块
//纯字符匹配 !//纯字符不匹配 ~//字段值匹配 !~//字段值不匹配 ~/a1|a2/字段值匹配a1或a2
awk ‘/mysql/’ /etc/passwd
awk ‘/mysql/{print }’ /etc/passwd
awk ‘/mysql/{print $0}’ /etc/passwd //三条指令结果一样
awk ‘!/mysql/{print $0}’ /etc/passwd //输出不匹配mysql的行
awk ‘/mysql|mail/{print}’ /etc/passwd
awk ‘!/mysql|mail/{print}’ /etc/passwd
awk -F: ‘/mail/,/mysql/{print}’ /etc/passwd //区间匹配
awk ‘/[2][7][7]*/{print $0}’ /etc/passwd //匹配包含27为数字开头的行，如27，277，2777…
awk -F: ‘$1~/mail/{print $1}’ /etc/passwd //$1匹配指定内容才显示
awk -F: ‘{if($1~/mail/) print $1}’ /etc/passwd //与上面相同
awk -F: ‘$1!~/mail/{print $1}’ /etc/passwd //不匹配
awk -F: ‘$1!~/mail|mysql/{print $1}’ /etc/passwd
(5) IF语句
必须用在{}中，且比较内容用()扩起来
awk -F: ‘{if($1~/mail/) print $1}’ /etc/passwd //简写
awk -F: ‘{if($1~/mail/) {print $1}}’ /etc/passwd //全写
awk -F: ‘{if($1~/mail/) {print $1} else {print $2}}’ /etc/passwd //if…else…
(6) 条件表达式 == != > >=
awk -F":" ‘$1==“mysql”{print $3}’ /etc/passwd
awk -F":" ‘{if($1==“mysql”) print $3}’ /etc/passwd //与上面相同
awk -F":" ‘$1!=“mysql”{print $3}’ /etc/passwd //不等于
awk -F":" ‘$3>1000{print $3}’ /etc/passwd //大于
awk -F":" ‘$3>=100{print $3}’ /etc/passwd //大于等于
awk -F":" ‘$3<1{print $3}’ /etc/passwd //小于
awk -F":" ‘$3<=1{print $3}’ /etc/passwd //小于等于
(7) 逻辑运算符 && ||
awk -F: ‘$1~/mail/ && $3>8 {print }’ /etc/passwd //逻辑与，$1匹配mail，并且$3>8
awk -F: ‘{if($1~/mail/ && $3>8) print }’ /etc/passwd
awk -F: ‘$1~/mail/ || $3>1000 {print }’ /etc/passwd //逻辑或
awk -F: ‘{if($1~/mail/ || $3>1000) print }’ /etc/passwd
(8) 数值运算
awk -F: ‘$3 > 100’ /etc/passwd
awk -F: ‘$3 > 100 || $3 < 5’ /etc/passwd
awk -F: ‘$3+$4 > 200’ /etc/passwd
awk -F: ‘/mysql|mail/{print $3+10}’ /etc/passwd //第三个字段加10打印
awk -F: ‘/mysql/{print $3-$4}’ /etc/passwd //减法
awk -F: ‘/mysql/{print $3*$4}’ /etc/passwd //求乘积
awk ‘/MemFree/{print $2/1024}’ /proc/meminfo //除法
awk ‘/MemFree/{print int($2/1024)}’ /proc/meminfo //取整
(9) 输出分隔符OFS
awk ‘$6 ~ /FIN/ || NR==1 {print NR,$4,$5,$6；OFS=“t”}’ netstat.txt
awk ‘$6 ~ /WAIT/ || NR==1 {print NR,$4,$5,$6；OFS=“t”}’ netstat.txt
//输出字段6匹配WAIT的行，其中输出每行行号，字段4，5,6，并使用制表符分割字段
(10) 输出处理结果到文件
①在命令代码块中直接输出 route -n|awk ‘NR!=1{print > “./fs”}’
②使用重定向进行输出 route -n|awk ‘NR!=1{print}’ > ./fs
(11) 格式化输出
netstat -anp|awk ‘{printf “%-8s %-8s %-10sn”,$1,$2,$3}’
printf表示格式输出
%格式化输出分隔符
-8长度为8个字符
s表示字符串类型
打印每行前三个字段，指定第一个字段输出字符串类型(长度为8)，第二个字段输出字符串类型(长度为8),第三个字段输出字符串类型(长度为10)
netstat -anp|awk ‘$6==“LISTEN” || NR==1 {printf “%-10s %-10s %-10s n”,$1,$2,$3}’
netstat -anp|awk ‘$6==“LISTEN” || NR==1 {printf “%-3s %-10s %-10s %-10s n”,NR,$1,$2,$3}’
(12) IF语句
awk -F: ‘{if($3>100) print “large”; else print “small”}’ /etc/passwd
small
small
small
large
small
small
awk -F: ‘BEGIN{A=0;B=0} {if($3>100) {A++; print “large”} else {B++; print “small”}} END{print A,“t”,B}’ /etc/passwd
//ID大于100,A加1，否则B加1
awk -F: ‘{if($3<100) next; else print}’ /etc/passwd //小于100跳过，否则显示
awk -F: ‘BEGIN{i=1} {if(i<NF) print NR,NF,i++ }’ /etc/passwd
awk -F: ‘BEGIN{i=1} {if(i<NF) {print NR,NF} i++ }’ /etc/passwd
另一种形式
awk -F: ‘{print ($3>100 ? “yes”:“no”)}’ /etc/passwd
awk -F: ‘{print ($3>100 ? $3":tyes":$3":tno")}’ /etc/passwd
(13) while语句
awk -F: ‘BEGIN{i=1} {while(i<NF) print NF,$i,i++}’ /etc/passwd
7 root 1
7 x 2
7 0 3
7 0 4
7 root 5
7 /root 6
(14) 数组
netstat -anp|awk ‘NR!=1{a[$6]++} END{for (i in a) print i,“t”,a[i]}’
netstat -anp|awk ‘NR!=1{a[$6]++} END{for (i in a) printf “%-20s %-10s %-5s n”, i,“t”,a[i]}’
9523 1
9929 1
LISTEN 6
7903 1
3038/cupsd 1
7913 1
10837 1
9833 1
(15) 应用1
awk -F: ‘{print NF}’ helloworld.sh //输出文件每行有多少字段
awk -F: ‘{print $1,$2,$3,$4,$5}’ helloworld.sh //输出前5个字段
awk -F: ‘{print $1,$2,$3,$4,$5}’ OFS=‘t’ helloworld.sh //输出前5个字段并使用制表符分隔输出
awk -F: ‘{print NR,$1,$2,$3,$4,$5}’ OFS=‘t’ helloworld.sh //制表符分隔输出前5个字段，并打印行号
(16) 应用2
awk -F’[:#]’ ‘{print NF}’ helloworld.sh //指定多个分隔符: #，输出每行多少字段
awk -F’[:#]’ ‘{print $1,$2,$3,$4,$5,$6,$7}’ OFS=‘t’ helloworld.sh //制表符分隔输出多字段
(17) 应用3
awk -F’[:#/]’ ‘{print NF}’ helloworld.sh //指定三个分隔符，并输出每行字段数
awk -F’[:#/]’ ‘{print $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12}’ helloworld.sh //制表符分隔输出多字段
(18) 应用4
计算/home目录下，普通文件的大小，使用KB作为单位
ls -l|awk ‘BEGIN{sum=0} !/^d/{sum+=$5} END{print “total size is:”,sum/1024,“KB”}’
ls -l|awk ‘BEGIN{sum=0} !/^d/{sum+=$5} END{print “total size is:”,int(sum/1024),“KB”}’ //int是取整的意思
(19) 应用5
统计netstat -anp 状态为LISTEN和CONNECT的连接数量分别是多少
netstat -anp|awk ‘$6~/LISTEN|CONNECTED/{sum[$6]++} END{for (i in sum) printf “%-10s %-6s %-3s n”, i," ",sum[i]}’
(20) 应用6
统计/home目录下不同用户的普通文件的总数是多少？
ls -l|awk ‘NR!=1 && !/^d/{sum[$3]++} END{for (i in sum) printf “%-6s %-5s %-3s n”,i," ",sum[i]}’
mysql 199
root 374
统计/home目录下不同用户的普通文件的大小总size是多少？
ls -l|awk ‘NR!=1 && !/^d/{sum[$3]+=$5} END{for (i in sum) printf “%-6s %-5s %-3s %-2s n”,i," ",sum[i]/1024/1024,“MB”}’
(21) 应用7
输出成绩表
awk ‘BEGIN{math=0;eng=0;com=0;printf “Lineno. Name No. Math English Computer Totaln”;printf “------------------------------------------------------------n”}{math+=$3; eng+=$4; com+=$5;printf “%-8s %-7s %-7s %-7s %-9s %-10s %-7s n”,NR,$1,$2,$3,$4,$5,$3+$4+$5} END{printf “------------------------------------------------------------n”;printf “%-24s %-7s %-9s %-20s n”,“Total:”,math,eng,com;printf “%-24s %-7s %-9s %-20s n”,“Avg:”,math/NR,eng/NR,com/NR}’ test0
[root@localhost home]# cat test0
Marry 2143 78 84 77
Jack 2321 66 78 45
Tom 2122 48 77 71
Mike 2537 87 97 95
Bob 2415 40 57 62
wc
更新时间：2016年06月05日 16:27:25 投稿：mdxy-dxy 脚本之家
wc是一个用于统计的工具，全拼为：Word Count(单词统计)。
用法：wc [选项]… [文件]… 或：wc [选项]… --files0-from=F
打印每行的换行符，单词，字节的数量，如果多于一个文件，则打印每个总行数。如果没有文件，或者文件位置用"-"表示，则读取标准流。 一个单词是由空白符分隔的非零长的字符序列。下面的操作可能用于选择某种类型数量的打印，通常顺序是 换行符，单词，字符，字节，最大行的长度。
-c, --bytes 打印字节数
-m, --chars 打印字符数
-l, --lines 打印换行符，即总行数
–files0-from=文件 从指定文件读取以NUL 终止的名称，如果该文件被指定为"-"则从标准输入读文件名
-L, --max-line-length 显示最长行的长度
-w, --words 显示单词计数
–help 显示此帮助信息并退出
–version 显示版本信息并退出
实例：
- 统计行数：$wc --l file
- 统计单词数：$wc --w file
- 统计字符数：$wc --c file
- 统计流中的字符数：$echo --n 1234 | wc --c 输出：4
- 多于一个文件：$wc file1 file2 打印两个文件的分别的统计行数
- 打印最长的行数的字符数，即长度：$wc --c file
- 直接wc 文件，无任何参数 顺序是 行数，单词，字符，字节，最大行长度
tee 定向输出到多个管道
Arlingtonroad 2019-09-24 23:38:09 703 收藏 2
在执行Linux命令时，我们可以把输出重定向到文件中，比如 ls >a.txt，这时我们就不能看到输出了。如果我们既想把输出保存到文件中，又想在屏幕上看到输出内容，就可以使用tee命令了。
tee命令读取标准输入，把这些内容同时输出到标准输出和（多个）文件中，tee命令可以重定向标准输出到多个文件。要注意的是：在使用管道线时，前一个命令的标准错误输出不会被tee读取。
tee指令会从标准输入设备读取数据，将其内容输出到标准输出设备，同时保存成文件。
语法
tee [-ai][–help][–version][文件…]
参数
-a或–append 附加到既有文件的后面，而非覆盖它．
-i或–ignore-interrupts 忽略中断信号。
–help 在线帮助。
–version 显示版本信息。
实例
(1) 使用指令"tee"将用户输入的数据同时保存到文件"file1"和"file2"中，输入如下命令：
$ tee file1 file2 #在两个文件中复制内容
以上命令执行后，将提示用户输入需要保存到文件的数据，如下所示：
My Linux #提示用户输入数据
My Linux #输出数据，进行输出反馈
此时，可以分别打开文件"file1"和"file2"，查看其内容是否均是"My Linux"即可判断指令"tee"是否执行成功。
(2) 监控串口并将串口收到数据存入file1并且控制台显示
cat /dev/ttyACM1 | tee file1 | tee &
格式：tee
只输出到标准输出，因为没有指定文件嘛。
格式：tee file
输出到标准输出的同时，保存到文件file中。如果文件不存在，则创建；如果已经存在，则覆盖之。
格式：tee -a file
输出到标准输出的同时，追加到文件file中。如果文件不存在，则创建；如果已经存在，就在末尾追加内容，而不是覆盖。
格式：tee -
输出到标准输出两次。
格式：tee file1 file2 -
输出到标准输出两次，同时保存到file1和file2中。
(3) 将脚本的执行结果（包括-x）输出到文件
./build.sh 2>&1 | tee err.txt
Linux中的0,1,2 /dev/null
小悟空爱吃桃 2018-05-19 14:58:44 29204 收藏 32
(1) 文件描述符
Linux系统预留可三个文件描述符：0、1和2，他们的意义如下所示：
0------标准输入（stdin）
1------标准输出（stdout）
2------标准错误（stderr）
(2) 可以将stderr单独定向到一个文件，stdout重定向到另一个文件
cmd 2> stderr.txt 1>stdout.txt
(3) 也可以将stderr和stdout重定向到同一个文件
cmd > output.txt 2>&1
或采用下面的方法，可以少写几个字，能达到同样的效果
cmd &> output.txt
cmd >& output.txt #两个表达式效果一样的
(4) Linux特殊文件
/dev/null是一个特殊的设备文件，这个文件接收到任何数据都会被丢弃。因此，null这个设备通常也被称为位桶（bit bucket）或黑洞。
所以，2>/dev/null的意思就是将标准错误stderr删掉。
C程序中使用正则
POSIX规定了正则表达式的C语言库函数，详见regex(3)。我们已经学习了很多C语言库函数的用法，读者应该具备自己看懂man手册的能力了。本章介绍了正则表达式在grep、sed、awk中的用法，学习要能够举一反三，请读者根据regex(3)自己总结正则表达式在C语言中的用法，写一些简单的程序，例如验证用户输入的IP地址或email地址格式是否正确。
C语言处理正则表达式常用的函数有regcomp()、regexec()、regfree()和regerror()，一般分为三个步骤，如下所示：
C语言中使用正则表达式一般分为三步：
编译正则表达式 regcomp()
匹配正则表达式 regexec()
释放正则表达式 regfree()
下边是对三个函数的详细解释
这个函数把指定的正则表达式pattern编译成一种特定的数据格式compiled，这样可以使匹配更有效。函数regexec 会使用这个数据在目标文本串中进行模式匹配。执行成功返回０。
int regcomp (regex_t *compiled, const char *pattern, int cflags)
regex_t 是一个结构体数据类型，用来存放编译后的正则表达式，它的成员re_nsub 用来存储正则表达式中的子正则表达式的个数，子正则表达式就是用圆括号包起来的部分表达式。
pattern 是指向我们写好的正则表达式的指针。
cflags 有如下4个值或者是它们或运算(|)后的值：
REG_EXTENDED 以功能更加强大的扩展正则表达式的方式进行匹配。
REG_ICASE 匹配字母时忽略大小写。
REG_NOSUB 不用存储匹配后的结果,只返回是否成功匹配。如果设置该标志位，那么在regexec将忽略nmatch和pmatch两个参数。
REG_NEWLINE 识别换行符，这样’$‘就可以从行尾开始匹配，’^'就可以从行的开头开始匹配。
当我们编译好正则表达式后，就可以用regexec 匹配我们的目标文本串了，如果在编译正则表达式的时候没有指定cflags的参数为REG_NEWLINE，则默认情况下是忽略换行符的，也就是把整个文本串当作一个字符串处理。
执行成功返回０。
regmatch_t 是一个结构体数据类型，在regex.h中定义：
typedef struct {
regoff_t rm_so;
regoff_t rm_eo;
} regmatch_t;
成员rm_so 存放匹配文本串在目标串中的开始位置，rm_eo 存放结束位置。通常我们以数组的形式定义一组这样的结构。因为往往我们的正则表达式中还包含子正则表达式。数组0单元存放主正则表达式位置，后边的单元依次存放子正则表达式位置。
int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr[], int eflags)
compiled 是已经用regcomp函数编译好的正则表达式。
string 是目标文本串。
nmatch 是regmatch_t结构体数组的长度。
matchptr regmatch_t类型的结构体数组，存放匹配文本串的位置信息。
eflags 有两个值:
REG_NOTBOL 让特殊字符^无作用
REG_NOTEOL 让特殊字符＄无作用
当我们使用完编译好的正则表达式后，或者要重新编译其他正则表达式的时候，我们可以用这个函数清空compiled指向的regex_t结构体的内容，请记住，如果是重新编译的话，一定要先清空regex_t结构体。
void regfree (regex_t *compiled)
当执行regcomp 或者regexec 产生错误的时候，就可以调用这个函数而返回一个包含错误信息的字符串。
size_t regerror (int errcode, regex_t *compiled, char *buffer, size_t length)
errcode 是由regcomp 和 regexec 函数返回的错误代号。
compiled 是已经用regcomp函数编译好的正则表达式，这个值可以为NULL。
buffer 指向用来存放错误信息的字符串的内存空间。
length 指明buffer的长度，如果这个错误信息的长度大于这个值，则regerror 函数会自动截断超出的字符串，但他仍然会返回完整的字符串的长度。所以我们可以用如下的方法先得到错误字符串的长度。
例如： size_t length = regerror (errcode, compiled, NULL, 0);
测试用例：
#include <sys/types.h>
#include <regex.h>
#include <stdio.h>int main(int argc, char ** argv)
{if (argc != 3) {printf("Usage: %s RegexString Textn", argv[0]);return 1;}const char * pregexstr = argv[1];const char * ptext = argv[2];regex_t oregex;int nerrcode = 0;char szerrmsg[1024] = {0};size_t unerrmsglen = 0;if ((nerrcode = regcomp(&oregex, pregexstr, REG_EXTENDED|REG_NOSUB)) == 0) {if ((nerrcode = regexec(&oregex, ptext, 0, NULL, 0)) == 0) {printf("%s matches %sn", ptext, pregexstr);regfree(&oregex);return 0;}}unerrmsglen = regerror(nerrcode, &oregex, szerrmsg, sizeof(szerrmsg));unerrmsglen = unerrmsglen < sizeof(szerrmsg) ? unerrmsglen : sizeof(szerrmsg) - 1;szerrmsg[unerrmsglen] = '0';printf("ErrMsg: %sn", szerrmsg);regfree(&oregex);return 1;
}
匹配网址：
./a.out “http://www…*.com” “http://www.taobao.com”
匹配邮箱：
./a.out “^[a-zA-Z0-9]+@[a-zA-Z0-9]+.[a-zA-Z0-9]+” “itcast123@itcast.com”
./a.out “w+([-+.]w+)@w+([-.]w+).w+([-.]w+)*” “itcast@qq.com”
注：w匹配一个字符，包含下划线
匹配固话号码：请同学们自己编写。
除了gnu提供的函数外，还常用PCRE处理正则，全称是Perl Compatible Regular Ex-pressions。从名字我们可以看出PCRE库是与Perl中正则表达式相兼容的一个正则表达式库。PCRE是免费开源的库，它是由C语言实现的，这里是它的官方主页：http://www.pcre.org/，感兴趣的朋友可以在这里了解更多的内容。 要得到PCRE库，可以从这里下载：http://sourceforge.net/projects/pcre/files/
PCRE++是一个对PCRE库的C++封装，它提供了更加方便、易用的C++接口。这里是它的官方主页：http://www.daemon.de/PCRE，感兴趣的朋友可以在这里了解更多的内容。 要得到PCRE++库，可以从这里下载：http://www.daemon.de/PcreDownload
外c++中常用 boost regex。
Shell脚本中调用另一个脚本
脚本之家
fork: 如果脚本有执行权限的话，path/to/foo.sh。如果没有，sh path/to/foo.sh。
exec: exec path/to/foo.sh
source: source path/to/foo.sh(或简写：. path/to/foo.sh)
fork
fork 是最普通的, 就是直接在脚本里面用 path/to/foo.sh 来调用 foo.sh 这个脚本，比如如果是 foo.sh 在当前目录下，就是 ./foo.sh。运行的时候 terminal 会新开一个子 Shell 执行脚本 foo.sh，子 Shell 执行的时候, 父 Shell 还在。子 Shell 执行完毕后返回父 Shell。 子 Shell 从父 Shell 继承环境变量，但是子 Shell 中的环境变量不会带回父 Shell。
exec
exec 与 fork 不同，不需要新开一个子 Shell 来执行被调用的脚本. 被调用的脚本与父脚本在同一个 Shell 内执行。但是使用 exec 调用一个新脚本以后, 父脚本中 exec 行之后的内容就不会再执行了。这是 exec 和 source 的区别.
source
与 fork 的区别是不新开一个子 Shell 来执行被调用的脚本，而是在同一个 Shell 中执行. 所以被调用的脚本中声明的变量和环境变量, 都可以在主脚本中进行获取和使用。
举例
第一个脚本，我们命名为 1.sh:
#!/usr/bin/env bashA=1
echo "before exec/source/fork: PID for 1.sh = $$"
export A
echo "In 1.sh: variable A=$A"
case $1 in--exec)echo -e "==> using exec...n"exec ./2.sh ;;--source)echo -e "==> using source...n". ./2.sh ;;*)echo -e "==> using fork by default...n"./2.sh ;;
esac
echo "after exec/source/fork: PID for 1.sh = $$"
echo -e "In 1.sh: variable A=$An"
第二个脚本，我们命名为 2.sh：
#!/usr/bin/env bashecho "PID for 2.sh = $$"
echo "In 2.sh get variable A=$A from 1.sh"
A=2
export A
echo -e "In 2.sh: variable A=$An"
注：这两个脚本中的参数 $$ 用于返回脚本的 PID , 也就是进程 ID。这个例子是想通过显示 PID 判断两个脚本是分开执行还是同一进程里执行，也就是是否有新开子 Shell。当执行完脚本 2.sh 后，脚本 1.sh 后面的内容是否还执行。
chmod +x 1.sh 2.sh 给两个脚本加上可执行权限后执行情况：
fork
fork 方式可以看出，两个脚本都执行了，运行顺序为1-2-1，从两者的PID值(1.sh PID=82266, 2.sh PID=82267)，可以看出，两个脚本是分成两个进程运行的。
exec
exec 方式运行的结果是，2.sh 执行完成后，不再回到 1.sh。运行顺序为 1-2。从pid值看，两者是在同一进程 PID=82287 中运行的。
source
source方式的结果是两者在同一进程里运行。该方式相当于把两个脚本先合并再运行。
shFlags简介
weixin_30367945 2016-03-27 11:28:00 212 收藏 1
https://github.com/yhlgo/yhlgo/blob/main/shflags
https://github.com/kward/shflags/wiki/Documentation12x
shaflags有助于在脚本中简单地处理命令行的参数。
如下例子
#!/bin/sh
# source shflags
. /path/to/shflags# define a 'name' command-line string flag
DEFINE_string 'name' 'world' 'name to say hello to' 'n'# parse the command-line
FLAGS "$@" || exit $?
eval set -- "${FLAGS_ARGV}"# say Hello!
echo "Hello, ${FLAGS_name}!"
下面逐行分析
# source shflags
. /path/to/shflags
这个是引入了shflags，这样后面才能用。
# define a ‘name’ command-line string flag
DEFINE_string ‘name’ ‘world’ ‘name to say hello to’ ‘n’
这个是定义了一个string类型的变量，名字是name，默认值是world，说明文字是name to say hello to 缩写是 n
它说明了以下两件事情
1 接受到命令行选项 -n （或者–name）的时候，将随后的参数当成一个字符串，存入变量 name 中
2 接收到命令行选项 -h (或者 --help)的时候，显示"name to say hello to"
# parse the command-line
FLAGS “$@” || exit $?
eval set – “${FLAGS_ARGV}”
前半句FLAGS “$@” 将所有命令行参数送到shFlags库中进行处理，如果都成功，返回0（${FLAGS_TRUE}）。如果返回的是1(${FLAGS_FALSE}) 或 2 (${FLAGS_ERROR})，那就执行exit $? 返回 $?
如果有shFlags不识别的命令行参数，就会被更新到现在的 $@ 变量中，可以被任何其他脚本处理。
也就是，调用脚本的时候，参数会先被shFlags处理一波，把它识别的处理完后，还会把不识别的参数放回去给别人用。
# say Hello!
echo “Hello, ${FLAGS_name}!”
这里就是输出了，使用了变量name,也就是FLAGS_name的值。
所以执行结果会是
$ ./hello_world.sh
Hello, world!
$ ./hello_world.sh -n Kate
Hello, Kate!
$ ./hello_world.sh --name ‘Kate Ward’
Hello, Kate Ward!
$ ./hello_world.sh -h
USAGE: ./hello_world.sh [flags] args
flags:
-h show this help
-n name to say hello to
关于类型可以是以下几种
boolean 布尔
可使用${FLAGS_TRUE} 和${FLAGS_FALSE}
注意在shell中true是0 false是1
float 浮点
在shell中是字符串，所以在比较的时候要按字符串的规则来
也就是使用 = 和 != 而不是使用 eq, ge, gt, le, lt, ne
integer 整型
shell支持整型所以应该使用 (eq, ge, gt, …)
string 字符串
那就是字符串
可以定义 FLAGS_HELP 提供自己的help
不然就会使用默认的help模板
常用 boost regex。
Linux之shell编程相关推荐
- shell for循环1到100_浅谈Linux下shell 编程的for循环常用的6种结构
浅谈Linux下shell 编程的for循环常用的6种结构 1. 常用for循环结构 (1) for 变量 in 值1 值2 值3... do 程序块儿 done (2) for 变量 in `命令` ...
- linux中快捷脚本,Linux下Shell编程快捷键大全(日常整理)
有时候,我们需要在 Bash 中重复执行先前的命令.你当然可以使用上方向键来查看之前曾经运行过的命令.但这里有一些更好的方式,例如,数量掌握以下的快捷键. 1) !!:重复执行上一条指令 2) !a: ...
- Linux _ Shell编程 — 循环语句
Linux _ Shell编程 - 循环语句 一.循环语句for的用法 二.循环语句while的用法 三.循环控制语句 一.循环语句for的用法 for 变量名 in 单词表do命令表done 变量依 ...
- 运维 - 第一阶段 - linux与shell编程
linux与shell编程 讲师:墨竹 系统运维与linux 1.系统运维是什么 简单来说运维(Operation and maintenance)是指对公司硬件和软件的维护. 硬件包括:机房.机柜. ...
- linux系统——Shell编程之变量解释
linux系统--Shell编程之变量解释 - Shell能做什么 自动化批量系统初始化程序 (update,软件安装,时区设置,安全策略-) 自动化批量软件部署程序 (LAMP,LNMP,Tomca ...
- Linux _ Shell编程 — 功能语句
Linux _ Shell编程 - 功能语句 一.说明性语句 二.常用功能性语句 1.常用功能性语句(read命令) 2.expr命令 三.结构性语句 条件测试语句 字符串测试 整数测试 文件的测试 ...
- Linux之shell编程篇-----Shell 函数和Shell 输入/输出重定向
最近发现了一个挺厉害的人工智能学习网站,内容通俗易懂,风趣幽默,感兴趣的可以点击此链接进行查看:床长人工智能教程 废话不多说,请看正文! Shell 函数 1. 自定义函数 linux she ...
- Linux学习——shell编程之变量
shell编程之变量:Linux shell编程基础中的变量. 包括Bash变量的分类和各变量的详细使用,如:用户自定义变量.环境变量.语系变量.位置参数变量和预定义变量. 1:什么是Bash变量? ...
- linux之shell编程基本语法
Shell是用户与内核进行交互操作的一种接口,目前最流行的Shell称为bash Shell.Shell也是一门编程语言<解释型的编程语言>,即shell脚本<就是在用linux的s ...
- Linux 下shell编程
什么是shell?Shell是一个命令解析器,是介于Linux操作系统的内核(kernel)与用户之间的一个绝缘层.shell脚本就是讲各类命令预先放入其中,方便一次性执行的一个程序文件,主要用于方便 ...
最新文章
- PostgreSQL 11 100亿 tpcb 性能测试 on ECS
- Leetcode 144. 二叉树的前序遍历 解题思路及C++实现
- 计算机视觉工具包Luminoth
- 奇迹暖暖登录一直显示服务器满,奇迹暖暖无法登录解决办法
- JavaSE(一)——HelloWorld
- Node工程-构建优秀的Session机制
- NTP时间服务器介绍
- VMware Workstation Player与VMware Workstation Pro的区别
- SQL Server表和字段说明的增加和更新
- mlock - 将页面锁入内存
- MySQL数据库入门学习
- t580 thinkpad_ThinkPad T580性能如何？联想ThinkPad T580商务本详细评测
- IC卡读卡器在安卓(android)下的开发
- 迅雷不及掩耳 山寨版iPhone 5令人瞠目
- python 处理英文步骤
- Android编程制作漫画,画出自己的漫画 Android漫画风制作所
- 钉钉企业邮箱smtp服务器
- 右键快捷菜单压缩文件的消失问题解决办法！
- linux6.6卸载防火墙,Linux-centos6.8下关闭防火墙
- 中国园区经济行业“十四五“规划与前景深度研究报告2021年版