简结的Bash Programming技巧
1. 检查命令执行是否成功
echo abcdee | grep -q abcd
if [ $? -eq 0 ]; then
echo "Found"
else
echo "Not found"
fi
if echo abcdee | grep -q abc; then
echo "Found"
else
echo "Not found"
fi
echo abcdee | grep -q abc && echo "Found" || echo "Not found"Found
2. 将标准输出与标准错误输出重定向到/dev/null
第一种写法，比较常见：
grep "abc" test.txt 1>/dev/null 2>&1
常见的错误写法：
grep "abc" test.txt 2>&1 1>/dev/null
简洁的写法：
grep "abc" test.txt &> /dev/null
3. awk的使用
举一个实际的例子，获取Xen DomU的id。
sudo xm li | grep vm_name | awk '{print $2}'
sudo xm li | awk '/vm_name/{print $2}'
4. 将一个文本的所有行用逗号连接起来
$ cat /tmp/test.txt
1
2
3
$ sed ':a;$!N;s/\n/,/;ta' /tmp/test.txt
1,2,3
简洁的写法：
$ paste -sd, /tmp/test.txt
1,2,3
5. 过滤重复行
假设文件内容如下所示：
$ sort /tmp/test.txt
1
1
2
3
常用的方法：
$ sort /tmp/test.txt | uniq
1
2
3
简单的写法：
$ sort /tmp/test.txt -u
1
2
3
6. grep查找单词
$ cat /tmp/ip.list
10.0.0.1
10.0.0.12
10.0.0.123
$ grep '10.0.0.1\>' /tmp/ip.list
10.0.0.1
$ grep -w '10.0.0.1' /tmp/ip.list
10.0.0.1
7. 临时设置环境变量
常见的写法：
$ export LC_ALL=zh_CN.UTF-8
$ date
2012年 11月 03日 星期六 22:26:55 CST
简洁的写法:
$ unset LC_ALL
$ LC_ALL=zh_CN.UTF-8 date
2012年 11月 03日 星期六 22:27:43 CST
在命令之前加上环境变更的设置，只是临时改变当前执行命令的环境。
8. $1,$2...等位置参数的使用
假设只想使用$2,$3..这几个参数，常见的做法是:
当使用shift命令之后，原来的$2会变成$1
shift
echo "$@"
为什么不这样写呢？
echo "${@:2}"
9. 参数默认值
相信大家会有这种需求，当一个参数值没有提供时，可以使用默认值。常见的写法是：
arg=$1
if [ -z "$arg" ]; then
arg=0
fi
简洁的写法是这样的:
arg=${1:-0}
10. bash特殊参数--的用法
假设要用grep查找字符串中是否包含-i，我们会这样尝试：
[Sat Nov 03 10:45 PM] [kodango@devops] ~/workspace
$ echo 'abc-i' | grep "-i"
Usage: grep [OPTION]... PATTERN [FILE]...
Try 'grep --help' for more information.
[Sat Nov 03 10:45 PM] [kodango@devops] ~/workspace
$ echo 'abc-i' | grep "\-i"
abc-i
简洁的方法是：
[Sat Nov 03 10:45 PM] [kodango@devops] ~/workspace
$ echo 'abc-i' | grep -- -i
abc-i
bash中--后面的参数不会被当作选项解析。
11. 函数的返回值默认是最后一行语句的返回值
# Check whether an item is a function
# $1: the function name
# Return: 0(yes) or 1(no)
function is_function()
{
local func_name=$1
test "`type -t $1 2>/dev/null`" = "function"
}
不要画蛇添足再在后面加一行return $?了。
12. 将printf格式化的结果赋值给变量
例如将数字转换成其十六进制形式，常见的写法是：
[Sat Nov 03 10:55 PM] [kodango@devops] ~/workspace
$ var=$(printf '%%%02x' 111)
简单的写法是：
[Sat Nov 03 10:54 PM] [kodango@devops] ~/workspace
$ printf -v var '%%%02x' 111
看看printf的help：
[Sat Nov 03 10:53 PM] [kodango@devops] ~/workspace
$ help printf | grep -A 1 -B 1 -- -v
printf: printf [-v var] format [arguments]
Formats and prints ARGUMENTS under control of the FORMAT.
--
Options:
-v var assign the output to shell variable VAR rather than
display it on the standard output
13. 打印文件行
打印文件的第一行：
head -1 test.txt
打印文件的第2行：
sed -n '2p' test.txt
打印文件的第2到5行：
sed -n '2,5p' test.txt
打印文件的第2行始（包括第2行在内）5行的内容：
sed -n '2,+4p' test.txt
打印倒数第二行：
$ tail -2 test.txt | head -1
$ tac test.txt | sed -n '2p'
14.善用let或者(())命令做算术运算
如何对一个数字做++运算，可能你会这样用：
a=1
a=`expr a + 1`
为何不用你熟悉的:
a=1
let a++
let a+=2
15. 获取软连接指定的真实文件名
如果你不知道，你可能会这样获取：
[Sat Nov 03 11:12 PM] [kodango@devops] ~/workspace
$ ls -l /usr/bin/python | awk -F'->' '{print $2}' | tr -d ' '
/usr/bin/python2
如果你知道有一个叫readlink的命令，那么：
[Sat Nov 03 11:13 PM] [kodango@devops] ~/workspace
$ readlink /usr/bin/python
/usr/bin/python2
16. 获取一个字符的ASCII码
[Sat Nov 03 11:14 PM] [kodango@devops] ~/workspace
$ printf '%02x' "'+"
2b
[Sat Nov 03 11:30 PM] [kodango@devops] ~/workspace
$ echo -n '+' | od -tx1 -An | tr -d ' '
2b
17. 清空一个文件
常见的用法:
echo "" > test.txt
简单的写法：
> test.txt
18 不要忘记有here document
下面一段代码：
grep -v 1 /tmp/test.txt | while read line; do
let a++
echo --$line--
done
echo a:$a
执行后有什么问题吗？
[Sun Nov 04 05:35 AM] [kodango@devops] ~/workspace
$ sh test.sh
--2--
--3--
a:
发现a这个变量没有被赋值，为什么呢？因为管道后面的代码是在在一个子shell中执行的，所做的任何更改都不会对当前shell有影响，自然a这个变量就不会有赋值了。
换一种思路，可以这样做：
grep -v 1 /tmp/test.txt > /tmp/test.tmp
while read line; do
let a++
echo --$line--
done < /tmp/test.tmp
echo a:$a
rm -f /tmp/test.tmp
不过多了一个临时文件，最后还要删除。这里其实可以用到here document：
while read line2; do
let b++
echo ??$line2??
done << EOF
`grep -v 1 /tmp/test.txt`
EOF
echo b: $b
here document往往用于需要输出一大段文本的地方，例如脚本的help函数。
19.删除字符串中的第一个或者最后一个字符
假设字符串为：
[Sun Nov 04 10:21 AM] [kodango@devops] ~/workspace
$ str="aremoveb"
可能你第一个想法是通过sed或者其它命令来完成这个功能，但是其实有很简单的方法：
[Sun Nov 04 10:24 AM] [kodango@devops] ~/workspace
$ echo "${str#?}"
removeb
[Sun Nov 04 10:24 AM] [kodango@devops] ~/workspace
$ echo "${str%?}"
aremove
类似地，你也可以删除2个、3个、4个……
有没有一次性删除第一个和最后一个字符的方法呢？答案当然是肯定的：
[Sun Nov 04 10:26 AM] [kodango@devops] ~/workspace
$ echo "${str:1:-1}"
remove
关于这些变量替换的内容在bash的man手册中都有说明。
20. 使用逗号join数组元素
假设数组元素没有空格，可以用这种方法：
[Sun Nov 04 10:14 AM] [kodango@devops] ~/workspace
$ a=(1 2 3)
$ b="${a[*]}"
[Sun Nov 04 10:15 AM] [kodango@devops] ~/workspace
$ echo ${b// /,}
1,2,3
注意：当该数组的长度非常长时，使用这种替换的时间开销很高，性能很差，推荐用sed。
假设数组元素包含有空格，可以借用printf命令来达到：
[Sun Nov 04 10:15 AM] [kodango@devops] ~/workspace
$ a=(1 "2 3" 4)
[Sun Nov 04 10:15 AM] [kodango@devops] ~/workspace
$ printf ",%s" "${a[@]}" | cut -c2-
1,2 3,4
21. Shell中的多进程
在命令行下，我们会在命令行后面加上&符号来让该命令在后台执行，在shell脚本中，使用"(cmd)"可以让fork一个子shell来执行该命令。利用这两点，可以实现shell的多线程：
job_num=10
function do_work()
{
echo "Do work.."
}
for ((i=0; i < job_num ;i++)); do
echo "Fork job $i"
(do_work) &
done
wait # wait for all job done
echo "All job have been done!"
注意最后的wait命令，作用是等待所有子进程结束。
附几则小技巧：
1）sudo iptables -L -n | vim -
2）grep -v xxx | vim -
3）echo $'\''
4）set -- 1 2 3; echo "$@"
5）搜索stackoverflow/superuser等站点
6）VIM编辑远程文件 vim scp://xxx//etc/vimrc
7）远程执行脚本 ssh xxx bash < xxx.sh
22. bash中alias的使用
alias其实是给常用的命令定一个别名，比如：
alias ll='ls -l'
以后就可以使用ll，实际展开后执行的是ls -l。现在很多发行版都会带几个默认的别名，比如：
alias grep='grep --color=auto' # 带颜色显示
alias ls='ls --color=auto' # 同上
alias rm='rm -i' # 删除文件需要确认
alias在某些方面确实提高了很大的效率，但是也是有隐患的，不使用alias，可以使用转义：
\ls
\grep
在命令前面加一个反斜杠后就可以了。
这里要插一段故事，前两天我在shell脚本中定义了下面的一个alias，假设位于文件util.sh：
#!/bin/bash
...
alias ssh='ssh -o StrictHostKeyChecking=no -o LogLevel=quiet -o BatchMode=yes'
...
后面这串ssh选项是为了去掉一些warning的信息，不提示输入密码等等。具体可以看ssh的文档说明。我自己测试的时候好好的，当时我同事跑得时候却依然有报Warning。我对比了下我们两个人的用法：
sh util.sh # 我的
./util.sh # 他的
大家应该知道，直接./util.sh执行，shell会去找脚本第一行的shebang中给定的解释器去执行改脚本，所以第二种用法相当于直接用bash来执行。那想必是bash/sh对alias是否默认展开这一点上是有区别的了。翻阅了下Bash的man手册，发现可以通过设置expand_aliases选项来打开alias展开的功能，而默认在非交互式Shell下是关闭的。
修改下util.sh，打开这个选项就Ok了：
#!/bin/bash
...
# Expand aliases in script
shopt -s expand_aliases
alias ssh='ssh -o StrictHostKeyChecking=no -o LogLevel=quiet -o BatchMode=yes'
...
23. awk打印除第一列之外的其他列
例如有如下的一个文件：
$ cat /tmp/test.txt
1 2 3 4 5
10 20 30 40 50
可以用下面的代码解决：
$ awk '{$1="";print $0}' /tmp/test.txt
2 3 4 5
20 30 40 50
但是前面多了一个空格，可以用cut命令稍微调整下：
$ awk '{$1="";print $0}' /tmp/test.txt | cut -c2-
2 3 4 5
20 30 40 50
24. 巧用bash的命令展开功能备份文件
假设要备份文件/your/path/to/file.list为/your/path/to/file.list.20121106，常规的方法是：
cp /your/path/to/file.list /your/path/to/file.list.20121106
这样重复写上一长串的路径，是不是很麻烦，这里利用bash的展开特性可以这样做：
cp /your/path/to/file.list{,.20121106}
/your/path/to/file.list{,.20121106}这一部分会展开为/your/path/to/file.list /your/path/to/file.list.20121106,再将此传给cp命令，就达到了与前面同样的效果。（思路同ls *）。
25. 命令行下使用ctrl+x ctrl+e来编辑当前
键入命令之后，再按ctrl+x ctrl+e可以打开一个编辑器来编辑命令，默认是使用emacs。你也可以通过在~/.bashrc中添加以下这一行，将编辑器换成vim:
export EDITOR='vim'
为什么推荐这一条呢？对于一般的命令（这里指的是长度很短的命令）其实这个技巧没什么用处，我用方向键移一下就OK了，但是有时候（尤其是运维的一些命令）有些命令长度特别长，一堆参数，如果直接在命令行修改其实风险很高的（可以通过在命令的开头加上一个#号来规避这个风险，Bash将当前的命令当成注释不执行），而且方向键一个一个迁移非常不方便（当然有类似ctrl+x ctrl+e这种预设的快捷键来操作，可以看bind -p)。
像使用ctrl+x,ctrl+e打开vim来编辑命令在这种场景有两种好处：
a. 可以方便的用熟悉的编辑器高效地修改命令；
b. 有一个确认的过程，无误后，退出vim才执行命令。
26. 你知道sed的这个特性吗？
假设一个文件的每一行为一个路径：
[Tue Nov 06 06:33 PM] [kodango@devops] ~
$ cat /tmp/test.txt
/home/kodango/hello
/home/kodango/hello/world
/home/kodango/good
/home/kodango/good/bye
现在要把/home/kodango/good替换成/home/kodango/bad，普通的作法是：
[Tue Nov 06 06:35 PM] [kodango@devops] ~
$ sed -n 's/\/home\/kodango\/good/\/home\/kodango\/bye/p' /tmp/test.txt
/home/kodango/bye
/home/kodango/bye/bye
因为路径中的分隔符与sed的替换命令的分隔符都是'/'，所以需要转义，非常麻烦。幸运的是，sed可以更改分隔符，例如使用#：
[Tue Nov 06 06:34 PM] [kodango@devops] ~
$ sed -n 's#/home/kodango/good#/home/kodango/bad#p' /tmp/test.txt
/home/kodango/bad
/home/kodango/bad/bye
如果是在地址对中使用，首个分隔符前面要加反斜杠：
$ sed -n '\#/home/kodango/#p' /tmp/test.txt
/home/kodango/hello
/home/kodango/hello/world
/home/kodango/good
/home/kodango/good/bye
27. 合并连续重复的字符（即squeeze操作）
例如要合并一个字符串中连续的多个空格，假设字符串为'print hello, world'。
第一种方法，使用sed命令，扫描整个字符串，替换2个以上的空格为1格：
$ echo 'print hello, world ' | sed -r 's/ {2,}/ /g'
print hello, world
第二种方法，使用tr命令的-s选项，专门就是为了合并连续重复的字符：
$ echo 'print hello, world ' | tr -s ' '
print hello, world
第三种方法，使用awk的域赋值来完成该目的：
$ echo 'print hello, world ' | awk '$1=$1'
print hello, world
对已经存在的域例如$1,$2..进行赋值，会导致awk重新使用OFS输出分隔符重组$0
28. 将文本中某列相同的行输出到不同的文件中
标题有点绕口，我们以实际例子来讲解，假设我们有以下的一个文件：
$ cat /tmp/test.txt
a char
1 int
2 int
b char
abc string
我们的目标是将该文本中的行按第二列的值归类，并且输出到相应的文件中，文件名为第二列的名称。例如第2行、第3行会输出到int.txt文件中，而第1行、第4行则输出到char.txt，以此类推。
[Wed Nov 07 07:31 PM] [kodango@devops] ~/workspace
$ awk '{print $1 > $2 ".txt"}' /tmp/test.txt
我们来检查结果：
[Wed Nov 07 07:34 PM] [kodango@devops] ~/workspace/output
$ grep -nH . *
char.txt:1:a
char.txt:2:b
int.txt:1:1
int.txt:2:2
string.txt:1:abc
29. 用exec命令来完成重定向
以一个简单的例子开始，现在需要一个脚本，它可以接受一个文件名作为参数，然后按行读取该文件的内容并打印到标准输出。如果不指定文件名，则默认从标准输入读。首先按上面的功能需求写出一个可以完成功能的脚本：
[Sat Nov 10 12:16 AM] [kodango@devops] ~/workspace
$ cat test.sh
filename=$1
if [ -z "$filename" ]; then
while read line; do
echo $line
done
else
while read line; do
echo $line
done < $filename
fi
如果换exec来实现重定向，可以把脚本写得更优雅：
$ cat test1.sh
filename=$1
if [ -n "$filename" ]; then
exec 0< $filename
fi
while read line; do
echo $line
done
这里的关键在第5行代码，exec命令不仅可以用于执行命令，还可以用于打开、关闭或者复制文件描述符，这里就是利用exec将指定的文件名打开重定向到标准输入。类似地可以用exec >$filename将文件重定向到标准输出。我们可以在命令行上做一个试验：
[Sat Nov 10 12:26 AM] [kodango@devops] ~
$ exec 3>&1 # 首先将fd 3重定向到标准输出，作为标准输出的一个备份
$ ls /proc/629/fd/{1,3} -l # 现在fd 3和fd 1指向同一个设备文件
lrwx------ 1 kodango kodango 64 Nov 10 00:26 /proc/629/fd/1 -> /dev/pts/1
lrwx------ 1 kodango kodango 64 Nov 10 00:26 /proc/629/fd/3 -> /dev/pts/1
$ exec >stdout # 现在把标准输出重定向到stdout这个文件中
$ ls /proc/629/fd/1 -l # 如果你此刻在同一个终端下执行本命令是没有返回的
$ ls /proc/629/fd/1 -l # 现在重新打开一个终端看看，确实已经重定向到stdout这个文件
l-wx------ 1 kodango kodango 64 Nov 10 00:26 /proc/629/fd/1 -> /home/kodango/stdout
$ exec 1>&3 # 现在重新把标准输出重定向到之前备份的fd 3上
$ ls /proc/629/fd/{1,3} -l # 现在屏幕可以看到输出了，但是fd 3这个描述符还打开，需要关闭
lrwx------ 1 kodango kodango 64 Nov 10 00:26 /proc/629/fd/1 -> /dev/pts/1
lrwx------ 1 kodango kodango 64 Nov 10 00:26 /proc/629/fd/3 -> /dev/pts/1
$ exec 3>&- # 关闭fd 3
$ ls /proc/629/fd/3 -l
ls: cannot access /proc/629/fd/3: No such file or directory
$ cat stdout # 检查stdout文件，确实有之前被吃掉的输出
l-wx------ 1 kodango kodango 64 Nov 10 00:26 /proc/629/fd/1 -> /home/kodango/stdout
关于I/O重定向的更详细的说明，可以看I/O Redirection，这里有很多例子讲解了各种I/O重定向的用法，包括exec来改变重定向。
这一点在while read; do xxx; done < file内部仍需要从标准输入读取内容时非常有用，此时必须要将循环外部的重定向和内部的剥离开来。
30. 引号之间的区别
Shell中比较让人抓狂的是各种引号的处理，其中，反引号(cmd)是最容易掌握的，它其实和$(cmd)是差不多的。
引号的作用有几点，一个是为了将多个因为空格或者回车等分隔符隔开的字符串合在一起，避免被命令行解析分开，例如"one two three"就是一整个字符串，而不是像one two three会被解析成三个单独的字符串；另外一方面，引号可以让一些特殊符号保持原义。
其中，单引号的处理是比较简单的，被单引号包括的所有字符都保留原有的意思，例如'\(a'不会被展开, '`cmd`'也不会执行命令；而双引号，则相对比较松，在双引号中，以下几个字符\), , \依然有其特殊的含义，比如$可以用于变量展开, 反引号可以执行命令，反斜杠\可以用于转义。但是，在双引号包围的字符串里，反斜杠的转义也是有限的，它只能转义$, `, ", \或者newline（回车）这几个字符，后面如果跟着的不是这几个字符，只不会被黑底，反斜杠会被保留，例如：
$ echo "\$,\",\`,\',\t"
$,",`,\',\t
双引号内可以直接包含单引号，而且单引号也没有如上据说的特殊含义，所以像"var='\(var'"中\)var还是会被展开的，而不要以为简单地认为在单引号内部就不会展开了。如果双引号内部包含感叹号！就比较头痛了，感叹号是用于命令行历史展开，例如!!展开为上一次执行的命令。你可以试试双引号中包含!：
[Sat Nov 10 07:39 PM] [kodango@devops] ~
$ echo "!"
-bash: !: event not found
$ echo "\!"
\!
可见，即使你用反斜杠也没办法转义，除非你把历史展开功能关闭（在脚本里面是没有问题的，默认是关闭的）。
[Sat Nov 10 07:50 PM] [kodango@devops] ~
$ set +o histexpand
[Sat Nov 10 07:50 PM] [kodango@devops] ~
$ echo "!"
!
当然，感叹号可以用在单引号里面。
[Sat Nov 10 07:50 PM] [kodango@devops] ~
$ set -o histexpand
[Sat Nov 10 07:51 PM] [kodango@devops] ~
$ echo '!'
!
到此为止，其实双引号和单引号的区别已经说得差不多了。不过还可以再说几个特殊的用法，前面说过可以在双引号内部使用单引号，你有想过在单引号里面使用单引号吗？
$ echo '\''
>
是不是发现不能用，因为单引号中反斜杠是没有转义的效果的，任何字符都没有特殊的含义。那就没有办法了吗？方法总是有的，可以在第一个单引号前面加个$符号：
$ echo $'\''
'
这又是另外一种神奇的用法了，我放到下一点讲。
关于这一点的内容，具体可以看以下两份资料：
a. http://www.gnu.org/software/bash/manual/html_node/Quoting.html#Quoting
b. http://tldp.org/LDP/abs/html/quoting.html
31. 特殊用法$'string'
前面一点中已经介绍了 $'string'这种用法，比如 $'''，之所以可以这样用，通俗地讲，就是在这种语法里一些转义字符串是被认可的，事实上有效地的转义底字符串列表可以看这里，例如\b，',\n,\f,\nnn,\xhh等等，是不是很熟悉。
$'string'的这个特性，其实为我们提供了一种很有用的技巧：
$ echo $'\x41'
A
他可以将ASCII对应的字符赋值给某个变量或者输出。
32. 用双引号比不用更加安全
双引号除了前面第10点讲到的去除特殊涵义的作用外，还可以避免字符串被分隔解析，例如：
$ echo `ls -l`
total 4.0K -rw-r--r-- 1 kodango kodango 4 Nov 10 20:09 1 -rw-r--r-- 1 kodango kodango 0 Nov 10 20:09 2
$ echo "`ls -l`"
total 4.0K
-rw-r--r-- 1 kodango kodango 4 Nov 10 20:09 1
-rw-r--r-- 1 kodango kodango 0 Nov 10 20:09 2
前者没有加双引号，ls -l输出行之间的回车就被吃掉了。原因是，当ls -l返回的结果传递给echo之前，会先被shell进行参数解析，而shell是用IFS定义的分隔符来分隔字符串的，一般包括\n，所以它把解析后的结果再传递给echo，就成为echo "line 1...." "line 2..."这种形式了，结果就像上面一样。
而用双引号包括起来可以避开字符串被拆开解析，因为shell认为它是一个单独的字符串。所以一般情况下，多用引号包括变量是好的，"\(var"比\)var更安全。
33. 显示一个文件并且在每行开头添加行号
有两种做法，第一种借助cat和nl命令来完成：
$ cat test.txt | nl
1 line 1
2 line 2
另外一种做法是用sed命令:
$ sed '=' test.txt | sed 'N;s/\n/\t/'
还有一种方法是通过cat -n或者cat -b命令，两者的区别是后者不会给空行增加行号。
34. 命令行键映射，编辑模式
命令行下默认是emacs的keymap，对于不会emacs的人来说真是灾难，完全不知道各种ctrl+x键是做什么的，可以通过执行以下命令切换到vi模式：
set -o vi
在这种模式下，就可以用熟悉的vi命令了，默认输入命令的是在insert模式，按ESC键可以切换到命令模式，这点和vim是一样的，熟悉vim的人很快就可以上手。
之前介绍过命令行下使用ctrl+x ctrl+e来编辑当前命令，而在vi模式下，可以在命令模式下直接键入v。还有，如果不想执行当前输入的命令，可以在命令模式下按#号键，它会在当前命令当作注释而不执行（在命令开头添加#号）。
如果你想将vi模式作为默认的编辑模式，可以将set -o vi写入到~/.bashrc文件中。当然，在运维的线上生产环境这样做是不合适的，你只能手动输入切换了。不过，如果你选择的ssh管理客户端比较高级的话，应该可以避免每次手动输出。比如我用的是xshell，可以通过设置Login script在每次登录的时候自动执行命令，或者将命令添加到quick command set，然后调出quick command set toolbar，手动点击按钮切换。这两种方法结合起来就几乎同写入到~/.bashrc一样的方便了。
35. 分别输出两个文件相同的行和不同的行
假设我们有以下两个文件：
$ echo test{,2}.txt;paste test{,2}.txt
test.txt test2.txt
line 1 line 11
line 2 line 2
如果要输出两个文件之间相同的行，只有test.txt拥有的行以及只有test2.txt拥有的行，怎么做？首先可以使用grep -f：
$ grep -f test{,2}.txt
line 2
$ grep -vf test{,2}.txt
line 11
$ grep -vf test{2,}.txt
line 1
还有一种选择是comm命令，这个命令就是专门用于比较文件的： comm - compare two sorted files line by line。
使用方法也很简单，comm比较两个排序好的文件返回的结果有三列，第一列是只有在文件A中有的行，第二列是只有在文件B中有的行，第三列则是两个文件共有的行：
$ comm test.txt test2.txt
line 1
line 11
line 2
要得到最初要求的结果，则只需要取相应的列就可以了。comm命令非常人性化地考虑到这个需求：
$ comm test.txt test2.txt -1 -2
line 2
$ comm test.txt test2.txt -2 -3
line 1
$ comm test.txt test2.txt -1 -3
line 11
其中，-1, -2与-3这个参数分别表示不输出第1、2或者3列。
36. 获取被source的脚本的名称
一般的情况下，脚本的名称可以通过$0获取，但是这在被source导入的脚本中却不成立。假设A脚本中source了B脚本，那么它是把B的代码导入到A的环境中直接执行的，因此A和B的代码其实是在同一个执行环境下分不开的，B的代码中访问到的$0，甚至$1, $2等位置参数都是与A脚本是一致的。
因此$0并非是被导入的脚本的名称，实际上，Bash将被source的脚本名称保存在一个叫BASH_SOURCE的数组中，该数组的第一个元素正是当前被source的脚本的名称。该变量与我在bash获取当前函数名中介绍的FUNCNAME是类似的，当一个脚本被source时，它的名称就被压入到这个数组的第一个位置上，举个实际的例子，假设有三个脚本a.sh,b.sh,c.sh，它们的内容如下所示：
$ cat a.sh
. ./b.sh
echo "\$0=$0"
echo "\${BASH_SOURCE[0]}=${BASH_SOURCE[0]}"
echo "\$BASH_SOURCE=(${BASH_SOURCE[@]})"
$ cat b.sh
. ./c.sh
. ./c.sh
echo "\$0=$0"
echo "\${BASH_SOURCE[0]}=${BASH_SOURCE[0]}"
echo "\$BASH_SOURCE=(${BASH_SOURCE[@]})"
$ cat c.sh
$ cat c.sh
echo "\$0=$0"
echo "\${BASH_SOURCE[0]}=${BASH_SOURCE[0]}"
echo "\$BASH_SOURCE=(${BASH_SOURCE[@]})"
现在执行a.sh这个脚本，实际的输出是（为了方便理解，我在实际的输出中加了一些注释和空行）：
$ bash a.sh
# c.sh的输出
$0=a.sh
${BASH_SOURCE[0]}=./c.sh
$BASH_SOURCE=(./c.sh ./b.sh a.sh)
# b.sh的输出
$0=a.sh
${BASH_SOURCE[0]}=./b.sh
$BASH_SOURCE=(./b.sh a.sh)
# a.sh的输出
$0=a.sh
${BASH_SOURCE[0]}=a.sh
$BASH_SOURCE=(a.sh)
此外，我们还可以利用BASH_SOURCE的值，在脚本中判断是被直接执行还是被导入：
if [ -n "$BASH_SOURCE" -a "$BASH_SOURCE" != "$0" ]
then
echo "be sourced by other scripts"
else
echo "be run in shell"
fi
37. ${}参数展开
我们知道\({parameter}是展开变量parameter这个值，在上一篇[简洁的bash编程技巧](https://kodango.com/simple-bash-programming-skills)中也曾经介绍过\){parameter:-word}这种用法，用于给变量赋一个默认值。
事实上除此之外，参数展开还有许多形式，在此之前，首先要说明一下变量的几种值的形式：
- unset： 变量未设置，即变量从未声明，或者被unset命令重置；
- null: 变量声明但未被赋值（var=）或者被赋值成空（var=""）；
- not null： 变量被赋值；
unset和null在参数展开的时候还是有很大的区别的，以下是参数展开的各种形式：
- ${parameter:-word}：假如parameter为unset或者null，则展开后返回word的值；
- ${parameter-word}：假如parameter为unset时，则展开后返回word的值；
- ${parameter:=word}：假如parameter为unset或者null，将word赋值给parameter；
- ${parameter=word}：假如parameter为unset，将word赋值给parameter；
- ${parameter:?word}：假如parameter为unset或者null，则将word作为错误输出到标准输出；
- ${parameter?word}：假如parameter为unset，则将word作为错误输出到标准输出；
- ${parameter:+word}：假如parameter为unset或者null，则不做展开，返回为空；（刚好与:-相反）
- ${parameter:word}：假如parameter为unset，则不做展开，返回为空；（刚好与-相反）
上面其实准确地应该是分成2组，一组带:，一组不带:，不带:的这组更加严格，只检查unset这种情况。以:+为例子, unset的情况均无返回：
$ unset var && echo ${var:+hello}
$ unset var && echo ${var+hello}
当var为空时：
$ var= && echo "${var:+hello}"
$ var= && echo "${var+hello}"
hello
当var为非空时：
$ var=1 && echo "${var:+hello}"
hello
$ var=1 && echo "${var+hello}"
hello
关于参数展开的具体内容可以参考Bash Man手册中的Parameter Expansion这一节。
38. 冒号的多种使用场景
冒号是一个比较奇怪的符号，它的用途有很多，这里介绍几种常用的：
- 内置命令null command：nop，表示什么都不做，也可以被当作true值使用；
$ :
$ echo $? # return 0
它也可以在循环中当作true值，例如:
while :; do # 等价于 while true; do
take-some-action
done
if condition
then :
else
take-some-action
fi
- 占位符
冒号可以在很多场景下充当占位符，例如之前介绍的${parameter=var}，如果直接执行会报错，表示找不到命令；这时可以借用冒号来完成赋值：
: ${parameter=var}
同样地，可以来判断变量是否赋值：
: ${parameter1?} ${parameter2?}
更多其它用法可以看ABS的Special Characters这一节。
39. 扩展的括号展开功能
这个功能不能说鸡肋，也可以了解下：
$ echo {0..3}
0 1 2 3
$ echo {z..a}
z y x w v u t s r q p o n m l k j i h g f e d c b a
$ echo {a..z}
a b c d e f g h i j k l m n o p q r s t u v w x y z
40. [[]]比[]作条件测试更安全
[[]]的功能比[]更加多，使用起来也更加安全。
- 首先[[]]内部不会发生文件名展开和单词分隔。
例如：
$ touch hello\ world
$ [[ -f $file ]] && echo yes
yes
$ [ -f $file ] && echo yes
-bash: [: hello: binary operator expected
- 进制之间自动转化
当一个十进制与八进制做比较时，会自动计算两个数的值，统一后做比较：
$ o=017
$ h=0x0f
$ [[ $o -eq $h ]] && echo yes
yes
$ [[ $o -eq 15 ]] && echo yes
yes
- [[]]支持&&，||等运算符
$ a=1;b=3
$ [[ $a > 0 && $b < 4 ]] && echo yes
yes
41. 获取Bash脚本的最后一个参数
我们都知道可以用$0，\(1等来获取传递给脚本或者函数的参数，也可以用\)*或者$@获取所有的参数，但是如果我只想要获取最后一个参数呢？
首先，你可能想到用遍历地方法（这里为了方便，我们使用set命令来设置位置参数）：
$ set -- arg1 arg2 arg3
$ for i in $@; do :; done
$ echo $i
arg3
这里的循环什么事情都没做，我用冒号（:）完成这个任务；循环结束后, $i就是保存着最后一个参数的值。
下面是两种更加简单的方法的：
$ echo ${@: -1}
$ echo ${!#}
上面的第一种方法事实上就是Parameter Expansion中的${parameter:offset:length}这种形式，只不过offset为-1表示最后一个元素，忽略length表明是从offset开始往后直到最后一个元素，即只取最后一个元素。这里要注意的一点是，在冒号和短横之间的空格不能少，否则就变成**37. \({}参数展开**中介绍的\){parameter:-var}这种用法了。
而第二种方法则是indirect referencing的一种表现，#这个特殊的变量存放参数的个数，!#则是对最后一个变量的引用。
42. Bash中的引用(indirect referencing)
有没有想法在Bash中也可以达到C++引用的效果？你可能不知道，但是你可能曾经有这种需求，我就有过：
有时候，我想要一个变量存放另外一个变量的名称，然后在后面我想通过这个变量的名称引用它的值
例子是这样的：
$ a=b
$ b=1
$ echo $a
b
$ eval "echo \$$a"
1
但是利用indirect referencing的用法，你可以这样获取b的值:
$ echo ${!a}
1
$ b=2
$ echo ${!a}
2
很奇怪的一种用法，关于indirect referencing你可以查看这里或者这里。
43. 替换语法${parameter/pattern/string}的妙用
${parameter/pattern/string}将parameter中匹配pattern的部分替换成string，例如下面的例子将字符串中的e替换成x：
$ str="three"
$ echo "${str/e/x}" # thrxe
如果pattern部分以/开头，表示替换parameter中所有匹配的内容，例如：
$ str="three"
$ echo "${str//e/x}" # thrxx
如果pattern部分以#开头，表示仅当parameter开始处匹配pattern的时候替换，例如：
str="three"
$ echo "${str/#e/x}" # three
$ echo "${str/#t/x}" # xhree
与此对应地是，如果pattern部分以%开头，表示仅当parameter结尾处匹配pattern的时候替换，例如：
$ str="three"
$ echo "${str/%e/x}" # threx
如果string部分为空，匹配pattern的部分被删除（替换为空），例如：
$ str="three"
$ echo "${str/h/}" # tree
这个时候第二个斜杠可以删除，即：echo "${str/h}"
如果parameter是一个数组会怎么样呢？有兴趣的可以看看Bash的man手册说明：
man -P 'less -p "\\$\{parameter/pattern/string}"' bash
44. +=运算符
有一天，我看到这样一个用法：
$ arr=(1 2 3)
$ arr+=(4 5)
原来数组还可以这样相加，后来我看了下Bash的手册，确实有一段这么说明的，这里未引用这段文字，有兴趣的可以查看Bash Reference Manual。
自然地我们会想到如果一个变量是数字，是否也可以用+=作运算呢？
$ i=1
$ i+=1
但是，运行后你会发现i的结果并不为2，而是11，这里bash并不认为i是一个整数，而是作为字符串。
这时可以通过declare声明一个变量为整数，上面的问题就解决了：
$ declare -i int=1
$ int+=1
$ echo $int
2
45. Here document不为人知的用法
一般的here document的用法是这样的：
$ cat b.sh
cat<<EOF
hello, $USER
EOF
$ sh b.sh
hello, kodango
here document中的变量都是会被展开的，那能不能不展开呢？答案是可以的，将EOF有引号括起来就可以：
$ cat b.sh
cat<<"EOF"
hello, $USER
EOF
$ sh b.sh
hello, $USER
一般here document用得最多的是在帮助函数(help\usage)函数里面，因为在这里我们要写一大段的脚本用法。
如果你有强迫症（比如我），有时候使用here document的时候会很不爽，因为here document里面每行首部的空格都会被保留，而如果要顶格写，在缩进的地方又会有点打乱结构，例如：
$ cat b.sh
# part 1
if :; then
cat << EOF
hello, $USER
EOF
fi
# part 2
if :; then
if :; then
cat << EOF
hello, $USER
EOF
fi
fi
上面的脚本执行的结果为：
$ sh b.sh
hello, kodango # part 1 result
hello, kodango # part 2 result
有没有办法既兼顾到缩进又能不保留行首空格呢？
答案也是肯定的，只不过语法又要稍稍变一下，现在在<<的后面加一个短横，这个用法下，行首的Tab字符都会被忽略：
$ cat b.sh
if :; then
cat <<- EOF
hello, $USER
EOF
fi
$ sh b.sh
hello, kodango
fi
一定要是Tab键哦，空格也是不可以的，在vim里面还要注意如果设置了smarttab选项，行首插入的Tab键会替换成相应个数的空格（这里可以按ctrl+v tab插入实际的空格）。
关于这一节的内容，可以进一步参考[Redirection#here_documents Bash Hackers Wiki]。
46. 使用内置命令declare显示脚本中定义的函数
declare的-F选项可以列出脚本中定义的函数名称：
$ cat b.sh
function one()
{
:
}
function two()
{
:
}
declare -F | sed 's/declare -f //'
$ sh b.sh
one
two
47. 嵌套函数还可以这么用
Bash中可以嵌套函数定义，即在一个函数中定义另外一个函数，例如：
[root@localhost ~]# cat nest.sh
#!/bin/bash
function out()
{
echo "out"
function inner() {
echo "inner"
}
}
inner
out
inner
这里out函数里面定义了inner函数，形成嵌套函数。但是，执行上面的例子会出错（nest.sh: line 12: inner: command not found），这是因为这是后inner函数还没定义。一旦out函数执行之后，inner函数就被定义了。整个例子的执行结果是这样的：
[root@localhost ~]# sh nest.sh
nest.sh: line 12: inner: command not found
out
inner
看到这里，你可能会想嵌套函数有什么用？事实上，在大多数情况下，我们基本不会用到嵌套函数。但是它并非一无是处，比如下面的例子就向我们展示了嵌套函数的神奇用法。
假设，我们要定义一个调试函数，同时需要一个开关控制该函数是否输出调试日志，最简单的写法是：
function log()
{
if [ "$verbose" = "1" ]; then
echo "$@"
fi
}
它可以完成任务，但是唯一美中不足的是，每次调用该函数都要判断verbose的值是否为1。这时候可以使用嵌套函数来弥补这个不足：
#!/bin/bash
verbose=${1:-1}
function log()
{
if [ $verbose -eq 1 ]; then
function log() {
echo "$@"
}
echo "$@"
else
function log() {
:
}
fi
}
log what is your name
log my name is kodango
上面的例子中，根据verbose的值定义了两个同名的log函数来覆盖之前的旧函数，以后调用的函数就都是后定义的函数了。
48. 删除ps auxf | grep python结果中的grep进程
在shell脚本中，经常需要利用ps和grep命令一起在查找进程相关的信息，尤其是针对python/java/shell等脚本进程，因为pidof本身不大支持查找脚本进程对应的pid。
在用ps auxf | grep python的时候，一个很恼人的事情是，经常会出现多余的grep进程：
$ ps auxf | grep python
kodango 18832 0.0 0.0 674192 10444 ? Sl 23:19 0:00 python test.py
kodango 63860 0.0 0.0 61180 752 pts/2 S+ 23:28 0:00 grep python
所以我们需要再加一个grep -v grep来排除它。
之前一直弄不明白为什么会这样，今天在看BashPitfalls的时候，终于明白原因了，stackoverflow上也有一个回答解释得很好。
shell在执行以上命令的时候，其实创建了一个管道，并且fork了两个子进程：ps auxf与grep python，并且将管道读的这一端绑定到grep的标准输入，管道写的这一段绑定到ps的标准输出。ps将自己的输出写到管道，grep从管道中读取输入。可能在这个时候，ps与grep是同时执行的，所以ps的结果中也会包含grep进程的信息。
还有一个解决方法是巧用正则表达式：
$ ps auxf | grep [p]ython
49. Shell如何实现timeout功能
有时候我们不希望某个命令执行太久，所以如果在给定的时间内没有完成，能够杀掉这个命令对应的进程，这就是timeout功能，可惜bash没有提供该功能。所以就得我们自己来实现。
实现代码如下所示：
function timeout()
{
local time cmd pid
if echo "$1" | grep -Eq '^[0-9]+'; then
time=$1
shift && cmd="$@"
else
time=5
cmd="$@"
fi
$cmd &
pid=$!
while kill -0 $pid &>/dev/null; do
sleep 1
let time-=1
if [ "$time" = "0" ]; then
kill -9 $pid &>/dev/null
wait $pid &>/dev/null
fi
done
}
假设有一个测试脚本sleep.sh：
$ cat sleep.sh
echo "sleep $1 seconds"
sleep $1
echo "awake from sleep"
现在利用我们写的timeout函数来达到超时kill功能：
$ time sh timeout.sh 2 'sh sleep.sh 100'
sleep 100 seconds
real 0m2.005s
user 0m0.002s
sys 0m0.001s
看最终执行的时间，差不多就是2秒钟。
上面timeout函数实现的代码中，利用了两个技巧：
- kill -0 $pid：发送信号0给进程，可以检查进程是否存活，如果进程不存在或者没有权限，则返回错误，错误码为1；
- wait $pid &>/dev/null：等待某个进程退出返回，这样相对比较优雅，同时将错误重定向到黑洞，从而隐藏后台进程被kill的错误输出；
50. 利用/etc/inittab实现watchdog
还在为实现watch dog而头疼吗，其实inittab中已经包含了该功能。可以将自己的脚本或者程序写到inittab文件中：
tt:2345:respawn:/home/kodango/sleep.sh 100
然后执行telinit q使其生效，ps看下该脚本是否已经在运行了，尝试kill后，又会被起起来。
51. 慎用波浪号展开
在shell中对比下面两种用法：
$ home1=~kodango
$ home2="~kodango"
$ echo -e "$home1\n$home2"
/Users/kodango
~kodango
第一个变量赋值，波浪号正确展开，所以我们得到了kodango用户的家目录地址；第二个变量，我们使用了双引号，这个时候波波浪号并没有展开。这是一个比较容易出错的地方。
还有一点要注意的地方是，波浪号展开只在:或者=号后面才会执行。所以：
$ path=1~kodango
$ echo "$path"
1~kodango
$ path=1:~kodango
$ echo "$path"
1:/Users/kodango
为什么要在:后面也可以展开呢？想想PATH的定义吧。
