Shell 快速入门

Shell 快速入门（零）：目录

Shell 快速入门定位于快速帮助初学者掌握 Shell 的语法，快速编写 Shell 脚本。对于 Shell 学习者来说，应该将 Shell 当成是工具，掌握了基础的语法之后就直接使用。当后面需要一些更高级的语法或者功能时，再去查找相应的资料。

这个系列与其他 Shell 入门教程不同的是：这个系列专注于用最少的知识，让你快速掌握必须的语法，最终实现快速上手的目的。所以在很多地方，我们并不追求大而全，而是追求实用。

如果你只是想简单掌握如何使用 Shell，那么你只看前 15 篇就够了。

Shell 快速入门（零）：目录
Shell 快速入门（一）：基础概念
Shell 快速入门（二）：环境搭建
Shell 快速入门（三）：文件结构
Shell 快速入门（四）：如何运行shell脚本
Shell 快速入门（五）：如何标记语句的结束
Shell 快速入门（六）：基本数据类型
Shell 快速入门（七）：变量的使用
Shell 快速入门（八）：如何打印字符串
Shell 快速入门（九）：如何进行数学运算
Shell 快速入门（十）：如何进行数值比较
Shell 快速入门（十一）：如何进行字符串比较
Shell 快速入门（十二）：选择结构怎么写
Shell 快速入门（十三）：循环结构怎么写
Shell 快速入门（十四）：函数的使用
在这之后的文章，作为 Shell 快速入门的补充。当你需要使用更加高级的语法时，你可以来这里看看有没有对应的例子。这个系列会根据情况不断地增加，如果你觉得有很好的文章要补充，也欢迎一起完善。

Shell 快速入门（十五）：输出重定向

Shell 快速入门（一）：基础概念

说起 Shell 语言，其实很多人习惯的叫法是叫做 Shell 脚本。或许你在还没学习之前就听说过，Shell 脚本、Shell 语言、Shell 环境等等名词。但是它们到底是什么，它们之间有什么区别？下面我们就逐个来解答一下。

Shell
我们知道对于所有计算机设备来说，它们都是由 CPU、内存、硬盘等硬件做成的。但是单单有这些硬件，我们还没办法使用，因为我们不知道怎么和这些冷冰冰的硬件沟通。

为了让这些硬件听懂我们的话，计算机的先辈们费尽了九牛二虎之力，写了一个程序来把我们的话翻译给机器听。这个翻译程序可厉害了，只要你输入具体的命令，它就会把它翻译给机器听，这样你就可以和机器沟通了。例如，我们输入ifconfig可以查看 IP 地址，翻译程序就会将这条命令翻译给硬件，告诉它我们要查看 IP 地址。其实这里的翻译程序就是 Shell，而具体的命令就是Linux命令。

简单地说，Shell 就是一套位于硬件和用户之间的程序，我们一般称之为解释器。

Shell语言
有了 Shell 这个解释器，硬件就能听懂我们输入的命令了。但当我们要做一些复杂的逻辑操作时，例如筛选出占用 CPU 最高的进程ID。这时候就不仅仅只是一个命令那么简单了，我们需要进行逻辑判断等一系列操作。

所以说 Shell 语言就是一系列语言规范的集合，只要你按照这些规范将你的 Linux 命令组合起来，那么 Shell 就可以正确解析出你的意图。

简单地说，Shell 语言其实就是一系列的语法规范。

Shell 脚本
简单地说，由 Linux 命令和 Shell 语言规范组成而成的一系列字符，我们就称之为 Shell 脚本。

Shell 环境
Unix 类系统经过了长时间的发展，衍生出了很多不同的版本，这些不同版本的 Shell 不太一致，其支持的 Linux 命令有有所不同。现存的 Shell 有下面这几个：

Bourne Again Shell（/bin/bash）
Bourne Shell（/usr/bin/sh或/bin/sh）
C Shell（/usr/bin/csh）
K Shell（/usr/bin/ksh）
所以说 Shell 环境就是指的就是拥有这些 Shell 的环境。在这些 Shell 环境中，Bash 由于易用和免费，在日常工作中被广泛使用。同时，Bash 也是大多数Linux 系统默认的 Shell。

关于概念就解释到这里了，下一小节我们介绍如何搭建学习 Shell 语言的环境。

Shell 快速入门（二）：环境搭建

