【系统性学习】Linux Shell易忘重点整理

本文主要基于《实用Linux Shell编程》总结，并加入一些网上查询资料和博主自己的推断。
其中命令相关的，已抽取出来在另一篇系统性学习】Linux Shell常用命令中，可以一起使用。

一、基础知识

1. Linux 系统主要目录及简单描述
   
   

2. ls -l 详情解释：

-rw-------.  1 root root 1.3K Dec 14 01:38 anaconda-ks.cfg
dr-xr-xr-x. 17 root root  224 Dec 14 01:38 bin
1
2

• 第一列共10位，第1位表示文档类型，d表示目录，-表示文件，l表示链接文件，d表示可随机存取的设备，如U盘等，c表示一次性读取设备，如鼠标、键盘等。后9位，依次对应三种身份所拥有的权限，身份顺序为：owner、group、others，权限顺序为：readable、writable、excutable
• 第二列，对于文件表示硬链接数，表示有多少个文件链接到inode号码。对于目录表示子目录数（包括隐藏文件），所有目录都包含".“和”…"两个隐藏目录，所以目录的第二列>=2。
• 第三列表示拥有者,user
• 第四列表示所属群组，group
• 第五列表示文档容量大小
• 第六列表示文档最后修改时间，注意不是文档的创建时间
• 第七列表示文档名称。以点(.)开头的是隐藏文档

3. 账户权限说明：对于文件，读：可以查看 写：可以修改 执行：可以运行。对于目录，读：可以浏览，用ls 写：可以创建和删除文件 执行：可以进入该目录。
4. SUID：有的可执行二进制文件的账户权限为rws，s是SUID（即set uid）,表示其他账户在执行时，有文件所有者的权限。如passwd命令会改/etc/shadow文件，这个文件只有root用户可以修改。但其他账户同样可以执行passwd修改该文件。原因就是passwd文件是s权限。chmod u+s file或chmod 4755 file添加该权限。rwS显示S是不正常的，给文件添加x权限才会正常。SUID仅对可执行二进制文件起作用。
5. SGID：有的可执行二进制文件的所属组权限为rws，，s是SGID（即set gid）表示其他账户在执行时，具有文件所属组的权限。对目录设置SGID，则作用为：任何账户如果可以在该目录内建立新文件或新的子目录，那么新文件和子目录的所属组与该目录的所属组保持一致。SGID属性要保证目录或文件对所属组由x权限，否则为大写S。chmod g+s file或chmod 2755 file添加该权限
6. SBIT：粘滞位，t是SBIT只有目录可以设置，作用是：在一个大家都有权限的目录下，账户不能删除别人的文件或目录。chmod o+t file或chmod 1755 file添加该权限。SBIT要求其他账户有执行权限，否则为大写T。

二、命令与环境

1. linux命令分为内置命令和外部命令：help查看所有内置命令和关键字列表， help command查看内置命令详情。外置命令：which command查看外置命令位置，which无法对内置命令生效。command --help显示外置命令详情。
2. 内置变量PS1，主命令提示参数。重新登陆shell则恢复。永久保持写入~/.bashrc中。

\h 计算机名
\t 当前时间
\u 账户名
\w 当前路径
> PS1="\h@\u@\t$" #输入
host-10-31-17-80@user_client@16:17:03$ #提示符从>改变了
1
2
3
4
5
6

3. 搜索路径PATH，路径用:隔开，按顺序先后查找，找到就停止。在原路径后面加路径PATH='$PATH:/tmp/bin'。
4. 要永久改变环境变量，将修改写进~/.bashrc文件中。
5. 权限掩码umask
6. source和点命令：souce file和. file等价，如果file不在当前目录下，会在$PATH下找。
7. 直接执行脚本文件和source都能执行脚本中的命令。差异：a. 脚本在子shell中运行，而source是在父shell b. 直接运行脚本需要脚本有x权限，source不需要
8. 命令解释顺序及改变。命令类型查看用type command

alias->keywords->function->built-in->$PATH
别名->关键字->函数->内置命令->外部命令
1
2

