苍耳的博客

细水长流

0%

shell学习笔记

发表于 更新于 分类于 阅读次数： Valine：

常用命令

查看文件夹大小

1
2
$ du -h --max-depth=1
$ du -h -d 1

ulimit

ulimit命令用来限制系统用户对shell资源的访问。

假设有这样一种情况，当一台 Linux 主机上同时登陆了 10 个人，在系统资源无限制的情况下，这 10 个用户同时打开了 500 个文档，而假设每个文档的大小有 10M，这时系统的内存资源就会受到巨大的挑战。

而实际应用的环境要比这种假设复杂的多，例如在一个嵌入式开发环境中，各方面的资源都是非常紧缺的，对于开启文件描述符的数量，分配堆栈的大小，CPU 时间，虚拟内存大小，等等，都有非常严格的要求。资源的合理限制和分配，不仅仅是保证系统可用性的必要条件，也与系统上软件运行的性能有着密不可分的联系。这时，ulimit可以起到很大的作用，它是一种简单并且有效的实现资源限制的方式。

ulimit 用于限制 shell 启动进程所占用的资源，支持以下各种类型的限制：所创建的内核文件的大小、进程数据块的大小、Shell 进程创建文件的大小、内存锁住的大小、常驻内存集的大小、打开文件描述符的数量、分配堆栈的最大大小、CPU 时间、单个用户的最大线程数、Shell 进程所能使用的最大虚拟内存。同时，它支持硬资源和软资源的限制。

作为临时限制，ulimit 可以作用于通过使用其命令登录的 shell 会话，在会话终止时便结束限制，并不影响于其他 shell 会话。而对于长期的固定限制，ulimit 命令语句又可以被添加到由登录 shell 读取的文件中，作用于特定的 shell 用户。

  • 语法

    1
    ulimit option

  • 选项

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    -a：显示目前资源限制的设定；
    -c <core文件上限>：设定core文件的最大值，单位为区块；
    -d <数据节区大小>：程序数据节区的最大值，单位为KB；
    -f <文件大小>：shell所能建立的最大文件，单位为区块；
    -H：设定资源的硬性限制，也就是管理员所设下的限制；
    -m <内存大小>：指定可使用内存的上限，单位为KB；
    -n <文件数目>：指定同一时间最多可开启的文件数；
    -p <缓冲区大小>：指定管道缓冲区的大小，单位512字节；
    -s <堆叠大小>：指定堆叠的上限，单位为KB；
    -S：设定资源的弹性限制；
    -t <CPU时间>：指定CPU使用时间的上限，单位为秒；
    -u <程序数目>：用户最多可开启的程序数目；
    -v <虚拟内存大小>：指定可使用的虚拟内存上限，单位为KB。

  • 实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    [root@localhost ~]# ulimit -a
    core file size          (blocks, -c) 0           #core文件的最大值为100 blocks。
    data seg size           (kbytes, -d) unlimited   #进程的数据段可以任意大。
    scheduling priority             (-e) 0
    file size               (blocks, -f) unlimited   #文件可以任意大。
    pending signals                 (-i) 98304       #最多有98304个待处理的信号。
    max locked memory       (kbytes, -l) 32          #一个任务锁住的物理内存的最大值为32KB。
    max memory size         (kbytes, -m) unlimited   #一个任务的常驻物理内存的最大值。
    open files                      (-n) 1024        #一个任务最多可以同时打开1024的文件。
    pipe size            (512 bytes, -p) 8           #管道的最大空间为4096字节。
    POSIX message queues     (bytes, -q) 819200      #POSIX的消息队列的最大值为819200字节。
    real-time priority              (-r) 0
    stack size              (kbytes, -s) 10240       #进程的栈的最大值为10240字节。
    cpu time               (seconds, -t) unlimited   #进程使用的CPU时间。
    max user processes              (-u) 98304       #当前用户同时打开的进程（包括线程）的最大个数为98304。
    virtual memory          (kbytes, -v) unlimited   #没有限制进程的最大地址空间。
    file locks                      (-x) unlimited   #所能锁住的文件的最大个数没有限制。

curl

检查url有效性

1
2
3
4
5
6
urlstatus=$(curl -s -m 5 -IL $url|grep 200)
if [ "$urlstatus" != "" ];then
    wget $url
else
    echo "illegal url: $url"
fi

jq

