bash--shell高级编程－特殊字符

---

shell高级编程－特殊字符

---

3. 特殊字符
   用在脚本和其他地方的特殊字符

#

注释. 行首以#(#!是个例外)开头是注释.

 # This line is a comment.

注释也可以放在于本行命令的后边.

 echo "A comment will follow." # 注释在这里.
#  注意#前边的空白

注释也可以放在本行行首空白的后面.

# A tab precedes this comment.

命令是不能放在同一行上注释的后边的. 因为没有办法把注释结束掉, 好让
同一行上后边的"代码生效". 只能够另起一行来使用下一个命令.
当然, 在echo中转义的#是不能作为注释的. 同样的, #也可以出现在特定的
参数替换结构中, 或者是出现在数字常量表达式中.

echo "The # here does not begin a comment."
echo 'The # here does not begin a comment.'
echo The \# here does not begin a comment.
echo The # 这里开始一个注释.

echo ${PATH#*:}
# 参数替换,
echo $(( 2#101011 )) # 数制转换,

标准的引用和转义字符(" ’ )可以用来转义#.
某些特定的模式匹配操作也可以使用#.
;
命令分隔符[分号, 即;]. 可以在同一行上写两个或两个以上的命令.

 echo hello; echo there

 if [ -x "$filename" ]; then  # 注意: "if"和"then"需要分隔.
							# 为什么?
	echo "File $filename exists."; cp $filename $filename.bak
	else
	echo "File $filename not found."; touch $filename
fi; echo "File test complete."

注意一下";"某些情况下需要转义.
;;
终止case选项[双分号, 即;;].

case "$variable" in
abc) echo "\$variable = abc" ;;
xyz) echo "\$variable = xyz" ;;
esac.

"点"命令[句点, 即.]. 等价于source命令(参见 例子 11-21). 这是一个bash的内建命令.
.
"点"作为文件名的一部分. 如果点放在文件名的开头的话, 那么这个文件将会成为"隐藏"文件,
并且ls命令将不会正常的显示出这个文件.

如果作为目录名的话, 一个单独的点代表当前的工作目录, 而两个点表示上一级目录.

bash$ pwd
/home/bozo/projects
bash$ cd .
bash$ pwd
/home/bozo/projects
bash$ cd ..
bash$ pwd
/home/bozo/

.
"点"命令[句点, 即.]. 等价于source命令(参见 例子 11-21). 这是一个bash的内建命令.
.
"点"作为文件名的一部分. 如果点放在文件名的开头的话, 那么这个文件将会成为"隐藏"文件,
并且ls命令将不会正常的显示出这个文件.

bash$ touch .hidden-file
bash$ ls -l
total 10
-rw-r--r-- 1 bozo 4034 Jul 18 22:04 data1.addressbook
-rw-r--r-- 1 bozo 4602 May 25 13:58 data1.addressbook.bak
-rw-r--r-- 1 bozo 877 Dec 17 2000 employment.addressbook
bash$ ls -al
total 14
drwxrwxr-x 2 bozo bozo 1024 Aug 29 20:54 ./
drwx------ 52 bozo bozo 3072 Aug 29 20:51 ../
-rw-r--r-- 1 bozo bozo 4034 Jul 18 22:04 data1.addressbook
-rw-r--r-- 1 bozo bozo 4602 May 25 13:58
data1.addressbook.bak
-rw-r--r-- 1 bozo bozo 877 Dec 17 2000
employment.addressbook
-rw-rw-r-- 1 bozo bozo 0 Aug 29 20:54 .hidden-file

.
"点"字符匹配. 当用作匹配字符的作用时, 通常都是作为正则表达式的一部分来使用, “点"用来
匹配任何的单个字符.
"
部分引用[双引号, 即”]. "STRING"将会阻止(解释)STRING中大部分特殊的字符. 参见 5.
’
全引用[单引号, 即’]. 'STRING’将会阻止STRING中所有特殊字符的解释. 这是一种比使用"更强
烈的形式. 参见 5.
,
逗号操作符. 逗号操作符链接了一系列的算术操作. 虽然里边所有的内容都被运行了,但只有最后
一项被返回.

let "t2 = ((a = 9, 15 / 3))" # Set "a = 9" and "t2 = 15 / 3"

\

转义符[反斜线, 即]. 一种对单字符的引用机制.
\X将会"转义"字符X. 这等价于"X", 也等价于’X’. \通常用来转义"和’, 这样双引号和但引号就
不会被解释成特殊含义了.
/
文件名路径分隔符[斜线, 即/]. 分隔文件名不同的部分(比如 /home/bozo/projects/Makefile).
也可以用来作为除法算术操作符.

`

命令替换. command结构可以将命令的输出赋值到一个变量中去. 我们在后边的后置引用
(backquotes)或后置标记(backticks)中也会讲解.
:
空命令[冒号, 即:]. 等价于"NOP" (no op, 一个什么也不干的命令). 也可以被认为与shell的
内建命令true作用相同. ":“命令是一个bash的内建命令, 它的退出码(exit status)是"true”(0).

:
echo $? # 0

死循环:

while :
do
operation-1
operation-2
...
operation-n
done
# 与下边相同:
# while true
# do
# ...
# done

在if/then中的占位符:

 if condition
 then : # 什么都不做,引出分支.
 else
 take-some-action
 fi

在一个二元命令中提供一个占位符

 : ${username=`whoami`}
 # ${username=`whoami`} 如果没有开头的":"的话, 将会给出一个错误,
 # 除非"username"是一个命令或者内建命令...

在here document中提供一个命令所需的占位符.
使用参数替换来评估字符串变量

 : ${HOSTNAME?} ${USER?} ${MAIL?}
 # 如果一个或多个必要的环境变量没被设置的话,
 #+ 就打印错误信息.

变量扩展/子串替换.
在与>重定向操作符结合使用时, 将会把一个文件清空, 但是并不会修改这个文件的权限. 如果之
前这个文件并不存在, 那么就创建这个文件.

 : > data.xxx # 文件"data.xxx"现在被清空了.

 # 与 cat /dev/null >data.xxx 的作用相同
 # 然而,这并不会产生一个新的进程, 因为":"是一个内建命令.

:在与>>重定向操作符结合使用时, 将不会对预先存在的目标文件(: >> target_file)产生任何影响. 如果这个文件之前并不存在, 那么就创建它.
这只适用于正规文件, 而不适用于管道, 符号连接, 和某些特殊文件.
也可能用来作为注释行, 虽然我们不推荐这么做. 使用#来注释的话, 将关闭剩余行的错误检查,
所以可以在注释行中写任何东西. 然而, 使用:的话将不会这样.

 : This is a comment that generates an error, ( if [ $x -eq 3] ).
":"还用来在/etc/passwd和$PATH变量中做分隔符.
bash$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/sbin:/usr/sbin:/usr/games

!
取反操作符[叹号, 即!. !操作符将会反转命令的退出码的结果,. 也会反转测试操作符的意义, 比如修改"等号"( = )为"不等号"( != ). !操作符是Bash的关键字.
在一个不同的上下文中, !也会出现在变量的间接引用中.
在另一种上下文中, 如命令行模式下, !还能反转bash的历史机制 , 需要注意
的是, 在一个脚本中, 历史机制是被禁用的.

*

通配符[星号, 即*]. *可以用来做文件名匹配(这个东西有个专有名词叫globbing)的"通配符".含义是, 可以用来匹配给定目录下的任何文件名.
bash$ echo *
abs-book.sgml add-drive.sh agram.sh alias.sh
也可以用在正则表达式中, 用来匹配任意个数(包含0个)的字符.
*
算术操作符. 在算术操作符的上下文中, 号表示乘法运算.
如果要做求幂运算, 使用, 这是求幂操作符.
?
测试操作符. 在一个特定的表达式中, ?用来测试一个条件的结果.
在一个双括号结构中, ?就是C语言的三元操作符. 参见例子 9-31.
在参数替换表达式中, ?用来测试一个变量是否被set了. .
?
通配符. ?在通配(globbing)中, 用来做匹配单个字符的"通配符", 在正则表达式中, 也是用
来表示一个字符.
$
变量替换(引用变量的内容).

 var1=5
 var2=23skidoo

 echo $var1 # 5
 echo $var2 # 23skidoo

在一个变量前面加上$用来引用这个变量的值.
$
行结束符. 在正则表达式中, "$"表示行结束符.
${}
参数替换.
$*, $@
位置参数.
$?
退出状态码变量. $? 变量 保存了一个命令, 一个函数, 或者是脚本本身的退出状态码.

$$

进程ID变量. 这个$$ 变量 保存了它所在脚本的进程 ID [1]
()
命令组.

(a=hello; echo $a)

在括号中的命令列表, 将会作为一个子shell来运行.
在括号中的变量,由于是在子shell中,所以对于脚本剩下的部分是不可用的.
父进程, 也就是脚本本身, 将不能够读取在子进程中创建的变量, 也就是在
子shell中创建的变量.

 a=123
 ( a=321; )

 echo "a = $a" # a = 123
 # 在圆括号中a变量, 更像是一个局部变量.

初始化数组.

 Array=(element1 element2 element3)

{xxx,yyy,zzz,…}
大括号扩展.

 cat {file1,file2,file3} > combined_file
 # 把file1, file2, file3连接在一起, 并且重定向到combined_file中.


 cp file22.{txt,backup}
 # 拷贝"file22.txt"到"file22.backup"中

一个命令可能会对大括号 [2] 中的以逗号分割的文件列表起作用. (通配(globbing))将对大括号中的文件名做扩展.
在大括号中, 不允许有空白, 除非这个空白被引用或转义.

echo {file1,file2}\ :{\ A," B",' C'}
file1 : A file1 : B file1 : C file2 : A file2 : B file2 : C

{}代码块[大括号, 即{}]. 又被称为内部组, 这个结构事实上创建了一个匿名函数(一个没有名字的函数). 然而, 与"标准"函数不同的是, 在其中声明的变量,对于脚本其他部分的代码来说还是可
见的.

bash$ { local a;
a=123; }
bash: local: can only be used in a
function
 a=123
 { a=321; }
 echo "a = $a" # a = 321 (说明在代码块中对变量a所作的修改, 影响了外边的
变量)

下边的代码展示了在大括号结构中代码的I/O 重定向.

 #!/bin/bash
 # 从/etc/fstab中读行.

 File=/etc/fstab
 #使用大括号和代码重定向来实现从文件中获取数据
 {
 read line1
 read line2
 } < $File

 echo "First line in $File is:"
 echo "$line1"
 echo
 echo "Second line in $File is:"
 echo "$line2"

 exit 0

将一个代码块的结果保存到文件

 #!/bin/bash
 # rpm-check.sh

 # 这个脚本的目的是为了描述, 列表, 和确定是否可以安装一个rpm包.
 # 在一个文件中保存输出.
 #
 # 这个脚本使用一个代码块来展示.

 SUCCESS=0
 E_NOARGS=65

 if [ -z "$1" ]
 then
 echo "Usage: `basename $0` rpm-file"
 exit $E_NOARGS
 fi

 {
 echo
 echo "Archive Description:"
 rpm -qpi $1 # 查询说明.
 echo
 echo "Archive Listing:"
 rpm -qpl $1 # 查询列表.
 echo
 rpm -i --test $1 # 查询rpm包是否可以被安装.
 if [ "$?" -eq $SUCCESS ]
 then
 echo "$1 can be installed."
 else
 echo "$1 cannot be installed."
 fi
 echo
 } > "$1.test" # 把代码块中的所有输出都重定向到文件中.

 echo "Results of rpm test in file $1.test"

 # 查看rpm的man页来查看rpm的选项.

 exit 0

与上面所讲到的()中的命令组不同的是, {大括号}中的代码块将不会开启一
个新的子shell. [3]
“{} \;”
路径名. 一般都在find命令中使用. 这不是一个shell内建命令.
";"用来结束find命令序列的-exec选项. 它需要被保护以防止被shell所解
释.

[ ]
条件测试.
条件测试表达式放在[ ]中. 值得注意的是[是shell内建test命令的一部分, 并不
是/usr/bin/test中的外部命令的一个链接.

[[ ]]
测试.
测试表达式放在[[ ]]中. (shell关键字).

[ ]
数组元素.
在一个array结构的上下文中, 中括号用来引用数组中每个元素的编号.

1 Array[1]=slot_1
2 echo ${Array[1]}

[ ]
字符范围.
用作正则表达式的一部分, 方括号描述一个匹配的字符范围.
(( ))
整数扩展.
扩展并计算在(( ))中的整数表达式.
请参考关于(( … )) 结构的讨论.

> &> >& >> < <>

重定向.
scriptname >filename 重定向scriptname的输出到文件filename中. 如果filename存在的话, 那
么将会被覆盖.
command &>filename 重定向command的stdout和stderr到filename中.
command >&2 重定向command的stdout到stderr中.
scriptname >>filename 把scriptname的输出追加到文件filename中. 如果filename不存在的话,
将会被创建.
[i]<>filename 打开文件filename用来读写, 并且分配文件描述符i给这个文件. 如果filename不
存在, 这个文件将会被创建.
进程替换.
(command)>
<(command)
在一种不同的上下文中, "<“和”>"可用来做 字符串比较操作.
在另一种上下文中, "<“和”>"可用来做 整数比较操作. 参见例子 12-9.
<<
用在here document中的重定向.
<<<
用在here string中的重定向.
<, >
ASCII comparison.

 veg1=carrots
 veg2=tomatoes

 if [[ "$veg1" < "$veg2" ]]
 then
 echo "Although $veg1 precede $veg2 in the dictionary,"
 echo "this implies nothing about my culinary preferences."
 else
 echo "What kind of dictionary are you using, anyhow?"
 fi

\<, \>

正则表达式中的单词边界 .

bash$ grep '\' textfile

|
管道. 分析前边命令的输出, 并将输出作为后边命令的输入. 这是一种产生命令链的好方法.

 echo ls -l | sh
 # 传递"echo ls -l"的输出到shell中,
 #+ 与一个简单的"ls -l"结果相同.


 cat *.lst | sort | uniq
 # 合并和排序所有的".lst"文件, 然后删除所有重复的行.

管道是进程间通讯的一个典型办法, 将一个进程的stdout放到另一个进程的stdin中. 标准的方法是将一个一般命令的输出, 比如cat或者echo, 传递到一个 “过滤命令”(在这个过滤命令中将处理输入)中, 然后得到结果.

cat $filename1 $filename2 | grep $search_word

当然输出的命令也可以传递到脚本中.

 #!/bin/bash
 # uppercase.sh : 修改输入, 全部转换为大写.

 tr 'a-z' 'A-Z'
 # 字符范围必须被""引用起来
 #+ 来阻止产生单字符的文件名.

 exit 0

现在让我们输送ls -l的输出到一个脚本中.

bash$ ls -l | ./uppercase.sh
-RW-RW-R-- 1 BOZO BOZO 109 APR 7 19:49 1.TXT
-RW-RW-R-- 1 BOZO BOZO 109 APR 14 16:48 2.TXT
-RW-R--R-- 1 BOZO BOZO 725 APR 20 20:56 DATA-FILE

管道中的每个进程的stdout比须被下一个进程作为stdin来读入. 否则, 数
据流会阻塞, 并且管道将产生一些非预期的行为.

 cat file1 file2 | ls -l | sort
 # 从"cat file1 file2"中的输出并没出现.作为子进程的运行的管道, 不能够改变脚本的变量.
 variable="initial_value"
 echo "new_value" | read variable
 echo "variable = $variable" # variable = initial_value

如果管道中的某个命令产生了一个异常,并中途失败,那么这个管道将过早的
终止. 这种行为被叫做broken pipe, 并且这种状态下将发送一个SIGPIPE
信号.

      >|

强制重定向(即使设置了noclobber选项 – 就是-C选项). 这将强制的覆盖一个现存文件.

	||


或-逻辑操作. 在一个条件测试结构中, 如果条件测试结构两边中的任意一边结果为true的话,||操作就会返回0(代表执行成功).

&

后台运行命令. 一个命令后边跟一个& 表示在后台运行.

bash$ sleep 10 &
[1] 850
[1]+ Done sleep 10
在一个脚本中,命令和循环都可能运行在后台.

 #!/bin/bash
 # background-loop.sh

for i in 1 2 3 4 5 6 7 8 9 10 # 第一个循环.
 do
 echo -n "$i "
 done & # 在后台运行这个循环.
 # 在第2个循环之后, 将在某些时候执行.

 echo # 这个'echo'某些时候将不会显示.

 for i in 11 12 13 14 15 16 17 18 19 20 # 第二个循环.
 do
 echo -n "$i "
 done

 echo # 这个'echo'某些时候将不会显示.

 # ======================================================

 # 期望的输出应该是:
 # 1 2 3 4 5 6 7 8 9 10
 # 11 12 13 14 15 16 17 18 19 20

 # 然而实际的结果有可能是:
# 11 12 13 14 15 16 17 18 19 20
 # 1 2 3 4 5 6 7 8 9 10 bozo $
 # (第2个'echo'没执行, 为什么?)

 # 也可能是:
 # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 # (第1个'echo'没执行, 为什么?)

 # 非常少见的执行结果, 也有可能是:
 # 11 12 13 1 2 3 4 5 6 7 8 9 10 14 15 16 17 18 19 20
 # 前台的循环先于后台的执行.

 exit 0

 # Nasimuddin Ansari 建议加一句 sleep 1
 #+ 在6行和14行的 echo -n "$i" 之后加这句.
 #+ 为了真正的乐趣.

在一个脚本内后台运行一个命令,有可能造成这个脚本的挂起,等待一个按键
响应. 幸运的是, 我们有针对这个问题的解决办法.

&&

与-逻辑操作. 在一个条件测试结构中, 只有在条件测试结构的两边结果都为true的时候, &&操作才会返回0(代表sucess).

-

选项, 前缀. 在所有的命令内如果想使用选项参数的话,前边都要加上"-".

COMMAND -[Option1][Option2][...]
ls -al
sort -dfu $filename
set -- $variable
 if [ $file1 -ot $file2 ]
 then
echo "File $file1 is older than $file2."
 fi

 if [ "$a" -eq "$b" ]
 then
echo "$a is equal to $b."
 fi

 if [ "$c" -eq 24 -a "$d" -eq 47 ]
 then
 echo "$c equals 24 and $d equals 47."
 fi

-

用于重定向stdin或stdout[破折号, 即-].

 (cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)
  # 从一个目录移动整个目录树到另一个目录
 # [感谢Alan Cox , 走出了部分修改]

 # 1) cd /source/directory 源目录
 # 2) && "与列表": 如果'cd'命令成功了, 那么就执行下边的命令.
 # 3) tar cf - . 'c'创建一个新文档, 'f'后边跟'-'指定目标文件作为stdout
 # '-'后边的'f'(file)选项, 指明作为stdout的目文件.
# 并且在当前目录('.')执行.
 # 4) | 管道...
 # 5) ( ... ) 一个子shell
 # 6) cd /dest/directory 改变当前目录到目标目录.
 # 7) && "与列表", 同上
 # 8) tar xpvf - 'x'解档, 'p'保证所有权和文件属性,
 # 'v'发完整消息到stdout,
 # 'f'后边跟'-',从stdin读取数据.
 #
 # :'x' , 'p', 'v', 'f' .注意是一个命令是选项
 # Whew!



 # 更优雅的写法应该是:
 # cd source/directory
 # tar cf - . | (cd ../dest/directory; tar xpvf -)
 #
 # 当然也可以这么写:
 # cp -a /source/directory/* /dest/directory
 # 或者:
# cp -a /source/directory/* /source/directory/.[^.]* /dest/directory
 # 如果在/source/directory中有隐藏文件的话.

---

 bunzip2 -c linux-2.6.16.tar.bz2 | tar xvf -
 # --未解压的tar文件-- | --然后把它传递到"tar"中--
 # 如果 "tar" 没能够正常的处理"bunzip2",
 #+ 这就需要使用管道来执行2个单独的步骤来完成它.
 # 这个练习的目的是解档"bzipped"的kernel源文件.

---

注意, 在这个上下文中"-"本身并不是一个Bash操作, 而是一个可以被特定的UNIX工具识别的选
项, 这些特定的UNIX工具特指那些可以写输出到stdout的工具, 比如tar, cat, 等等.

bash$ echo "whatever" | cat -
whatever

---

在需要一个文件名的位置, -重定向输出到stdout(有时候会在tar和cf中出现), 或者从stdin接受输入, 而不是从一个文件中接受输入. 这是在管道中使用文件导向(file-oriented)工具来作为过滤器的一种方法.
bash$ file
Usage: file [-bciknvzL] [-f namefile] [-m magicfiles] file...
在命令行上单独给出一个file, 会给出一个错误信息.
添加一个"-"将得到一个更有用的结果. 这会使shell等待用户输入.
bash$ file -
abc
standard input: ASCII text
bash$ file -
#!/bin/bash
standard input: Bourne-Again shell script text executable
现在命令从stdin中接受了输入, 并分析它.
"-"可以被用来将stdout通过管道传递到其他命令中. 这样就允许使用在一个文件开头添加几行的技巧.

使用diff命令来和另一个文件的某一段进行比较:

grep Linux file1 | diff file2 -

最后, 来展示一个使用-的tar命令的一个真实的例子.
备份最后一天所有修改的文件

 #!/bin/bash

 # 在一个"tarball"中(经过tar和gzip处理过的文件)
 #+ 备份最后24小时当前目录下d所有修改的文件.

 BACKUPFILE=backup-$(date +%m-%d-%Y)
# 在备份文件中嵌入时间.
 # Thanks, Joshua Tschida, for the idea.
 archive=${1:-$BACKUPFILE}
 # 如果在命令行中没有指定备份文件的文件名,
 #+ 那么将默认使用"backup-MM-DD-YYYY.tar.gz".

 tar cvf - `find . -mtime -1 -type f -print` > $archive.tar
 gzip $archive.tar
 echo "Directory $PWD backed up in archive file \"$archive.tar.gz\"."


 # Stephane Chazelas指出上边代码,
 #+ 如果在发现太多的文件的时候, 或者是如果文件
 #+ 名包括空格的时候, 将执行失败.

 # Stephane Chazelas建议使用下边的两种代码之一:
 # -------------------------------------------------

 # find . -mtime -1 -type f -print0 | xargs -0 tar rvf
"$archive.tar"
 # 使用gnu版本的"find".


 # find . -mtime -1 -type f -exec tar rvf "$archive.tar" '{}' \;
 # 对于其他风格的UNIX便于移植, 但是比较慢.
 # ------------------------------------------------------



 exit 0

以'-'开头的文件名在使用"-"作为重定向操作符的时候, 可能会产生问题.
应该写一个脚本来检查这个问题, 并给这个文件加上合适的前缀. 比如:
./-FILENAME, $PWD/-FILENAME, 或者 $PATHNAME/-FILENAME.
如果变量以-开头进行命名, 可能也会引起问题.

 var="-n"
 echo $var
 # 具有"echo -n"的效果了,这样什么都不会输出的.

-
先前的工作目录. cd -将会回到先前的工作目录. 它使用了$OLDPWD 环境变量.
不要混淆这里所使用的"-"和先前我们所讨论的"-"重定向操作符. 对于"-
"的具体解释只能依赖于具体的上下文.
-
减号. 减号属于算术操作.
=
等号. 赋值操作
 a=28
 echo $a # 28
在另一种上下文环境中, "="也用来做字符串比较操作.
+
加号. 加法算术操作.
在另一种上下文环境中, +也是一种正则表达式操作.
+
选项. 一个命令或者过滤器的选项标记.
某些命令内建命令使用+来打开特定的选项, 用-来禁用这些特定的选项.
%
取模. 取模(一次除法的余数)算术操作.
在不同的上下文中, %也是一种模式匹配操作.
~
home目录[波浪号, 即~]. 相当于$HOME内部变量. ~bozo是bozo的home目录, 并且ls ~bozo将列
出其中的内容. ~/就是当前用户的home目录, 并且ls ~/将列出其中的内容.
bash$ echo ~bozo
/home/bozo
bash$ echo ~
/home/bozo
bash$ echo ~/
/home/bozo/
bash$ echo ~:
/home/bozo:
bash$ echo ~nonexistent-user
~nonexistent-user
~+
当前工作目录. 相当于$PWD内部变量.
~-
先前的工作目录. 相当于$OLDPWD内部变量.
=~
正则表达式匹配. 这个操作将会在version 3版本的Bash部分进行讲解.
^
行首. 在正则表达式中, "^"表示定位到文本行的行首.
控制字符
修改终端或文本显示的行为. . 控制字符以CONTROL + key这种方式进行组合(同时按下). 控制
字符也可以使用8进制或16进制表示法来进行表示, 但是前边必须要加上转义符.

控制字符在脚本中不能正常使用.
Ctl-B
退格(非破坏性的), 就是退格但是不删掉前面的字符.
Ctl-C
break. 终结一个前台作业.
Ctl-D
从一个shell中登出(与exit很相像).
“EOF”(文件结束). 这也能从stdin中终止输入.
在console或者在xterm窗口中输入的时候, Ctl-D将删除光标下字符. 当没有字符时, Ctl-
D将退出当前会话, 在一个xterm窗口中, 则会产生关闭此窗口的效果.
Ctl-G
“哔” (beep). 在一些老式的打字机终端上, 它会响一下铃.
Ctl-H
“退格”(破坏性的), 就是在退格之后, 还要删掉前边的字符.

 #!/bin/bash
 # Embedding Ctl-H in a string.

 a="^H^H" # 两个 Ctl-H's (backspaces).
 echo "abcdef" # abcdef
 echo -n "abcdef$a " # abcd f
 # Space at end ^ ^ 两次退格.
 echo -n "abcdef$a" # abcdef
 # 结尾没有空格没有 backspace 的效果了(why?).
 # 结果并不像期望的那样.
 echo; echo

Ctl-I
水平制表符.
Ctl-J
重起一行(换一行并到行首). 在脚本中, 也可以使用8进制表示法 – ‘\012’ 或者16进制
表示法 – ‘\x0a’ 来表示.
Ctl-K
垂直制表符.
当在console或者xterm窗口中输入文本时, Ctl-K将会删除从光标所在处到行为的全部字
符. 在脚本中, Ctl-K的行为有些不同, 具体请参见下边的Lee Maschmeyer的例子程序.
Ctl-L
清屏(清除终端的屏幕显示). 在终端中, 与clear命令的效果相同. 当发送到打印机上时,
Ctl-L会让打印机将打印纸卷到最后.
Ctl-M
回车.

 #!/bin/bash
 # Thank you, Lee Maschmeyer, for this example.

 read -n 1 -s -p $'Control-M leaves cursor at beginning of this
line. Press Enter. \x0d'
 # 当然, '0d'就是二进制的回车.
 echo >&2 # '-s'参数使得任何输入都不将回显出来.
 #+ 所以, 明确的重起一行是必要的.

 read -n 1 -s -p $'Control-J leaves cursor on next line. \x0a'
 # '0a' 等价于Control-J, 换行.
 echo >&2

 ###

 read -n 1 -s -p $'And Control-K\x0bgoes straight down.'
 echo >&2 # Control-K 是垂直制表符.

 # 关于垂直制表符效果的一个更好的例子见下边:

 var=$'\x0aThis is the bottom line\x0bThis is the top line\x0a'
 echo "$var"
 # 这句与上边的例子使用的是同样的办法, 然而:
 echo "$var" | col
 # 这将造成垂直制表符右边的部分比左边部分高.
 # 这也解释了为什么我们要在行首和行尾加上一个换行符 --
 #+ 这样可以避免屏幕显示混乱.

 # Lee Maschmeyer的解释:
 # --------------------------
 # 在这里[第一个垂直制表符的例子中] . . .
#+ 这个垂直制表符使得还没回车就直接打印下来.
 # 这只能在那些不能"后退"的设备中才行,
 #+ 比如说Linux的console.
 # 垂直制表符的真正意义是向上移, 而不是向下.
 # 它可以用来让打印机打印上标.
 # col工具可以模拟垂直制表符的正确行为.

 exit 0

Ctl-Q
恢复(XON).
在一个终端中恢复stdin.
Ctl-S
挂起(XOFF).
在一个终端中冻结stdin. (使用Ctl-Q可以恢复输入.)
Ctl-U
删除光标到行首的所有字符. 在某些设置下, 不管光标的所在位置Ctl-U都将删除整行输
入.
Ctl-V
当输入字符时, Ctl-V允许插入控制字符. 比如, 下边的两个例子是等价的:
1 echo -e ‘\x0a’
2 echo
Ctl-V主要用于文本编辑.
Ctl-W
当在控制台或一个xterm窗口敲入文本时, Ctl-W将会删除当前光标到左边最近一个空格间
的全部字符. 在某些设置下, Ctl-W将会删除当前光标到左边第一个非字母或数字之间的全
部字符.
Ctl-Z
暂停前台作业.
空白
用来分隔函数, 命令或变量. . 空白包含空格, tab, 空行, 或者是它们之间任意的组合体. [4]
在某些上下文中, 比如变量赋值, 空白是不被允许的, 会产生语法错误.
空行不会影响脚本的行为, 因此使用空行可以很好的划分独立的函数段以增加可读性.
特殊变量$IFS用来做一些输入命令的分隔符, 默认情况下是空白.
如果想在字符串或变量中使用空白, 那么应该使用引用.
注意事项
[1] PID, 或进程 ID, 是分配给运行进程的一个数字. 要想察看所有运行进程的PID可以使
用ps命令.
[2] The shell does the brace expansion. The command itself acts upon the result of
the expansion.
[3] 例外: 在pipe中的一个大括号中的代码段可能运行在一个 子shell中.

 ls | { read firstline; read secondline; }
 # 错误. 在大括号中的代码段, 将运行到子shell中,
 #+ 所以"ls"的输出将不能传递到代码块中.
 echo "First line is $firstline; second line is $secondline" # 不能工作.

 # 感谢, S.C.

[4] 一个换行符(“重起一行”)也被认为是空白符. 这也就解释了为什么一个只包含换行符的空
行也被认为是空白.