• command <命令> 禁用别名和函数，先处理内置命令和外部命令
• builtin <命令> 只查找内置命令
• enable 禁用(-n)和使能内置命令（尽量少用，要避免自己的编写的命令和内置命令重名）

9. 命令或程序结束后会返回一个退出状态，取值0-255，0表示成功执行。内置变量$?存了上一条命令的退出状态 。
10. 内置命令true用于返回成功的状态，false则是失败。
11. 管道左侧|右侧，理解成左侧命令的输出，会给到右侧命令的输入，所以右侧命令不需要写代表输入的参数。
12. 执行一个shell命令会自动打开标准输入文件(stdin)和标准输出文件(stdout),他们默认对应终端键盘和终端屏幕，分别对应文件描述符0和1。文件描述符（file descriptor,fd）是进程对其打开文件的索引，形式上是个非负整数。

> ls -l /dev/std*
lrwxrwxrwx 1 root root 15 Aug 19  2015 /dev/stderr -> /proc/self/fd/2
lrwxrwxrwx 1 root root 15 Aug 19  2015 /dev/stdin -> /proc/self/fd/0
lrwxrwxrwx 1 root root 15 Aug 19  2015 /dev/stdout -> /proc/self/fd/1
> ls -l /proc/self/fd/*
lrwx------ 1 user_client users 64 Oct 22 17:00 /proc/self/fd/0 -> /dev/pts/0
lrwx------ 1 user_client users 64 Oct 22 17:00 /proc/self/fd/1 -> /dev/pts/0
lrwx------ 1 user_client users 64 Oct 22 17:00 /proc/self/fd/2 -> /dev/pts/0
1
2
3
4
5
6
7
8

Linux下的tty和pts详解
概述Linux TTY/PTS的区别
简单的说，/dev/pts/0 可以当做一个终端，这个终端连接了输入和输出，所以fd/0(标准输入)、fd/1（标准输出）、fd/2（标准错误）都可以连到这个终端上来。

  Input  +--------------------------+  R/W   +------+
----------->|             |<---------->| bash |
      |     pts/1      |      +------+
<-----------|             |<---------->| lsof |
  Output  | Foreground process group |  R/W   +------+
      +--------------------------+                
1
2
3
4
5
6

13. 输入重定向： 命令 输入->命令 < 文件名（不能是带输出的命令）
14. 输出重定向： 命令（能产生输出）->命令（能产生输出） >文件名，命令（能产生输出） >>文件名追加模式。> 文件名可以创建空文件或者清空文件。输出重定向是不安全的。如果想不覆盖源文件，可开启noclobber选项，set -o noclobber。
15. 标准错误输出（stderr）,对应fd/2，普通重定向>不起作用。需要 2> 实现重定向。
16. 同时处理，1>file1 2>file2标准到file1,错误到file2，>file 2>&1同时输出到file（等价 &> file 和>& file）。
17. “黑洞”，/dev/null一般用作垃圾箱，把不要的输出重定向到这里，如2> /dev/null
18. 一行多命令，用;隔开。
19. 后台执行：command &，执行后会输出 [工作号] 进程号。
20. 续行：命令太长可用\来分行，PS2控制续行提示符。
21. 特殊文件名处理：空格前面加\,-a.txt这样-开头的，用vi -- -a.txt或vi ./-a.txt。因为-后面会被认为是选项。Bash规定--(空格)后面的东西不是选项，而是文件名或参数。
22. 小括号，大括号，中括号

三、变量和数组

1. Bash只有字符串类型。整数型字符串赋值被变量时，变量相当于多了个整数属性，可以进行整数运算。
2. 变量定义时，等号左右两边不能有空格。引用变量时，前面加$。
3. 双引号作用，保留空格。a= 和b=" "，a是为空的，b才能保留空格。

• 单引号：相当于raw字符串：被单引号括起的内容不管是常量还是变量者不会发生替换。
• 双引号：把双引号内的内容输出出来；如果内容中有命令、变量等，会先把变量、命令解析出结果，发生替换，然后在输出最终内容来。
• 不加引号：不会将含有空格的字符串视为一个整体输出, 如果内容中有命令、变量等，会先把变量、命令解析出结果，然后在输出最终内容来，如果字符串中带有空格等特殊字符，则不能完整的输出，需要改加双引号，一般连续的字符串，数字，路径等可以用。

4. 取命令执行结果：`命令`,$(命令)都可以取命令输出的结果。要保留换行符、首尾空格等符号，则用"$(命令)"。可以把()当做子shell，里面的操作不会对父shell产生影响。少用反引号，因为$()便于嵌套。注意对比取变量${变量}和取命令输出结果$(命令)。

# 测试父shell中变量
> x=10
> b=$(echo $x)
> echo b=$b x=$10
b=10 x=0
> b=$(x=5;echo $x)
> echo b=$b x=$x
b=5 x=10 --父shell中的x没被改变

# 测试嵌套
> time=$(echo Today is $(date))
> echo $time
Today is Sun Oct 23 14:06:37 CST 2022

# 取变量和取命令
> aa=${date}
> echo aa
  --空，因为变量date没有定义
  
# 测试定义命令同名变量，不会影响命令执行
> date=3 #同名变量
> t1=$(date)
> t2=$date
> t3=${date}
>  echo -e "t1=$t1\nt2=$t2\nt3=$t3"
t1=Sun Oct 23 14:11:21 CST 2022
t2=3
t3=3

# 反斜杠取消符号原有功能
> echo "`date`"
Sun Oct 23 14:19:05 CST 2022
> echo "\`date\`"
`date`
> echo "$(date)"
Sun Oct 23 14:19:22 CST 2022
> echo "\$(date)"
$(date)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

5. 整型计算：放在双括号间或let后面。$((表达式))可取出表达式计算结果。单独的((表达式))仅仅是计算，而没有输出。i++(先用后加)，++i先加后用，支持+=,-=,*=,/=,%=,^=等运算。支持算木运算((条件?结果1：结果2))。$(())可替换成$[]，注意，有$时才能替换。另外，declare -i var定义了整型变量后，var=表达式不需要括号也可进行整型计算。

# 命令行理解
w=date
> echo $w
date
> $w  #直接被执行
Sun Oct 23 16:03:32 CST 2022

# 表达式结果
> echo $((50/20))
2
> echo $((w=50/20))
2
> echo $w
2
> echo $[a=10+5]
15
> echo $a
15

# 整型变量
>declare -i v
>v=$a+$w
>echo $v
30
>v=a+10 # 甚至不需要引用
>echo $v
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

6. 浮点运算：用bc或者awk。echo "scale=5;表达式|bc"或者直接bc开客户端运算，quit退出。
7. 其他进制：bash支持其他进制运算，只要在算数表达式能生效的地方都可以使用。两种书写方法，a. 基数#数值，基数可取2到64。b. 0开头表示8进制，0x开头表示十六进制：

((w=8#16)) #8进制的16赋值给w
((w=016))  #等价
((w=16#25)) #16进制的25赋值给w
((w=0x25))  #等价
1
2
3
4

8. 数组：bash只支持一维数组，下标默认从0开始。单独引用数组名时，返回数组第一个元素。打印数组全部详细信息，用 declare -p 数组名。

# 定义
y=(aa bb cc)
y=([1]=aa [3]=bb [5]=cc) # 非连续下标定义
>echo $y
aa
> declare -p y
declare -a y='([0]="aa" [1]="bb" [2]="cc")'

# 引用,${数组名[下标]}
echo $y  # 打印数组第一个元素
echo ${y[1]}
echo ${y[*]} #得到数组所有元素，作为一个整体
echo ${y[@]} #得到数组所有元素，作为一个个个体
echo ${#y[*]} #得到数组个数
echo ${!y[*]} #得到数组所有下标
# 增加或修改元素
y[3]=dd
y[2]=cc2
# 删除元素或数组
unset y[1]
unset y
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

9. 关联数组（其他语言里的map）：Bash4以上版本才支持。使用和数组类似，定义如下：

declare -A age=([Mike]=12 [Jack]=24 [Tom]=30)
# 显示详情
declare -p age

# 取建
echo ${!age[@]}
# 取值
echo ${age[@]}
1
2
3
4
5
6
7
8

10. Bash中的特殊变量。P118

11. set --清除所有位置参数,不包括$0。
12. 父shell与子shell及其进程ID。
13. 一些常用内置变量（或者说环境变量）P121

14. 常用变量赋值表达式。下面的Default可以是变量，取$变量。var也可以是0(不能赋值)或者位置变量1，2，3…10(不能赋值)。

15. 常用内置字符串操作(支持通配符)。sed和awk也有字符串处理函数，但内置操作最快。下表中的str可替换成数组名[*]，则表达式对于数组每个元素做处理。expr命令也可处理字符串，支持正则表达式。注意，str必须变量名。

> a=(one on1 tow)
> echo ${a[*]#o*}
ne n1 tow
> echo ${a[*]##o*}
tow
> b=${a[*]##o.*}
>  declare -p b
declare -- b="one on1 tow"
> echo ${a[@]##o*}
tow
> c=${a[@]##o*}
> declare -p c
declare -- c="tow"
1
2
3
4
5
6
7
8
9
10
11
12
13

四、条件流程控制

1. 条件判断命令：test 条件表达式或[ 条件表达式 ],中括号前后一定要有空格。$?取命令退出结果来看条件是否满足。满足则退出结果为0，否则为1。
2. 整型关系运算：

3. 字符串关系运算，注意需要加\转义，且str最好用""保护首尾的空格。

4. 文件属性判断，

5. 逻辑与：[ 条件表达式1 -a 条件表达式2 ],逻辑或：[ 条件表达式1 -o 条件表达式2 ],逻辑非：[ ! 条件表达式 ]。test同样。优先级：非、与、或，多条件可用()，括号最优先。
6. 双中括号代替test或[].[[]]使得P146：

• a. (,<等不用加反斜杠；
• b. 保留字符串首尾有空格时，也不需要加双引号
• c. 判断字符串相等或者不等时，右侧支持通配模式。*代表0或多个字符，?代表一个字符
• d. 支持&& 和 || 表达 代替 -a ,-o

7. 双小括号助力整数条件运算。(())使用场景：
   I. 计算表达式，((表达式))等价于 let 表达式 。表达式结果不是逻辑0或1的时候，该表达式不报错的退出状态永远是0。
   II. 上述表达式可以是整数相关的条件表达式，使得
   a. (,<等不用加反斜杠；
   b. >,<,!=可应用于整数，并且>=,<=,==也可使用
   c. 支持&& 和 || 表达 代替 -a ,-o

8. 命令的与或非：
   I. 与：命令1 && 命令2 ，命令结果都为0，才为0。若命令1结果为非0，则命令2不再执行。可用来实现命令依赖。
   II. 或：命令1 || 命令2 ，命令结果有一个为0，则为0。若命令1结果为0，则命令2不再执行。可用来按优先级至少执行一个命令。
   III. 非: ! 命令1 ，命令结果有一个为0，则为0。若命令1结果为0，则命令2不再执行。可用来按优先级至少执行一个命令。

# 样例
>[-r a.txt -a -w b.txt ] #判断文件存在和权限
>echo $?
0

# 优先级
> x=5;y=10;z=20
>[ \($x -eq 5 -o $y -gt 5\) -a $z -lt 5 ]
> echo $?
0
# 双中括号
>[[ ($x -eq 5 || $y -gt 5) && $z -lt 5 ]]
> echo $?
0
# 双小括号
>(( ($x == 5 || $y > 5) && $z < 5 ))
> echo $?
0

# 双中括号字符串相等或不相等右侧通配模式
>[[ $s1 == a* && $s2 != b? ]]

# 命令与或非
> [ 1 -eq 2 ] && [ 1 -lt 3 ] 
> echo $?
1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

9. 判断变量是否有定义：[-v 变量名] 或 test -v 变量名。结果为0则表示有定义。或者set，从结果中找，存在则表示有定义，但这种方式太繁琐。
10. if控制结构，可嵌套使用。

# if命令
if 命令 #该命令的退出结果为0，则执行then后面的语句
then
	命令1
	命令2
	...
if

if 命令;then 命令1;命令2...;fi  # 单行模式

#if-else 命令
if 命令
then 
	命令（命令组）
else #可以没有
	命令（命令组）
fi

if 命令;then 命令（命令组）;else 命令（命令组）;fi

#if-elif 命令
if 命令1
then 
	命令（命令组）
elif 命令2
then 
	命令（命令组）
elif 命令3
then 
	命令（命令组）
else  #可以没有
	命令（命令组）
fi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 命令中的重定向
if cp a.txt b.txt 2>/dev/null #重定向不影响命令退出状态
then
 	echo “copy done”
fi

# if-else的替换
if cmd1; then cmd2;else cmd3;fi
cmd1 && cmd2 ||cmd3 # 有可能等价
1
2
3
4
5
6
7
8
9

11. case 控制结构，如下模式可以是1个，或者多个，多个用|分割，或关系。模式支持正则表达式。如[6-7][0-9]表示60~79。

case $变量 in
	模式1)
		命令(命令组);;
	模式2)
		命令(命令组);;
	...
	*) #表示其他情况
		命令(命令组);;
esac
# 样例
case $score in
	100)
		echo "Full Mark";;
	9[0-9])
		echo "Excellent";;
	8[0-5] | 8[6-9])
		echo "Very Good";;
	[6-7][0-9])
		echo "Passing";;
	*)
		echo "Failed,or Error";;
esac
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

34. exit的退出状态默认为前一条命令的退出状态。也可以exit N带整型参数，则退出状态为N，这个特点可以配合if（产生exit 不同结果）和case（对不同结果做处理）命令使用。
35. here文档和case可模拟select命令的功能。详见常用命令here。

# 结合case使用，模拟select命令
cat << INPUT
choose your role
A）student
B) teacher
INPUT

read var
case $var in
	A)
		...;;
	B) 
	 	...;;
	*)
		echo "error";;
esac
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

五、循环

1. for控制流程，如下“”列表“”可以是字符串字面量，字符串变量，或位置参数枚举$*,$@，或数组枚举${数组名[*]，${数组名[@]
   I. 为字符串时，元素分割符由IFS指定（Internal Filed Seperator，字段分割符），默认为“空白字符”，linux中的"空白字符"包括:空格、\t、换行\n、回车\r（\n和\r 是不同的:\r是指 在同一行中, 使光标回到该行的行首。\n是指 光标转到下一行）。IFS使用后要记得恢复。IFS可以是多个，表示任意一个做分割，如IFS=";:"，表示:和;都是分割符。
   II. $*,$@的表现受双引号限制，有引号时"$*"仍是一个整体，"$@"则各元素分别作为一个整体；没有引号时，$*,$@表现一样，每个元素都分别作为一个整体。
   III. ${数组名[*]，${数组名[@]同上。
   IV. [in 列表]部分不是必须的，没有的时候相当于 for 变量 in "#@"

for 变量 [in 列表]
do
	命令（命令组）
done
#  单行
for 变量 [in 列表];do 命令（命令组）;done


# IFS注意点
> OLD_IFS="$IFS"
> IFS="$OLD_IFS" #用完后要恢复



# IFS 测试
> for a in 1 2 3;do echo  "${a}T";done
1T
2T
3T  --不带引号的字符串，触发天然分割，但该分割不是由IFS指定。
> for a in "1 2 3";do echo  "${a}T";done
1 2 3T  --不触发天然分割和IFS分割
> str2="1 2 3"
> for a in $str2;do echo  "${a}T";done
1T
2T
3T --变量引用触发IFS分割，当前分割符为默认的空白字符
>IFS=":"
> for a in "1:2:3";do echo "${a}T";done
1:2:3T
> str="1:2:3"
> for a in $str;do echo  "${a}T";done
1T
2T
3T  --变量引用触发IFS分割，当前分割符为:
> for a in 1 2 3;do echo  "${a}T";done
1T
2T
3T  --触发天然分割未受影响
> echo $str
1 2 3 --此时，echo得到的str结果可以看出，IFS分割已触发，分割后的元素用空格连接打印
> for a in $str2;do echo  "${a}T";done
1 2 3T --分割符已变，所以即使触发IFS分割，也分割不了
> a=$str
> declare -p str
declare -- str="1:2:3"
> declare -p a
declare -- a="1:2:3"
> echo "1:2"
1:2



所以，可以猜测，IFS只作用于引用变量的时候，即变量引用触发IFS分割，并将变量以IFS字符分割。
in后面只看有多少被分割元素，不触发分割。

# 引号下不同表现
>cat test.sh
for a in "$@";do echo $a;done

>test.sh A B C
A
B
C
>cat test.sh
for a in "$*";do echo $a;done
>test.sh A B C
A B C
>若不加双引号， 即 for a in $* 或 $@，结果都如下
>test.sh A B C
A
B
C  --可理解成，$*也触发天然分割，被切开了

# for 常用大括号扩展
for i in {1..10} # 或{a..z}, a{b,c}k,{10..1}等
do 
	...
done
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

2. 算数for循环，三个表达式不是必须的，但;需要保留。循环条件为空时，表示无限循环。

for ((变量初始化;循环条件;变量值更新))
do
	命令（命令组）
done

# 样例1
for ((i=0;i<10;i++));do echo $i;done
# 样例2
i=0
for ((;i<10;));do echo $i;((i++));done
1
2
3
4
5
6
7
8
9
10

3. while循环。先判断while后面命令的退出状态，为0时，do后面的命令再执行。

while 命令
do
	命令（命令组）
done
1
2
3
4

4. until循环。先判断while后面命令的退出状态，为0时，do后面的命令再停止。

until 命令 #等价于 while !命令
do
	命令（命令组）
done
1
2
3
4

5. break和continue可以跳出循环，包括for、while、until。break N和continue N跳出N层循环。技巧if 命令;then break/continue;fi可写成命令 && break/continue。
6. 循环的重定向以及和管道的配合。循环结构for、while、until都是以done结尾的，done后面可以接<，>做输入输出重定向，或者接| 命令做管道。因为while和until后面是命令，所以命令就有可能需要有输入，那么也是可以在前面加管道的，即 命令 | while 需要输入的命令。

# 输出管道，脚本：
for i in c b a m p
do
	echo $i
done | sort # 则该脚本可以输出排序后的值

# 输入重定向：
while read line
do
	echo $line
done < test.txt 

# 输入管道：
cat test.txt|while read line
do
	echo $line
done 

# 输入和输出：
cat test.txt|while read line
do
	echo $line
done > out.txt 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

六、函数

1. 函数定义有三种形式,可接受位置参数，调用时用法和脚本一样

function 函数名
{
	命令（命令组）
}

函数名()
{
	命令（命令组）
}

function 函数名()
{
	命令（命令组）
}
# 一行形式，右大括号前必须要有一个分号
function 函数名 {命令（命令组）;}

# 使用
函数名 arg1 arg2 arg3 #函数体力如果有echo，就打印echo内容

# 调用
source 函数定义脚本
$(函数名)
$(函数名 arg1 agr2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2. 函数内变量，如果和全局变量同名，则为全局变量，否则需要加上 local 或者declare声明成局部变量；如果是非同名变量，则为局部变量，加上declare -g 则可声明成全局变量。
3. 当前函数名，存在内部变量FUNNAME中。FUNNAME是一个数组，第一个元素为当前函数名，第二个元素为上一层调用函数名，declare - p FUNNAME或 echo ${FUNAME[*]}查看调用链。
4. 函数的导出与清除。declare -fx fun1, 导出函数，等同 export -f fun1。清除 unset -f 函数名或unset 函数名。declare -f fun1查看函数定义。
5. 函数返回命令return， 可带参数N。执行return后，函数中后续命令不再执行。return不带参数时，函数的返回状态为return上一条命令的状态。retrun N时，，函数的返回状态为N。可当做默认函数结尾有个隐含的return。
6. 递归函数，可以实现，但运行效率较低，且占用系统资源较多，不提倡写递归函数。

七、通配符、正则表达和文本处理

1. 通配符模式，glob（也叫wildcard）。支持以下几种

2. 扩展通配模式，可通过shopt -s extglob打开扩展(-u 表示关闭)，支持：

4. 通配符模式使用场景
   I. shell命令行里，加单引号，双引号或反斜杠时，失去通配符能力。如ls "*"找的就是名为*的文件。
   II. find -name file，中file支持通配符，且本身就放在双引号或单引号中，如find -name "a*.txt"，通配符能力不失去，加反斜杠才失去通配能力。
   III. 条件判断双中括号[[]]的等号或不等号右边支持通配符，右边如果带双引号或单引号或反斜杠，通配符失效。
   IV. 第三章15节的常用内置字符串操作(支持通配符)。如果带双引号或单引号或反斜杠，通配符失效。

# 条件判断中
> [[ "ads" == a* ]]
> echo $?
0
> [[ "ads" == "a*" ]]
> > echo $?
1 --双引号，通配符失效
# 内置字符串操作中
> str="abcd"
> echo ${str/a*/K}
K
> echo ${str/"a*"/K}
abcd  --双引号，通配符失效
1
2
3
4
5
6
7
8
9
10
11
12
13