可以使用jq解析json。

1
2
3
4
# Usage: jq [options] <jq filter> [file...] 
$ sudo apt install jq
$ curl -s url | jq -r '.result.page_size'
$ echo $json|jq -r '.result.data[0]'        # 数组

实例：分页请求服务器，每页请求返回page_size条数据，下载每条数据中的视频/图片

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
#!/bin/bash

echo "Begin to download..."
urlPattern="http://url?version=3&page="

for page in `seq 1 20`
do
	url="$urlPattern$page"
	echo "fetch content: $url"

	urlstatus=$(curl -s -m 5 -IL $url|grep 200)
	if [ "$urlstatus" != "" ];then
		json=$(curl -s $url)
		pageSize=`expr $(echo $json|jq -r '.result.page_size') - 1`
		echo "the page size is $pageSize"
		for index in `seq 0 $pageSize`
		do
			item=$(echo $json|jq -r ".result.data[$index]")
			urlVideo=$(echo $item|jq -r '.url')
			urlImg=$(echo $item|jq -r '.url_img')
			echo "download video: $urlVideo"
			wget $urlVideo>/dev/null 2>&1
			echo "download image: $urlImg"
			wget $urlImg>/dev/null 2>&1
		done
	else
		echo "illegal url: $url"
	fi
done

proxy

1
2
3
4
5
6
7
8
9
10
11
12
# 设置代理
$ export http_proxy=ip:port

# 取消代理
$ unset http_proxy

# 也可以
$ export https_proxy=https://127.0.0.1:1080
# 设置socks代理
$ export http_proxy=socks://127.0.0.1:1080
$ export http_proxy=sock4://127.0.0.1:1080
$ export http_proxy=sock5://127.0.0.1:1080

变量

定义变量

定义变量时，变量名不加美元符号，变量名和等号之间不能有空格，已定义的变量，可以被重新定义，如：

1
your_name="runoob.com"

除了显式地直接赋值，还可以用语句给变量赋值，如：

1
2
3
for file in `ls /etc`
或
for file in $(ls /etc)

使用变量

使用一个定义过的变量，只要在变量名前面加美元符号即可，如：

1
2
3
your_name="qinjx"
echo $your_name
echo ${your_name}

只读变量

使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。

1
2
3
4
#!/bin/bash
myUrl="http://www.google.com"
readonly myUrl
myUrl="http://www.runoob.com"

删除变量

使用 unset 命令可以删除变量。语法：

1
unset variable_name

输出为变量

1
arr=$(command)

字符串

字符串可以用单引号，也可以用双引号，也可以不用引号。

单引号

  • 单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；
  • 单引号字串中不能出现单引号（对单引号使用转义符后也不行）。

双引号

  • 双引号里可以有变量
  • 双引号里可以出现转义字符

拼接字符串

1
2
3
4
your_name="qinjx"
greeting="hello, "$your_name" !"
greeting_1="hello, ${your_name} !"
echo $greeting $greeting_1

获取字符串长度