对于使用 Mac OSX 系统或者 Linux 系统的朋友来说，因其自带了基本的 Shell 环境，我们无需做任何操作即可进行 Shell 脚本的编写。但在 Windows 系统中，要运行 Shell 脚本，则需要做一些额外的工作。

在 Windows 中运行 Linux 命令，我们可以通过 GitHub 提供的一个 Git For Windows 软件来实现。首先到下面的地址下载合适的版本：

Git for Windows

下载成功后直接按照默认安装。默认安装成功，在桌面或任何文件目录中，点击右键菜单中会有Git Bash Here选项。

点击Git Bash Here之后会打开命令行窗口，在窗口中就可以运行 Linux 命令。

虽然在 Windows 下也可以通过这种方式运行 Shell 脚本，但是总归不方便。所以有条件的话还是直接在 Unix 系统中进行 Shell 语言学习吧。

下一小节，我们讲讲 Shell 脚本的文件结构。

Shell 快速入门（三）：文件结构

一个 Shell 脚本都以.sh为文件名后缀，并且其文件结构都有一定的特点。一个标准的 Shell 脚本组成结构如下：

文件标识。第一行的#!是一个特殊标记（一般称为Hashbang），标识该 Shell 脚本将使用/bin/bash这个 Shell 对这个文件内容进行解析。
文件注释。这部分是对这个文件业务逻辑的注释，一个好的注释可以让别人一眼看懂该文件的目的。
Shell代码。这部分就是具体的业务代码了。

#!/bin/bash
# author:陈树义
# site:http://shuyi.me
echo "Hello Shell"

在注释部分，建议分为两个部分：

顶层注释。顶层注释主要是对其内容进行简要概述。版权声明和作者信息是可选的。例如：

#!/bin/bash
#
# 备份数据库User表

功能注释。其他人通过阅读注释就能够学会如何使用你的程序或库函数，而不需要阅读代码。例如：

#######################################
# 连接指定数据数据库
# 全局变量:
#   BACKUP_DIR
#   ORACLE_SID
# 参数:
#   None
# 返回值:
#   None
#######################################
connect(){

}

综合以上的建议，整理了一个 Shell 脚本的文件结构范例。下次你要写 Shell 脚本的时候可以直接拷贝过去，修改相关注释以及函数名就可以，即规范又简便。

#!/bin/bash
#
# 备份数据库User表

#######################################
# 连接指定数据数据库
# 全局变量:
#   BACKUP_DIR
#   ORACLE_SID
# 参数:
#   None
# 返回值:
#   None
#######################################
connect(){
}

Shell 快速入门（四）：如何运行shell脚本

运行 Shell 脚本有两种方式，一种是通过 bash 命令，一种是作为可执行程序执行。

我们写了下面这样一个 Shell 脚本，并将其保存为hello.sh：

#!/bin/bash
echo "Hello Shell."

如果我们用bash命令运行，那么是这样的：bash hello.sh。

运行后会输出：Hello Shell。

如果想用可执行程序方式运行，那么需要先修改文件的权限，使其具有执行权限，之后再执行脚本。

chmod +x ./hello.sh  #使脚本具有执行权限
./hello.sh  #执行脚本

同样地，运行后会输出：Hello Shell。

Shell 快速入门（五）：如何标记语句的结束

在 Shell 中标记语句的结束有两种方式：分号和换行。

例如下面的 Shell 脚本：

a=10
if [ $a = 10 ]; then 
  echo "the value of a is 10"
fi

也可以写成：

a=10
if [ $a = 10 ]
then 
  echo "the value of a is 10"
fi

即上面将 if 表达式后面的分号换成换行符了。但是不推荐这种写法，因为这样不利于阅读。因为最好的阅读方式就是 if 和 fi 对齐，中间是执行的语句，就像上面一开始的例子一样。

Shell 快速入门（六）：基本数据类型

Shell 语言是一门弱类型的语言，它并没有数据类型上的概念。无论你输入的是字符串、数字，在 Shell 中都按照字符串类型来存储。至于具体是什么类型，Shell 根据上下文去确定。 例如下面当你尝试对一个字符串进行加一操作时，Shell 运行时便会报错。

#!/bin/bash
num="Hello"
echo `expr $num + 1`	//expr: not a decimal number: 'Hello'
num=1
echo `expr $num + 1`	//2

这是因为虽然 Shell 语言是弱语言类型，但其解释执行的时候会进行语法检查。意识到 Shell 在数据类型上的特殊性很重要，这样你就不会犯一些基础错误了。例如下面的例子：

result="false"
if $result
then
	echo "true."