3. GLOBIGNORE,被忽略的通配模式，用冒号分割。仅作用于命令行。

> touch a.txt b.txt c.txt d.txt
> find -name "*"
.
./c.txt
./a.txt
./d.txt
./b.txt
> ls *
a.txt  b.txt  c.txt  d.txt
> GLOBIGNORE=a*:b*
> ls *
c.txt  d.txt
> find -name "*"
.
./c.txt
./a.txt
./d.txt
./b.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4. 正则表达式，各语言的正则表达式支持范围略有不同，具体可查阅【中文，英文】。linux中，平常的正则表达式简称BRE(Basic Regular Expressions)，扩展的正则表达式叫ERE(Extended Regular Expressions)。Linux里的正则表达式都是贪婪的（当可匹配多个时，都匹配最长）。常用的正则模式有（其中，"扩展"在egrep命令中可使用）：

5. POSIX字符类。指定匹配字符范围的另一种方法。grep 中和egrep中使用方法一样。tr命令后也可使用单中括号tr [:punct:] X，但为了保持一致，建议都用双中括号。作用：有些字符类比正则表达简单，有些命令只支持POSIX不支持正则（如tr）。

# 样例
grep [[:punct:]] t.txt #过滤出包含空白字符的所有行
1
2

八、进程与作业

