下图描述了stdin、stout、stderr和Shell命令的关系，Shell命令从标准输入读取输入数据，将输出送到标准输出，如果该命令在执行过程中发生错误，则将错误信息输出到标准错误输出
符号 意义
cmd1 | cmd2 管道符，将cmd1的标准输出作为cmd2的标准输入
> filename 将标准输出写到文件filename之中
< filename 将文件filename的内容读入到标准输入之中
>> filename 将标准输出写到文件filename之中，若filename文件已存在，则将标准输出追加到filename已有内容之后
>| filename 即使noclobber选项已开启，仍然强制将标准输出写到文件filename之中，即将filename文件覆盖掉
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 这样的写法.