else 
	echo "false."	# 输出false
fi

虽然上面的 result 变量是一个字符串，但是实际上在运行时，Shell 是将其当成一个布尔型的值进行比较的。当你将 result 改成 true 之后，结果便会输出 true。

Shell 快速入门（七）：变量的使用

因为 Shell 语言是一门弱语言类型，所以变量可以无须定义便可直接使用。在 Shell 语言中，引用变量有几种方式。

第一种，直接使用 $ 符号引用。

str="Hello"
echo $str	//Hello

第二种，使用 ${} 符号引用。

str="Hello"
echo ${str} //Hello

一般来说，如果不会引起变量的阅读困难，那么可以使用第一种变量引用方式。但如果在较为复杂的环境，会引起阅读和理解困难，那还是使用第二种引用方式。例如：

#!/bin/sh
echo "What is your name?"
read USER_NAME
echo "Hello $USER_NAME"
echo "I have create an email [email protected] for you"

上面的例子非常简单，输入你的名字，为你创建一个邮箱。虽然上面的例子能正常运行，但是却不易阅读。特别最后一行，你需要很仔细端详，才知道原来是引用了$USE{R}_{N}AME这个变量，而不是引用了$[email protected]这个变量。在这种情况下，使用花括号来引用变量是更为合适的：

#!/bin/sh
echo "What is your name?"
read USER_NAME
echo "Hello $USER_NAME"
echo "I have create an email ${USER_NAME}@gmail.com for you"

虽然说我们可以加上大括号，或者不加，但是业界统一的规范还是加上大括号。因为这样比较统一，便于阅读。因此树义也建议大家使用第二种方式，即使用加上大括号的方式。

Shell 快速入门（八）：如何打印字符串

在 Shell 脚本中，我们可以使用 echo 命令或者 printf 命令来打印字符串。echo 适合用于简单的打印，而 printf 则适用于统一缩进的复杂打印。

echo命令
在 Shell 语言中，一般使用 echo 命令来打印字符串。而 echo 命令后面跟着的字符串有好几种形式：裸奔、单引号、双引号。

第一种，裸奔。

所谓裸奔就是后面什么引用符号都不用加，直接写上要输出的字符串。

echo Hello, My Name is chenshuyi!

这种方式会直接输出 echo 命令后的所有字符，例如上面会输出：Hello, My Name is chenshuyi!。但这种方式有个缺陷，就是无法输出分号;。因为当读到分号的时候，程序会认为这一行代码结束了。

echo Hello; I am chenshuyi
上面的命令的输出结果是：

Hello
-bash: I: command not found

可以看到程序只输出了 Hello，并把后面的I当成了一个命令。

第二种，单引号的引用方式。

str='Hello ! My Name is chenshuyi';
echo $str

上面的语句成功输出：Hello ! My Name is chenshuyi。但这种方式的缺陷是无法在字符串中引用变量。

NAME="chenshuyi"
str='Hello ! My Name is $NAME';
echo $str

上面的输出结果是：Hello ! My Name is $NAME。可以看到我们无法打印出 NAME 变量的值。

第三种，双引号的引用方式。

NAME="chenshuyi"
str="Hello! My Name is $NAME";
echo $str

输出结果：Hello! My Name is chenshuyi。可以看到在双引号的引用方式下，我们可以成功打印出 NAME 变量的值。但是这种方式也有其缺陷，就是无法直接打印出特殊字符，需要把特殊进行转义。

简单地说：如果你打印的语句没有任何变量，那么直接和特殊字符，直接裸奔也未尝不可。但如果有一些特殊字符，那么使用单引号可能更好。如果又有特殊字符，又需要引用变量，那么只能使用双引号了。

printf命令
使用 printf 命令可以对齐打印字符串，对于阅读比较友好。

#!/bin/bash
# author:陈树义
# site:www.shuyi.me
 
printf "%-10s %-8s %-4s\n" 姓名 年龄 存款K  
printf "%-10s %-8s %-4.2f\n" 郭靖 30 52.20
printf "%-10s %-8s %-4.2f\n" 杨过 25 26.32
printf "%-10s %-8s %-4.2f\n" 郭芙 27 15.20

在这样一个符号中%-10s，百分号是个标识符，-表示左对齐，数字10表示保留10位的长度，s表示其实一个字符串。

对应的%-8s表示左对齐、保留 8 位，是字符串。
对应的%-4.2f表示左对齐、保留 4 位、小数点保留两位，是个浮点型数字。
在 printf 中的格式替代符一共有下面四个：