1. 挂起进程，比如进入vi后，在命令模式下，按挂起进程。jobs查看作业状态。

> vi test.txt # 按
[1]+  Stopped                 vi test.txt
> jobs
[1]+  Stopped                 vi test.txt
1
2
3
4

2. 熟悉命令 ps，jobs, fg, bg, kill, trap, suspend。

九、其他话题

1. 目录栈。通常，目录只保留了OLDPWD和PWD，无法再追踪更早之前的记录。pushd、popd，dirs提供了这方面的能力。使用pushd命令记录的目录栈保存在内置变量DIRSTACK中。

pushd cd到目录，并将目录放入目录栈
+/-N 目录栈的“环滑动”，+N从栈顶的第N个项目滑为栈顶，-N从栈底的第N个目录滑为栈顶

>pwd
/usr
> dirs -c
> pushd /usr/bin 
/usr/bin /usr  --永远把当前目录放在栈底
> pushd /var/lib
/var/lib /usr/bin /usr
> declare -p DIRSTACK 
declare -a DIRSTACK='([0]="/var/lib" [1]="/usr/bin" [2]="/usr")'

dirs
-p 每行显示目录栈内一个目录
-v p的基础上带编号，编号大的在栈底
+/-N 不改变目录栈的内容，+N表示从栈顶数第N个目录，-N表示从栈底数第N个目录
> dirs
/var/lib /usr/bin /usr
> dirs -v
 0  /var/lib
 1  /usr/bin
 2  /usr