1
2
string="abcd"
echo ${#string} #输出 4

提取子字符串

1
2
string="runoob is a great site"
echo ${string:1:4} # 输出 unoo

查找子字符串

查找字符 “i 或 s” 的位置（输出index从1开始），如果i存在则输出i的位置，不存在则输出s的位置，若都不存在则输出0：

1
2
string="runoob is a great company"
echo `expr index "$string" is`  # 输出 8

注意： 以上脚本中 ` 是反引号，而不是单引号 ‘，不要看错了哦。

Shell 数组

bash支持一维数组（不支持多维数组），并且没有限定数组的大小。数组元素的下标由 0 开始编号。获取数组中的元素要利用下标，下标可以是整数或算术表达式，其值应大于或等于0。

定义数组

在 Shell 中，用括号来表示数组，数组元素用”空格”符号分割开。定义数组的一般形式为：

数组名=(值1 值2 … 值n)

1
2
3
4
5
6
7
8
array_name=(value0 value1 value2 value3)

array_name=(
value0
value1
value2
value3
)

还可以单独定义数组的各个分量：

1
2
3
array_name[0]=value0
array_name[1]=value1
array_name[n]=valuen

可以不使用连续的下标，而且下标的范围没有限制。

读取数组

读取数组元素值的一般格式是：

${数组名[下标]}

使用 @ 符号可以获取数组中的所有元素：

echo ${array_name[@]}

获取数组的长度

获取数组长度的方法与获取字符串长度的方法相同：

1
2
3
4
5
6
#取得数组元素的个数
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得数组单个元素的长度
lengthn=${#array_name[n]}

注释

以”#”开头的行就是注释，会被解释器忽略。sh里没有多行注释，只能每一行加一个#号。
如果在开发过程中，遇到大段的代码需要临时注释起来，过一会儿又取消注释，可以把这一段要注释的代码用一对花括号括起来，定义成一个函数，没有地方调用这个函数，这块代码就不会执行，达到了和注释一样的效果。

多行注释还可以使用以下格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
:<<EOF
注释内容...
注释内容...
注释内容...
EOF

:<<'
注释内容...
注释内容...
注释内容...
'

:<<!
注释内容...
注释内容...
注释内容...
!

传递参数

可以在执行 Shell 脚本时，向脚本传递参数，脚本内获取参数的格式为：$n。n 代表一个数字，1 为执行脚本的第一个参数，2 为执行脚本的第二个参数，以此类推……，$0 为执行的文件名：

1
2
3
4
5
echo "Shell 传递参数实例！";
echo "执行的文件名：$0";
echo "第一个参数为：$1";
echo "第二个参数为：$2";
echo "第三个参数为：$3";
参数处理 说明
$# 传递到脚本的参数个数
$* 以一个单字符串显示所有向脚本传递的参数。如”$*“用「”」括起来的情况、以”$1 $2 … $n“的形式输出所有参数。
$@ 与$*相同，但是使用时加引号，并在引号中返回每个参数。如”$@“用「”」括起来的情况、以"$1" "$2" … "$n" 的形式输出所有参数。
$$ 脚本运行的当前进程ID号
$! 后台运行的最后一个进程的ID号
$- 显示Shell使用的当前选项，与set命令功能相同。
$? 显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。 
1
2
3
4
5
6
7
8
9
10
echo "Shell 传递参数实例！";
echo "第一个参数为：$1";

echo "参数个数为：$#";
echo "传递的参数作为一个字符串显示：$*";

Shell 传递参数实例！
第一个参数为：1
参数个数为：3
传递的参数作为一个字符串显示：1 2 3

运算符

算术运算符

原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，expr 最常用。expr 是一款表达式计算工具，使用它能完成表达式的求值操作。

1
2
val=`expr 2 + 2`
echo "两数之和为 : $val"

注意：表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2.

关系运算符

关系运算符只支持数字，不支持字符串，除非字符串的值是数字。

运算符 说明 举例
-eq 检测两个数是否相等，相等返回 true。 [ $a -eq $b ] 返回 false。
-ne 检测两个数是否不相等，不相等返回 true。 [ $a -ne $b ] 返回 true。
-gt 检测左边的数是否大于右边的，如果是，则返回 true。 [ $a -gt $b ] 返回 false。
-lt 检测左边的数是否小于右边的，如果是，则返回 true。 [ $a -lt $b ] 返回 true。
-ge 检测左边的数是否大于等于右边的，如果是，则返回 true。 [ $a -ge $b ] 返回 false。
-le 检测左边的数是否小于等于右边的，如果是，则返回 true。 [ $a -le $b ] 返回 true。

布尔运算符

运算符 说明 举例
! 非运算，表达式为 true 则返回 false，否则返回 true。 [ ! false ] 返回 true。
-o 或运算，有一个表达式为 true 则返回 true。 [ $a -lt 20 -o $b -gt 100 ] 返回 true。
-a 与运算，两个表达式都为 true 才返回 true。 [ $a -lt 20 -a $b -gt 100 ] 返回 false。

逻辑运算符

运算符 说明 举例
&& 逻辑的 AND [[ $a -lt 100 && $b -gt 100 ]] 返回 false
|| 逻辑的 OR [[ $a -lt 100 || $b -gt 100 ]] 返回 true

字符串运算符

运算符 说明 举例
= 检测两个字符串是否相等，相等返回 true。 [ $a = $b ] 返回 false。
!= 检测两个字符串是否相等，不相等返回 true。 [ $a != $b ] 返回 true。
-z 检测字符串长度是否为0，为0返回 true。 [ -z $a ] 返回 false。
-n 检测字符串长度是否为0，不为0返回 true。 [ -n “$a” ] 返回 true。
str 检测字符串是否为空，不为空返回 true。 [ $a ] 返回 true。

文件测试运算符

操作符 说明 举例
-r file 检测文件是否可读，如果是，则返回 true。 [ -r $file ] 返回 true。
-w file 检测文件是否可写，如果是，则返回 true。 [ -w $file ] 返回 true。
-x file 检测文件是否可执行，如果是，则返回 true。 [ -x $file ] 返回 true。
-s file 检测文件是否为空（文件大小是否大于0），不为空返回 true。 [ -s $file ] 返回 true。
-e file 检测文件（包括目录）是否存在，如果是，则返回 true。 [ -e $file ] 返回 true。
-d file 检测文件是否是目录，如果是，则返回 true。 [ -d $file ] 返回 false。
-f file 检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。 [ -f $file ] 返回 true。
-b file 检测文件是否是块设备文件，如果是，则返回 true。 [ -b $file ] 返回 false。
-c file 检测文件是否是字符设备文件，如果是，则返回 true。 [ -c $file ] 返回 false。
-g file 检测文件是否设置了 SGID 位，如果是，则返回 true。 [ -g $file ] 返回 false。
-k file 检测文件是否设置了粘着位(Sticky Bit)，如果是，则返回 true。 [ -k $file ] 返回 false。
-p file 检测文件是否是有名管道，如果是，则返回 true。 [ -p $file ] 返回 false。
-u file 检测文件是否设置了 SUID 位，如果是，则返回 true。 [ -u $file ] 返回 false。

echo, printf和read

echo

显示普通字符串:

1
echo "It is a test"

这里的双引号完全可以省略，以下命令与上面实例效果一致：

显示转义字符

1
2
echo "\"It is a test\""
"It is a test"

同样，双引号也可以省略

显示变量

read 命令从标准输入中读取一行,并把输入行的每个字段的值指定给 shell 变量

1
2
read name 
echo "$name It is a test"

显示换行

1
2
echo -e "OK! \n" # -e 开启转义
echo "It it a test"

显示不换行

1
2
echo -e "OK! \c" # -e 开启转义 \c 不换行
echo "It is a test"

显示结果定向至文件

1
echo "It is a test" > myfile

不转义或取变量

1
echo '$name\"'

显示命令执行结果

1
2
3
echo `date`

->Thu Jul 24 10:08:46 CST 2014

注意： 这里使用的是反引号 `, 而不是单引号 ‘。

printf

用法

printf format-string [arguments…]

参数说明：

format-string: 为格式控制字符串
arguments: 为参数列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
printf "%-10s %-8s %-4s\n" 姓名 性别 体重kg  
printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234 
printf "%-10s %-8s %-4.2f\n" 杨过 男 48.6543 
printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876 

#执行脚本，输出结果如下所示：
姓名     性别   体重kg
郭靖     男      66.12
杨过     男      48.65
郭芙     女      47.99

# 没有引号也可以输出
printf %s abcdef

# 格式只指定了一个参数，但多出的参数仍然会按照该格式输出，format-string 被重用
printf %s abc def

# 如果没有 arguments，那么 %s 用NULL代替，%d 用 0 代替
printf "%s and %d \n"

%-10s 指一个宽度为10个字符（-表示左对齐，没有则表示右对齐），任何字符都会被显示在10个字符宽的字符内，如果不足则自动以空格填充，超过也会将内容全部显示出来。

%-4.2f 指格式化为小数，其中.2指保留2位小数。

read

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
echo -n "Enter you name:"   #echo -n 让用户直接在后面输入 
read name  #输入的多个文本将保存在一个变量中
echo "Hello $name, welcome to my program."

read -p "Please enter your age: " age  #在read命令行指定提示符
days=$[ $age * 365 ]
echo "That makes you over $days days old!"

read -p "Enter your name:" first last   #指定多个变量
echo "Checking data for $last, $first"

if read -t 5 -p "Please enter your name: " name     #超时, 等待输入的秒数
then
    echo "Hello $name, welcome to my script"
else
    echo 
    echo "Sorry, too slow!"
fi

read -s -p "Enter your passwd: " pass   #-s 参数使得read读入的字符隐藏
echo 
echo "Is your passwd readlly $pass?"

流程控制

if else

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
if condition
then
    command1 
    command2
    ...
    commandN
else
    command
fi

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

if condition1
then
    command1
elif condition2 
then 
    command2
else
    commandN
fi

for

1
2
3
4
5
6
7
8
9
for var in item1 item2 ... itemN
do
    command1
    command2
    ...
    commandN
done

for var in item1 item2 ... itemN; do command1; command2… done;

in列表可以包含替换、字符串和文件名。

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
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

for i in `seq 1 4`
do
    echo "The value is: $i"
done
# 输出结果：
The value is: 1
The value is: 2
The value is: 3
The value is: 4

for (( i = 1; i < 5; i++ )); do
	echo "The value is: $i"
done
# 输出结果：
The value is: 1
The value is: 2
The value is: 3
The value is: 4

while

1
2
3
4
while condition
do
    command
done
1
2
3
4
5
6
int=1
while(( $int<=5 ))
do
    echo $int
    let "int++"
done

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

while循环可用于读取键盘信息。下面的例子中，输入信息被设置为变量FILM，按结束循环。

1
2
3
4
5
6
7
8
9
10
11
12
echo '按下 <CTRL-D> 退出'
echo -n '输入你最喜欢的网站名: '
while read FILM
do
    echo "是的！$FILM 是一个好网站"
done

# 运行脚本，输出类似下面：

按下 <CTRL-D> 退出
输入你最喜欢的网站名:菜鸟教程
是的！菜鸟教程 是一个好网站

无限循环

1
2
3
4
5
6
7
8
9
10
11
12
13
while :
do
    command
done
# 或者

while true
do
    command
done
# 或者

for (( ; ; ))

until

until 循环执行一系列命令直至条件为 true 时停止。until 循环与 while 循环在处理方式上刚好相反。一般 while 循环优于 until 循环，但在某些时候—也只是极少数情况下，until 循环更加有用。

1
2
3
4
5
6
7
8
9
10
11
until condition
do
    command
done

a=0
until [ ! $a -lt 10 ]
do
   echo $a
   a=`expr $a + 1`
done

case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
case 值 in
模式1)
    command1
    command2
    ...
    commandN
    ;;