d: Decimal 十进制整数
s: String 字符串
c: Char 字符
f: Float 浮点

Shell 快速入门（九）：如何进行数学运算

在 Shell 中进行数据运算是一件很头疼的事情，因为 Shell 的数学运算和我们高级语言中的语法完全不一样。例如在 Java 中下面一个简单的算术：

int a = 10 + 5;

你以为是这么写的：

#!/bin/bash
a=10+5
echo $a

但实际上上面的输出是：10+5。我们在第四小节的时候说过，Shell 中把所有东西都当成是一个字符串，所以这里它并不知道我们要它进行数学运算。实际上在 Shell 中你要进行这样的数学运算，你应该这么写：

#!/bin/bash
a=`expr 10 + 5`
echo $a

当然了，你还可以这么写：

#!/bin/bash
let a=10+5
echo $a

这两种方式都可以实现简单的数学运算。但相比这两种，我更推荐用下面这种形式：

(( a = 10 + 5 ))
echo $a

即将需要运算的内容放在两对中括号里面。因为这种方式更加简洁，并且功能也是最为完整，也是最为接近高级语言的写法。

Shell 快速入门（十）：如何进行数值比较

学会了如何进行数学运算，但怎么进行数值运算呢。在 Java 中，我们进行数值运算是这样的：

int a = 15;
int b = 10;
if (a >= b){
  System.out.println("a > b");
} else {
  System.out.println("a < b");
}

但在 Shell 中，如果你写成下面这样：

#!/bin/bash
a=15
b=10
if [ $a >= $b ]
then 
  echo "a >= b"
else
  echo "a < b"
fi