> dirs -p
/var/lib
/usr/bin
/usr
> dirs +1
/usr/bin

popd 移除栈顶目录，并cd到新栈顶目录
+/-N 
> popd
/usr/bin /usr
> pwd
/usr/bin
> dirs -v
 0  /usr/bin
 1  /usr

## 环滑动
> dirs -v
 0  /opt
 1  /usr/lib
 2  /usr/bin  --从栈顶第2位
 3  /usr
> pushd +2
/usr/bin /usr /opt /usr/lib
> dirs -v
 0  /usr/bin  --原从栈顶第2位
 1  /usr
 2  /opt   --原栈顶滑下来了
 3  /usr/lib
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

2. 波浪号扩展

3. 交互式shell和非交互式shell、登录shell和非登录shell
4. expand_aliases别名功能，交互式shell默认打开，非交互式shell默认关闭。
   I. 不要在脚本内使用别名，不然要显示打开expand_aliases。
   II. 别名不能export，要想在其他shell中使用，将别名放到脚本里，再source 脚本名。
   III. 函数内定义的别名，在函数调用前不能使用。
   IV. 综上，不要在脚本和函数内使用别名。
5. 并行处理。常用名命令grep，wc,awk和sed等都是单线程的，只能使用一个cpu。服务器有多个cpu时，可以利用GNU的parallel命令，把负载分配到各个cpu上。
   I. parrallel命令通常需要下载安装，官网。
   II. 使用说明。

