下图描述了stdin、stout、stderr和Shell命令的关系，Shell命令从标准输入读取输入数据，将输出送到标准输出，如果该命令在执行过程中发生错误，则将错误信息输出到标准错误输出
符号 意义
cmd1 | cmd2 管道符，将cmd1的标准输出作为cmd2的标准输入
> filename 将标准
输出写到文件filename之中
< filename 将文件filename的内容
读入到标准输入之中
>> filename 将标准输出写到文件filename之中，若filename文件已存在，则将标准输出
追加到filename已有内容之后
>| filename 即使noclobber选项已开启，仍然强制将
标准输出写到文件filename之中，即将f
ilename文件覆盖掉
n>| filename 即使noclobber选项已开启，仍然强制将FD为n的
输出写到文件filename之中，即将filename文件覆盖掉
n> filename 将FD为n的输出写到文件filename之中
n< filename 将文件filename的内容读入到FD n之中
n>> filename 将FD为n的输出写到文件filename之中，若filename文件已存在，则将FD为n的输出追加到filename已有内容之后
<<delimiter 此处文档（Here-document）
注意：cat和>符号结合成为简易文本编辑器
cat后不加
任何参数时，cat命令的输入：标准输入，即键盘输入
利用I/O重定向符号“>”将键盘输入写入文件
cat > newfile：可输入需要写到newfile的内容，最后按CTRL+D结束对newfile的编辑
>>：用于在已有文件后追加一些文本
>|符：强制覆盖文件的符号，它与Shell的noclobber选项有关系，如果noclobber选项开启，表示不允许覆盖任何文件，而>|符号则可以不管noclobber选项的作用，强制将文件覆盖
重定向标准错误输出，需要使用文件标识符2
2> newfile
<是I/O重定向的输入符号，它可将文件内容写到标准输入之中
例10-20
<<delimiter符号称为此处文档（Here-document），delimiter称为分界符，该符号表明：Shell将分界符delimiter之后直至下一个delimiter之前的所有内容作为输入
exec命令可以通过
文件标识符打开或关闭文件，也可
将文件重定向到标准输入，及将
标准输出重定向到文件
execin.sh脚本使用exec将stdin重定向到文件：
#!/bin/bash
exec 8<&0 //将标准输入重定向到文件8中
exec < hfile //将hfile的内容读入标准输入中 分别为a ，b变量
read a
read b
echo "---------------------------"
echo $a
echo $b
echo "Close FD 8:"
exec 0<&8 8<&-
//将文件8的内容拷贝到标准输入 然后将8文件关闭
echo -n "Pls. Enter Data:"
read c //标准输入中读入c
echo $c
execout.sh脚本将stdout重定向到文件
#!/bin/bash
exec 8>&1 //将文件8的内容拷贝到标准输出
exec > loggg //将标准输出的内容拷贝到loggg文件
echo "Output of date command"
date //时间
echo "Output of df command"
df
exec 1>&8 8>&- //将标准输出的内容拷贝到文件8 ，关闭文件8
echo "--------------------------------"
echo "Output of date command"
date
echo "Output of df command"
df
符号 意义
n>&m 将FD为m的输出拷贝到FD为n的文件
n<&m 将FD为m的输入拷贝到FD为n的文件
n>&- 关闭FD为n的输出
n<&- 关闭FD为n的输入
&>file 将标准输出和标准错误输出重定向到文件
代码块重定向：指在代码块内将
标准输入或标准输出重定向到文件，而在
代码块之外还是保留默认状态
代码块重定向是指对标准输入或标准输出的重定向
只在代码块内有效
可以重定向的代码块可以是while、until、for等循环结构，也可以是if/then测试结构，甚至可以是函数
代码块
输入重定向符号是
<，
输出重定向符号是
>
rewhile.sh脚本演示while循环的重定向：
#!/bin/bash
ls /etc > loggg //输出重定向
while [ "$filename" != "rc.d" ]; do
read filename
let "count +=1"
done
< loggg //从logg中读取文件名
echo "$count times read"
echo -n "-----Pls. Input Data:-----"
read test
echo $test
refor.sh脚本演示for循环的重定向：
#refor.sh脚本：for循环的重定向
#!/bin/bash
#将ls /etc的结果写到loggg文件中
ls /etc > loggg
#计算loggg文件的最大行数，并赋给maxline变量
#这是与while和until循环最大的区别
#灵活运用了输入重定向符号<，类似用法可以参见图10-25的例子
maxline=$(wc -l < loggg)
#搜索loggg文件中与rc.d所匹配的行，输出匹配行的行数
for filename in `
seq $maxline` #利用
seq命令产生循环参数 $取值
do
read filename #按行读取loggg中的数据
#let "count +=1"
#for循环中需要有if语句指定跳出循环的条件
if [ "$filename" = "rc.d" ]
then
break
else
let "count +=1"
fi
done < loggg #将标准输入重定向到loggg文件
echo "$count times read"
#测试循环体外面的标准输入是否被重定向
echo -n "-----Pls. Input Data:-----"
read test
echo $test
代码块重定向在一定程度上增强了Shell脚本处理文本文件的灵活性，它可以让一段代码很方便地处理一个文件（只要将该文件输入重定向到该代码块）
命令行处理
命令行处理解释了Shell如何处理一个命令的内部机制
Shell从标准输入或脚本读取的
每一行称为管道（pipeline），每一行包含一个或多个命令，这些命令用管道符隔开，Shell对
每一个读取的管道都按照下面的步骤处理：
1、将命令分割成令牌（token），令牌之间以
元字符分隔，Shell的元字符集合是固定不变的，包括
空格、Tab键、换行字符、分号（;）、小括号、输入重定向符（<）、输出重定向符（>）、管道符（|）和&符号，令牌可以是
单词（word）、关键字，也可以是
I/O重定向器和
分号。
2、检查命令行的第一个令牌是否为
不带引号或反斜杠的关键字，如果此令牌是开放关键字，开放关键字指if、while、for或其他控制结构中的开始符号，Shell就认为此命令是复合命令，并为该复合命令进行
内部设置，读取下一条命令，再次
启动进程。如果此令牌不是复合命令的开始符号，如该令牌是then、else、do、fi、done等符号，这说明该令牌不应该处在命令行的首位，因此，Shell提示语法错误信息。
3、检查命令行的第一个令牌是否为
某命令的别名，这需要将此令牌与别名（alia）列表逐个比较，如果匹配，说明该令牌是别名，则将该
令牌替换掉，
返回步骤1，否则进入步骤4。这种机制允许别名递归，也允许定义关键字别名，比如可以用下面命令定义while关键字的别名when。
alias when=while
4、执行大括号展开，比如h{a,i}t展开为hat或hit。
5、将单词开头处的波浪号（~）替换成用户的根目录$HOME。
6、将任何开头为$符号的表达式，执行变量替换。
7、将反引号内的表达式，执行命令替换。
8、将$((string))的表达式进行算术运算。
9、从变量、命令和算术替换的
结果中取出命令行，再次进行单词切分，与步骤1不同的是，此时
不再用元字符分隔单词，而是使用$IFS分隔单词。
10、对于*、?、[…]等符号，执行
通配符展开，生成文件名。
11、将第一个单词作为命令，它可以是函数、内建命令和可执行文件。
12、在完成I/O重定向与其他类似事项后，执行命令。
eg: echo ~/i* $PWD `echo Yahoo Hadop` $((21*20)) > output
1、Shell首先将
命令行分割成令牌，分割成的令牌如下，我们在命令行下方用数字标出各个令牌：
echo ~/i* $PWD `echo Yahoo Hadop` $((21*20))
|--1-||--2-| |--3---| |---------4-------------| |-----5-----|
需要注意的是，重定向
>output虽已被识别，但是它
不是令牌，Shell将在后面
对I/O重定向进行处理。
2、检查第一个单词echo是否为关键字，显然echo不是开放关键字，所以命令行继续下面的判断。
3、检查第一个单词echo是否为别名，echo不是别名，命令行继续往下处理。
4、扫描命令行是否需要大括号展开，这条命令没有大括号，命令行继续往下处理。
5、扫描命令行是否需要波浪号展开，命令行中存在波浪号，令牌2将被修改，命令行变为如下形式：
echo /root/i* $PWD `echo Yahoo Hadop` $((21*20))
|--1-||----2---| |--3---| |---------4-------------| |-----5-----|
6、扫描命令行中是否存在变量，若存在变量，则进行变量替换，该命令行中存在环境变量PWD，因此，令牌3将被修改，命令行变为如下形式：
echo /root/i* /root `echo Yahoo Hadop` $((21*20))
|--1-||----2---| |--3-| |---------4-------------| |-----5-----|
7、扫描命令行中是否存在反引号，若存在则进行命令替换，该命令行存在命令替换，因此，令牌4将被修改，命令行变为如下形式：
echo /root/i* /root Yahoo Hadop $((21*20))
|--1-||----2---| |--3-| |-------4-------| |-----5-----|
8、执行命令行中的算术替换，令牌5将被修改，命令行变为如下形式：
echo /root/i* /root Yahoo Hadop 420
|--1-||----2---| |--3-| |-------4-------| |-5-|
9、Shell将对前面所有展开所产生的结果进行再次扫描，依据$IFS变量值对结果进行单词分割，形成如下形式的新命令行：
echo /root/i* /root Yahoo Hadop 420
|--1-||----2---| |--3-| |--4---| |---5--| |-6-|
由于$IFS是空格，因此，命令行被分割为6个令牌，Yahoo Hadop被分成两个令牌。
10、扫描命令行中的
通配符，并展开，该命令行中存在通配符*，展开后，命令行变为如下形式：
echo /root/indirect.sh /root/install.log /root/install.log.syslog /root Yahoo Hadop 420
|--1-||--------2---------| |--------3-------| |---------4----------------| |--5-| |---6--| |---7--| |-8-|
i*展开为当前目录下所有以i开头的文件，该目录下有三个i开头的文件：indirect.sh、install.log和install.log.syslog，因此，令牌2又被分为令牌2、3和4。
11、此时，Shell已经准备执行命令了，它寻找echo，echo是内建命令。
12、Shell执行echo命令，此时执行
>output的I/O重定向，再调用
echo命令，显示最后参数。
命令行处理流程图的左侧跳转箭头从执行命令步骤跳转到初始步骤，这正是
eval命令的作用
eval命令将其
参数作为命令行，
让Shell重新执行该命令行，
eval的参数再次经过Shell命令行处理的12个步骤
eval在处理简单命令时，与直接执行该命令无甚区别
演示了eval执行复杂命令：
#!/bin/bash
while read NAME VALUE
do
eval "${NAME}=${VALUE}"
#${NAME}=${VALUE}
done <evalsource
echo "var1=$var1"
echo "var2=$var2"
echo "var3=$var3"
echo "var4=$var4"
echo "var5=$var5"
其中
evalsource：
var1 APPLE
var2 BAIDU
var3 CAMEL
var4 DOT
var5 EMUL
var1 APPLE 最后的效果是：
$var1=APPLE
evalre.sh脚本关键语句
eval “${NAME}=${VALUE}”，第1轮结束后命令变为： var1=APPLE；再次将该命令提交到Shell，成功实现var1变量的赋值
evalre.sh脚本还使用了代码块重定向，实现对evalsource文件的遍历
pipe变量赋为管道符， ls $pipe wc -l发生错误：第1步扫描没有发现有管道符，直到
第6步变量替换之后命令行才变成ls | wc -l，第9步根据$IFS变量将命令行重新
分割成4个令牌，第11步将ls当作命令，后面的3个令牌|、wc和-l被解析为ls命令的参数，由于该目录下没有|和wc等文件或目录，因此，Shell报语法错误
eval ls $pipe wc –l正确执行，第1轮的结果，ls | wc -l命令行被重新提交到Shell
---------------------------------------------------------------------------------------
30 19 * * * /usr/bin/**dcon.sh > /dev/null 2>&1
59 23 * * 1-7 /home/s**-log/squid-log.renew > /dev/null 2>&1
50 1 * * 1-7 /usr/local/src/**log.sh > /dev/null 2>&1
20 2 * * 1-7 /home/sq**-log/**log > /dev/null 2>&1
30 2 * * 1-7 /home/sq**-log/**log.01
30 22 * * * /bin/**sync > /dev/null 2>&1
00 8 * * 1-7 /home/**-log/rmcore > /dev/null 2>&1
00 16 * * 1-7 /home/**-log/rmcore > /dev/null 2>&1
他问我为什么要用 /dev/null 2>&1 这样的写法.这条命令的意思是将标准输出和错误输出全部重定向到/dev/null中,也就是将产生的所有信息丢弃.下面我就为大家来说一下, command > file 2>file 与command > file 2>&1 有什么不同的地方.
首先~command > file 2>file 的意思是将命令所产生的标准输出信息,和错误的输出信息送到file 中.command > file 2>file 这样的写法,stdout和stderr都直接送到file中, file会被打开两次,这样stdout和stderr会互相覆盖,这样写相当使用了FD1和FD2两个同时去抢占file 的管道.
而command >file 2>&1 这条命令就将stdout直接送向file, stderr 继承了FD1管道后,再被送往file,此时,file 只被打开了一次,也只使用了一个管道FD1,它包括了stdout和stderr的内容.
从IO效率上,前一条命令的效率要比后面一条的命令效率要低,所以在编写shell脚本的时候,较多的时候我们会用command > file 2>&1 这样的写法.