运行结果会报错：-bash: [: a: unary operator expected。这是因为 Shell 无法识别 >= 这个符号。但如果我们使用下面这种形式，我们就可以顺利执行了。

#!/bin/bash
a=15
b=10
if (( a >= b ))
then 
  echo "a >= b"
else
  echo "a < b"
fi

没错，用的就是和数学运算一样的两对括号。将需要运算的表达式放在这里面，Shell 就会计算出一个最终的结果，true 或者 false。在括号中的表达式与我们用 Java 等高级语言的语法非常一致，我们可以使用 && 或者 || 符号，非常方便。

#!/bin/bash
a=15
if (( a > 10 && a < 20 ))
then 
	echo "10 < a < 20"	
else
	echo "a <= 10 or a >= 20"
fi

输出结果：10 < a < 20。

Shell 快速入门（十一）：如何进行字符串比较

在 Shell 中进行字符串比较有专门的六个操作符，他们分别是：

=：检测两个字符串是否相等，相等返回 true。
!=：检两个字符串是否相等，不相等返回 true。
-z：检测字符串长度是否为0，为 0 返回 true。
-n：检测字符串长度是否为0，不为 0 返回 true。
str：检测字符串是否为空，不为空返回 true。
要记得操作符左右两边都要加空格，否则会报语法错误。

这六个操作符可以进行字符串的非空比较，长度比较，相等比较等。下面的这个例子完整列出了这六个字符串操作符的使用方法：

#!/bin/bash
# author:陈树义
# site:http://www.shuyi.me

a="abc"
b="efg"
# 字符串是否相等
if [ $a = $b ]
then
   echo "$a = $b : a 等于 b"
else
   echo "$a = $b: a 不等于 b"
fi
if [ $a != $b ]
then
   echo "$a != $b : a 不等于 b"
else
   echo "$a != $b: a 等于 b"
fi
# 字符串长度是否为0
if [ -z $a ]
then
   echo "-z $a : 字符串长度为 0"
else
   echo "-z $a : 字符串长度不为 0"
fi
if [ -n "$a" ]
then
   echo "-n $a : 字符串长度不为 0"
else
   echo "-n $a : 字符串长度为 0"
fi
# 字符串是否为空
if [ $a ]
then
   echo "$a : 字符串不为空"
else
   echo "$a : 字符串为空"
fi

输出结果为：

abc = efg: a 不等于 b
abc != efg : a 不等于 b
-z abc : 字符串长度不为 0
-n abc : 字符串长度不为 0
abc : 字符串不为空

Shell 快速入门（十二）：选择结构怎么写

与其他语言一样 Shell 也有 IF-ELSE 以及 IF-ELSE-IF-ELSE 的选择结构。

IF ELSE 结构
Shell 语言中的 IF - ELSE 选择结构语法格式如下：

if condition
then
    command1 
    command2
    ...
    commandN
else
    command
fi

例如：

a=10
b=10
if [ $a = $b ]
then
  echo "a equals b"	# 输出这里
fi

IF ELSE-IF ELSE 结构
Shell 语言中的 IF ELSE-IF ELSE 结构语法格式如下：

if condition1
then
    command1
elif condition2 
then 
    command2
else
    commandN
fi

例如：

a=9 
if [ $a = 10 ]
then
  echo "a == 10"
elif [ $a -lt 10 ]
then
  echo "a < 10"	# 输出这里
else 
  echo "a > 10"
fi

特别需要注意的是 if 后面的表达式，其左右两边都要留有一个空格，这是 Shell 的语法。如果没有空格，那么 Shell 执行的时候会报错。例如下面的 Shell 就会报错：

a=10 
if [$a = 10 ]
then
  echo "a is $a"
fi

执行之后，输出错误：-bash: [9: command not found。出错原因就是因为在 if 后面的表达式$a前面少了一个空格。

Shell 快速入门（十三）：循环结构怎么写

Shell 中的循环结构有 for、while、until、case 这四种，但是 while 和 until 的作用基本类似，所以我们重点关注 for、while、case 这三种循环结构即可。

for 循环结构
for 循环结构的语法如下：

for var in item1 item2 ... itemN
do
    command1
    command2
    ...
    commandN
done

例如，顺序输出当前列表中的数字：

for loop in 1 2 3 4 5
do
  echo "The value is: $loop"
done

输出结果：

The value is: 1
The value is: 2
The value is: 3
The value is: 4
The value is: 5

例如，顺序输出字符串中的字符：

for str in 'This is a string'
do
  echo $str
done

输出结果：

This is a string

while 循环结构
whie 循环结构语法格式如下：

while condition
do
    command
done

以下是一个基本的while循环，测试条件是：如果 a 小于等于5，那么条件返回真。int 从 0 开始，每次循环处理时，int 加 1。运行上述脚本，返回数字 1 到 4，然后终止。

#!/bin/sh
a=1
while [ $a -lt 5 ]
do
    echo $a
    let "a++"
done

运行脚本，输出：

1
2
3
4

使用中使用了 Bash let 命令，它用于执行一个或多个表达式，变量计算中不需要加上 $ 来表示变量。

那如果我要实现一个无线循环呢？

#!/bin/bash
a=1
while true
do
  echo "infinite loop $a"
  ((a++))
done

运行上面的程序，记得按下ctrl+c结束掉。

case 语句
Shell case 语句为多选择语句。可以用case语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令。case语句格式如下：

case 值 in
模式1)
    command1
    command2
    ...
    commandN
    ;;
模式2）
    command1
    command2
    ...
    commandN
    ;;
*)
	  command1
    ....
    commandN
	  ;;
esac

case 语句取值后面必须为单词 in，每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后，其间所有命令开始执行直至 ;;。取值将检测匹配的每一个模式。一旦模式匹配，则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式，使用星号 * 捕获该值，再执行后面的命令。case 语句使用 esac 作为结束标志。

下面的脚本提示输入1到4，与每一种模式进行匹配：

#!/bin/bash
echo '输入 1 到 4 之间的数字:'
echo '你输入的数字为:'
read aNum
case $aNum in
    1)  echo '你选择了 1'
    ;;
    2)  echo '你选择了 2'
    ;;
    3)  echo '你选择了 3'
    ;;
    4)  echo '你选择了 4'
    ;;
    *)  echo '你没有输入 1 到 4 之间的数字'
    ;;
esac

温馨提示：将上面的文本保存为一个 shell 脚本运行，直接复制到命令行运行会出错。

输入不同的内容，会有不同的结果，例如：

输入 1 到 4 之间的数字:
你输入的数字为:
3
你选择了 3

跳出循环
在循环过程中，有时候需要在未达到循环结束条件时强制跳出循环，Shell使用两个命令来实现该功能：break 和 continue。

break 命令允许跳出所有循环，这将终止执行后面的所有循环。

下面的例子中，脚本进入死循环直至用户输入数字大于5。要跳出这个循环，返回到shell提示符下，需要使用break命令。

#!/bin/bash
while true
do
    echo -n "输入 1 到 5 之间的数字:"
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你输入的数字为 $aNum!"
        ;;
        *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
            break
        ;;
    esac
done