mpstat # 查看cpu信息，该命令不是所有bash都有
> cat /proc/cpuinfo |grep processor | wc -l # 获取cpu数
2
1
2
3

十、Bash调试

1. 正式运行脚本前，先set -n 或set -o noexce，读命令，解释但不执行，用来检查脚本语法
2. set -u 或 set -o nounset，有变量未定义时提示错误信息
3. shopt -s shift_verbose，shift移动数大于参数个数时，提示错误
4. set -v 或 set -o verbose，为调试打开verbose模式，脚本运行时显示读入的每行命令，并原样打印
5. set -x 或 set -o xtrace，为调试打开echo模式，脚本运行时显示变量替换后的每行命令和参数。只调试一段代码时，在代码前后添加：

set -xv
待调试代码段
set +xv
1
2
3

6. set -x的提示符为PS4，默认为+，可修改成PS4=+'$[LINENO]'打印代码行号。
7. bash -x 脚本 和 set -x是一样的，相当于在脚本前增加了set -x。便于脚本测试。
8. 利用trap捕获信号来调试
9. 打印内容调试
10. 利用BASH_SOURCE，BASH_SUBSHELL，FUNNAME等内置变量。
11. 输出重定向获取log文件来分析
12. 在代码中增加“调试块”，if语句开控制变量调试信息是否打印