模式2）
    command1
    command2
    ...
    commandN
    ;;
esac

case工作方式如上所示。取值后面必须为单词in，每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后，其间所有命令开始执行直至 ;;。

取值将检测匹配的每一个模式。一旦模式匹配，则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式，使用星号 * 捕获该值，再执行后面的命令。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
echo '输入 1 到 4 之间的数字:'
echo '你输入的数字为:'
read aNum
case $aNum in
    1)  echo '你选择了 1'
    ;;
    1)  echo '你选择了 2'
    ;;
    1)  echo '你选择了 3'
    ;;
    1)  echo '你选择了 4'
    ;;
    *)  echo '你没有输入 1 到 4 之间的数字'
    ;;
esac

跳出循环

break

1
2
3
4
5
6
7
8
9
10
11
12
while :
do
    echo -n "输入 1 到 5 之间的数字:"
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你输入的数字为 $aNum!"
        ;;
        *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
            break
        ;;
    esac
done

continue

1
2
3
4
5
6
7
8
9
10
11
12
13
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

函数

函数定义

1
2
3
4
[ function ] funname [()] {
    action;
    [return int;]
}
  1. 可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。
  2. 参数返回，可以显示加：return 返回，如果不加，将以最后一条命令运行结果，作为返回值。 return后跟数值n(0-255
1
2
3
4
demoFun(){
    echo "这是我的第一个 shell 函数!"
}
demoFun

注意：所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至shell解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。

函数参数

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

1
2
3
4
5
6
7
8
9
10
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

注意，$10 不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。另外，还有几个特殊字符用来处理参数：

参数处理 说明
$# 传递到脚本的参数个数
$* 以一个单字符串显示所有向脚本传递的参数
$$ 脚本运行的当前进程ID号
$! 后台运行的最后一个进程的ID号
$@ 与$*相同，但是使用时加引号，并在引号中返回每个参数。
$- 显示Shell使用的当前选项，与set命令功能相同。
$? 显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。

输入/输出重定向

概述

大多数 UNIX 系统命令从终端接受输入并将所产生的输出发送回​​到终端。一个命令通常从一个叫标准输入的地方读取输入，默认情况下是终端。同样，一个命令通常将其输出写入到标准输出，默认情况下也是终端。

重定向命令列表如下：

命令 说明
command > file 将输出重定向到 file。
command < file 将输入重定向到 file。
command >> file 将输出以追加的方式重定向到 file。
n > file 将文件描述符为 n 的文件重定向到 file。
n >> file 将文件描述符为 n 的文件以追加的方式重定向到 file。
n>&m 把输出到文件符n的信息重定向到文件描述符m。
n<&m 将输入文件 m 和 n 合并。
<< tag 将开始标记 tag 和结束标记 tag 之间的内容作为输入。
cmd >&n 把输出送到文件描述符n
cmd m>&n 把输出 到文件符m的信息重定向到文件描述符n
cmd >&- 关闭标准输出
cmd <&n 输入来自文件描述符n
cmd m<&n m来自文件描述符n
cmd <&- 关闭标准输入
cmd <&n- 移动输入文件描述符n而非复制它。（需要解释）
cmd >&n- 移动输出文件描述符 n而非复制它。（需要解释）
cmd 2>file 把文件描述符2重定向到file，即把错误输出存到file中。
cmd > file 2>&1 把标准错误重定向到标准输出，再重定向到file，即stderr和stdout都被输出到file中
cmd &> file 功能与上一个相同，更为简便的写法。
cmd >& file 功能仍与上一个相同。
cmd > f1 2>f2 把stdout重定向到f1，而把stderr重定向到f2
tee files 把stdout原样输出的同时，复制一份到files中。
tee files 把stderr和stdout都输出到files中，同时输出到屏幕。

>&实际上复制了文件描述符，这使得ls > dirlist 2>&1与ls 2>&1 > dirlist的效果不一样。man bash的Redirection节中提及了这段内容。

需要注意的是文件描述符 0 通常是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。

输出重定向

1
2
3
4
5
6
7
$ echo "菜鸟教程：www.runoob.com" > users
$ cat users

$ echo "菜鸟教程：www.runoob.com" >> users
$ cat users
菜鸟教程：www.runoob.com
菜鸟教程：www.runoob.com

输入重定向

和输出重定向一样，Unix 命令也可以从文件获取输入,这样，本来需要从键盘获取输入的命令会转移到文件读取内容。

1
2
3
4
5
6
command1 < file1

$ cat > test.txt                                                                                  liujiadong

$ cat test.txt
liujiadong

重定向深入讲解

一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：

  • 标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据。
  • 标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据。
  • 标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。

默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。

  • 如果希望 stderr 重定向到 file，可以这样写：
1
2
$ command 2 > file
$ command 2 >> file
  • 如果希望将 stdout 和 stderr 合并后重定向到 file，可以这样写：
1
2
$ command > file 2>&1
$ command >> file 2>&1
  • 如果希望对 stdin 和 stdout 都重定向，可以这样写：
1
$ command < file1 >file2

Here Document

Here Document 是 Shell 中的一种特殊的重定向方式，用来将输入重定向到一个交互式 Shell 脚本或程序。

1
2
3
command << delimiter
    document
delimiter

它的作用是将两个 delimiter 之间的内容(document) 作为输入传递给 command。

  • 结尾的delimiter 一定要顶格写，前面不能有任何字符，后面也不能有任何字符，包括空格和 tab 缩进。
  • 开始的delimiter前后的空格会被忽略掉。
1
2
3
4
5
6
7
8
9
10
11
cat << EOF
欢迎来到
菜鸟教程
www.runoob.com
EOF

执行以上脚本，输出结果：
欢迎来到
菜鸟教程
www.runoob.com
/dev/null 文件

  • 如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null, /dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到”禁止输出”的效果。

  • 如果希望屏蔽 stdout 和 stderr，可以这样写：

1
$ command > /dev/null 2>&1

文件包含

和其他语言一样，Shell 也可以包含外部脚本。这样可以很方便的封装一些公用的代码作为一个独立的文件。Shell 文件包含的语法格式如下：

1
2
. filename   # 注意点号(.)和文件名中间有一空格
source filename
  • test1.sh 代码如下：
1
url="http://www.runoob.com"
  • test2.sh 代码如下：
1
2
3
4
5
6
7
#使用 . 号来引用test1.sh 文件
. ./test1.sh

# 或者使用以下包含文件代码
# source ./test1.sh

echo "菜鸟教程官网地址：$url"

注：被包含的文件 test1.sh 不需要可执行权限。