执行以上代码，输出结果为：

输入 1 到 5 之间的数字:3
你输入的数字为 3!
输入 1 到 5 之间的数字:7
你输入的数字不是 1 到 5 之间的! 游戏结束
continue
continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。

对上面的例子进行修改：

#!/bin/bash
while :
do
    echo -n "输入 1 到 5 之间的数字: "
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你输入的数字为 $aNum!"
        ;;
        *) echo "你输入的数字不是 1 到 5 之间的!"
            continue
            echo "游戏结束"
        ;;
    esac
done

运行代码发现，当输入大于5的数字时，该例中的循环不会结束，语句 echo 「游戏结束」永远不会被执行。

Shell 快速入门（十四）：函数的使用

Linux Shell 可以用户定义函数，然后在shell脚本中可以随便调用。

函数定义
Shell 中的函数定义与 JavaScript 类似，格式如下：

function hello()
{
    echo "Hello SHell.";
	  return 1;
}
echo "method begin..."
hello
echo "method end..."

输出结果：

method begin...
Hello SHell.
method end...

上面定义了一个名为 hello 的函数，并返回了一个整数。

在 Shell 中，参数返回可以显示加 return 返回。如果不加，将以最后一条命令运行结果，作为返回值。返回值只能正整数，并且范围在 0 - 255。

函数参数
在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 $n 的形式来获取参数的值，例如，$1表示第一个参数，$2表示第二个参数…

带参数的函数示例：

funWithParam(){
    echo "第一个参数为 $1 !"
    echo "第二个参数为 $2 !"
    echo "第十个参数为 $10 !"
    echo "第十个参数为 ${10} !"
    echo "第十一个参数为 ${11} !"
    echo "参数总数有 $# 个!"
    echo "作为一个字符串输出所有参数 $* !"
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73

输出结果：

第一个参数为 1 !
第二个参数为 2 !
第十个参数为 10 !
第十个参数为 34 !
第十一个参数为 73 !
参数总数有 11 个!

作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !

注意，$10不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。

另外，还有几个特殊字符用来处理参数：

[image:B92B80B9-81E1-4760-8153-0FEDD6F34A32-315-000099F2DAFA9951/E57EB315-DFE4-4D10-AF30-E42268F31FEA.png]

Shell 快速入门（十五）：输出重定向

在写 Shell 脚本的时候，我们经常会想将命令的输出结果保存到文件中，或者将命令的执行结果保存到日志记录中。这时候就需要把命令的输出结果重定向。而要进行重定向，就要了解 Linux 的输入输出流。

在 Linux 中有三个经常用到的输入输出流，他们分别是：

标准输入（stdin）
标准输出（stdout）
标准错误（stderr）
在 Linux 系统中，系统保留了 0（标准输入）、1（标准输出）、2（标准错误） 三个文件描述符分别代表它们。

标准输入指的是从键盘这些标准输入设备读取到的数据。一般情况下标准输入重定向的很少用到，因此我们就不展开说。

标准输出则是通过屏幕输出的这些数据。我们可以通过标准输出重定向来让数据保存到文件里。例如：

YuRongChandeMacBook-Pro:chenshuyi yurongchan$ echo "hello shell, I'm shuyi" > out.txt
YuRongChandeMacBook-Pro:chenshuyi yurongchan$ cat out.txt
hello shell, I'm shuyi

可以看到 echo 命令的输出并没有在屏幕上打印出来，而是保存在了 out.txt 文件中。

其实上面这种方式和echo “hello” 1> out.txt这条命令的结果是一样的。或许是因为标准输出重定向比较频繁，所以就把数字 1 省略了。

标准错误是指输出的错误信息。例如当我们运行一条错误的指令时，控制台会提示凑无信息，这些就是错误信息。如果我们要重定向错误信息到文件中，我们可以用2>这个操作符。例如：

YuRongChandeMacBook-Pro:chenshuyi yurongchan$ ls +
ls: +: No such file or directory
YuRongChandeMacBook-Pro:chenshuyi yurongchan$ ls + 2> error.txt
YuRongChandeMacBook-Pro:chenshuyi yurongchan$ cat error.txt
ls: +: No such file or directory

通过2>这个操作符，我们将标准错误重定向到了 error.txt 文件中了。

说到这里，输入输出重定向就说完了。其实这一章很简单，就是通过1>和2>这两个操作符达到输出重定向的目的。

原作者:陈树义

欢迎关注作者私人博客http://shuyi.me