if [$DEBUG = YES];then
	打印调试信息
fi
1
2
3

# 当前执行脚本的绝对路径，可以采用以下方式：
DIR_T="$( cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# 在tmp文件夹下创建脚本test.sh 和a.sh
> cat test.sh
echo BASH_SOURCE=${BASH_SOURCE[0]}
echo \$0=$0
DIR_T="$( cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
echo ${DIR_T}
> cat a.sh
echo "This is a.sh"
source test.sh

# 运行
> ./test.sh
BASH_SOURCE=./test.sh --相对路径
$0=./test.sh --相对路径
/opt/user/tmp --绝对路径
> bash test.sh
BASH_SOURCE=test.sh
$0=test.sh
/opt/user/tmp
> ../tmp/test.sh
BASH_SOURCE=../tmp/test.sh --相对路径
$0=../tmp/test.sh --相对路径
/opt/user/tmp
> bash ../tmp/test.sh
BASH_SOURCE=../tmp/test.sh
$0=../tmp/test.sh
/opt/user/tmp
> ./a.sh
This is a.sh
BASH_SOURCE=test.sh
$0=./a.sh  --父脚本的名字
/opt/user/tmp

# BASH_SUBSHELL
> echo $BASH_SUBSHELL
0
> (echo $BASH_SUBSHELL)
1
> ( ( ( ( (echo $BASH_SUBSHELL) ) ) ) )
5
> bash
> echo $SHLVL
1
> echo $BASH_SUBSHELL
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48