Linux快速入门（08）Shell脚本学习

╰+哭是因爲堅強的太久メ 2022-12-20 05:46 340阅读 0赞

# 简介  #

> Shell 是一个用C语言编写的程序，它是用户使用Linux的桥梁。Shell既是一种命令语言，又是一种程序设计语言。
> 
> Shell 是指一种应用程序，这个应用程序提供了一个界面，用户通过这个界面访问操作系统内核的服务。
> 
> Ken Thompson的sh是第一种Unix Shell，Windows Explorer是一个典型的图形界面Shell。

# Shell教程入门 #

### 1、shell脚本 ###

> shell脚本(shell script)，是一种为shell而编写的脚本程序。然而通常所说的shell却是指shell脚本，而非shell本身。

Linux系统shell种类众多，常用的有sh和bash。

### 2、shell脚本实践 ###

shell脚本用 **\#!/bin/bash** 或 **\#!/bin/sh** 之类的方式，制定运行脚本的shell, **\#!** 是识别符号。例如：

> \#!/bin/sh
> 
> echo "Hello World"

运行shell脚本的两种方法：

*  1）作为可执行程序

将shell脚本内容保到扩展名为.sh格式文件中：

> test.sh

赋予执行权限

> chmod + x ./test.sh

然后执行脚本（*注意此处需要指明当前目录下的**test.sh**哦，不然会去**path**路径找的*）：

> ./test.sh

*  2）作为解释其参数

直接解释运行,如此就不用写\#!/bin/sh之类的引用注释了（*类似java、php、python脚本 ** *****javac Hello.java**）。

> sh test.sh

# Shell变量 #

变量命名语法，不需要$符号（php需要）。命名要求：

*  首字母必须字母a-z或A-Z
 *  不能空格，可用\_
 *  不能标点
 *  不能使用bash关键字

举几个例子：

> \#1、直接给变量赋值，注意，不同于其他编程语言，等号前后不要有空格。
> 
> hello="hello world"
> 
> \#2、打印变量
> 
> echo $hello
> 
> *\# 3、**使用语句给变量赋值，如下循环显示出**/etc**目录下的文件名（注意，ls语句前后是飘号，也就是 ~ 键下面那个）*
> 
> \#!/bin/sh  
> for file in \`ls /etc\`   
> do   
>     echo "this path is $\{file\}"  
> done

### 1、使用变量 ###

使用已定义变量，只需在变量前加$符号即可：

> 1.  your\_variable='yourname'
> 2.  echo $your\_variable
> 3.  echo $(your\_variable)

变量名可以加\{\}来标识变量名的范围，如：

> 1.  for skill in Ada Coffe Action Java; do
> 2.      echo "I am good at $\{skill\}Script"
> 3.  done

注意，因为$\{skill\}和后面的Script紧挨着，如果不加\{\}，skill就可能被认为skillScript而导致变量找不到

已定义的变量可重新定义：

> 1.  your\_name="tom"
> 2.  echo $your\_name
> 3.  your\_name="john"
> 4.  echo $your\_name

### 2、只读变量 ###

使用readonly命令将变量只读，则不可再改变，否则报错。

> 1.  \#!/bin/bash
> 2.  myUrl="http://www.w3cschool.cc"
> 3.  readonly myUrl
> 4.  myUrl="new url" *\#**此处就会报错，因为变量只读了。*

### 3、删除变量 ###

使用unset命令删除变量：

> unset variable\_name

==删除变量后不能再用，而unset不能删除只读变量==

> 1.  \#!/bin/sh
> 2.  myUrl="http://www.google.com"
> 3.  unset myUrl
> 4.  echo $myUrl *\#**此时输出就没接过了，因为变量被删除了。*

### 4、变量类型 ###

运行shell时，会同时存在三种变量：

>  *  局部变量：脚本中定义的变量，仅作用于本shell脚本内。
>  *  环境变量：所有程序，包括shell启动程序都能访问的环境变量。
>  *  shell变量：shell程序的特殊变量。

### 5、shell字符串 ###

shell常用number和string，其中string可以单引号、双引号或者不用引号。但是略有区别：

> \#单引号
> 
> str='string test'

单引号''之间的字符原样输出，里面的变量也会失效。其内部不能再有单引号，哪怕转义符号都失效。

> \#双引号
> 
> your\_name='your name'
> 
> str=*"Hello ,world ,\\"*$your\_name\\*"! \\n"*

双引号里面可以有变量和转义符号。

> \#字符串拼接（类似"hello"+$n1+"!"）
> 
> n1="abc"
> 
> test="hello, "$n1" !"
> 
> test1="hello, $\{n1\} !"
> 
> echo $test $test1

获取字符串长度，使用\#号标识变量长度

> str="abcdef"

**输出字符串长度**

> echo $\{\#str\}

获取子字符串

> str="abcdef"
> 
> *\#**下标从左至右，**0**开始，*
> 
> echo $\{str:1:4\}

查找子字符串

> \#使用\`符号（飘号）
> 
>  
> 
> str="hello world nihaome"
> 
> *\#**查找字符**i**或**s**的位置**,**反引号*（飘号）
> 
> echo \`expr index "$str" is\`

### 6、Shell数组 ###

bash仅支持一维数组，可利用下标或表达式操作元素。

定义数组，shell中使用()表示数组，元素用空格来分割。

> array=(1 2 3 4 5 6 7)
> 
> *\#**或者*
> 
> array=(a b c)

也可以单独定义,下标可以不连续，也无范围限制。

> array\[0\]=1
> 
> array\[1\]=2
> 
> array\[3\]=7

读取数组

> variable=$\{array\[index\]\}
> 
> *\# @**符号代替**index**表示获取所有元素，下面的脚本会输出所有元素*
> 
> echo $\{variable\[@\]\}

获取数组长度，类似字符串的获取

> *\#**获取元素个数*
> 
> length=$\{ *\#array\_name\[@\]\}*
> 
> *\#**或者**\***通配符*
> 
> length=$\{ *\#array\_name\[\*\]\}*
> 
> *\#**获取数组单个元素的长度*
> 
> length\_n=$\{ *\#array\_name\[n\]\}*

### 7、Shell注释 ###

使用\#至于行首，表示该行注释，shell无多行注释，只能每行都\#

> *\#-----------------------*
> 
> *\#**我是个多行注释*
> 
> *\#**但是只能这么写*
> 
> *\#-----------------------*

要是多行代码需要注释，可以将定义为函数，加\{\}包裹起来，该函数不被调用，则类似于注释掉。

# Shell传递参数 #

在执行shell脚本test.sh时，可以向脚本传递参数，脚本内获取参数的格式：$n，n代表数字编号，为脚本内需要获取的参数的编号。

例如，向脚本传递三个参数，并输出，其中，$0为执行文件名（test.sh）：

> \#!/bin/bash
> 
> *\#**传参测试*
> 
> echo "Shell 传参测试";
> 
> echo "file name: $0";
> 
> echo "first variable: $1";
> 
> echo "second variable: $2"
> 
> echo "third variable: $3";

通过赋予权限，或者指定执行，可实现输出：

> $ chmod +x test.sh

$符号在前表示root用户执行（并非主动输入），下面是传入1，2，3，三个数到脚本

> $ ./test.sh 1 2 3

输出结果：

> Shell 传参测试
> 
> file name: ./test.sh
> 
> first variable: 1
> 
> second variable 2
> 
> third variable 3

另有几个特殊字符处理参数：

<table> 
 <thead> 
 <tr> 
 <td style="border-color:#eeeeee;"> 参数处理 </td> 
 <td style="border-color:#eeeeee;"> 说明 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#eeeeee;"> $# </td> 
 <td> 传递到脚本的参数的个数 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> $* </td> 
 <td> 以一个单字符串显示所有向脚本传递的参数。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> $$ </td> 
 <td> 脚本运行的当前进程ID号 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> $! </td> 
 <td> 后台运行的最后一个进程的ID号 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> $@ </td> 
 <td> 类似$*，使用时许加引号，并在引号中返回每个参数。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> $- </td> 
 <td> 显示shell使用的当前选选项，类似set命令 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> $? </td> 
 <td> 显示最后命令的退出状态。0 表示无错误。其他都是错。 </td> 
 </tr> 
 </tbody> 
</table>

> \#!/bin/sh
> 
> echo "Shell 传递参数实例！";
> 
> echo "第一个参数为：$1";
> 
> echo "参数个数为：$\#";
> 
> echo "传递的参数作为一个字符串显示：$\*";

执行效果：

$ chmod +x test.sh

$ ./test.sh 1 2 3

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

$\*与$@的相同点：

>  *  都是应用所有参数

不同：只有在双引号中体现。假设在脚本运行时写了三个参数 1、2、3，，则 ” \* ” 等价于 “1 2 3”（传递了一个参数），而 “@” 等价于 “1” “2” “3”（传递了三个参数）。

> \#!/bin/bash
> 
> echo "-- \\$\* demo ---"
> 
> for i in "$\*";do
> 
>     echo $i
> 
> done
> 
> echo "-- \\$@ demo ---"
> 
> for i in "$@"; do
> 
>     echo $i
> 
> done

执行效果：

$ chmod +x test.sh

$ ./test.sh 1 2 3

> \# $\* 演示 
> 
> 1 2 3
> 
> \# $@ 演示 
> 
> 1
> 
> 2
> 
> 3

# Shell数组 #

Bash shell仅支持一维数组，不限定大小，初始化时候不需要指定大小。下标0开始，()包裹，空格分割元素。

> array=(a b c d)

读取数组，格式$\{array\[index\]\}

> \#!/bin/bash
> 
> my\_array=(a b "c" d)
> 
> echo "first: $\{my\_array\[0\]\}"
> 
> *\#**然后执行文件，获得输出结果*
> 
> *\#**可用**@**或**\***来代替**index**获取所有元素*

数组长度，类似字符串的长度获取

> $\{ *\#array\[index\]\}*

# Shell运算符 #

shell支持多种运算符：

>  *  算数运算符
>  *  关系运算符
>  *  布尔运算符
>  *  字符串运算符
>  *  文件测试运算符

原生Bash不支持简单的数学运算，可以用awk和expr实现。

> \#!/bin/sh
> 
> val=\`expr 2 \+ 2\`
> 
> echo $val
> 
> *\#**注意，**expr**用反引号，表达式和运算符之间必须有空格，**2+2**就不行。*

### 1、算术运算符 ###

若a = 10，b = 20

<table> 
 <thead> 
 <tr> 
 <td style="border-color:#eeeeee;"> 运算符 </td> 
 <td style="border-color:#eeeeee;"> 说明 </td> 
 <td style="border-color:#eeeeee;"> 举例 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#eeeeee;"> + </td> 
 <td> 加号 </td> 
 <td> `expr&nbsp;$a +&nbsp;$b`，result = 30 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> - </td> 
 <td> 减号 </td> 
 <td> `expr&nbsp;$a -&nbsp;$b`，result = -10 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> * </td> 
 <td> 乘号 </td> 
 <td> `expr&nbsp;$a *&nbsp;$b`，result = 200 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> / </td> 
 <td> 除号 </td> 
 <td> `expr&nbsp;$b /&nbsp;$a`，result = 2 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> % </td> 
 <td> 取余 </td> 
 <td> `expr&nbsp;$b %&nbsp;$a`，result=0 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> = </td> 
 <td> 赋值 </td> 
 <td> a=$b，将b的值赋给a </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> == </td> 
 <td> 相等，比较数字，同则true。 </td> 
 <td> [$a ==&nbsp;$b]返回false </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> != </td> 
 <td> 不等，比较数字，不同的true。 </td> 
 <td> [$a !=&nbsp;$b]返回true。 </td> 
 </tr> 
 </tbody> 
</table>

> \#!/bin/bash  
> a=10  
> b=20  
> val=\`expr $a + $b\`  
> echo "a + b : $val"  
> val=\`expr $a - $b\`  
> echo "a - b : $val"  
> val=\`expr $a \\\* $b\`  
> echo "a \* b : $val"  
> val=\`expr $b / $a\`  
> echo "b / a : $val"  
> val=\`expr $b % $a\`  
> echo "b % a : $val"   
> if \[ $a == $b \] ; then  
> echo "a 等于 b"   
> fi
> 
> if \[ $a != $b \] ; then  
> echo "a 不等于 b"  
> fi

执行结果：

> a + b : 30
> 
> a - b : -10
> 
> a \* b : 200
> 
> b / a : 2
> 
> b % a : 0
> 
> a 不等于 b

注意：条件表达式必须在\[\]之间，且必须有空格，如\[$a==$b\]是错的！

\*乘号需要在expr表达式内用\\转义

Mac电脑的shell的expr表达式：$((表达式))所以它的乘号\*不用转义

### 2、关系运算符 ###

布尔类型，关系运算符仅支持数字，除非字符串的值也是数字。示例，若a = 10 ,b = 20:

### 3、布尔运算符 ###

### 4、逻辑运算符 ###

### 5、字符串运算符 ###

### 6、文件测试运算符 ###

用于检测类unix 文件的各种属性

<table> 
 <thead> 
 <tr> 
 <td style="border-color:#eeeeee;"> 操作符 </td> 
 <td style="border-color:#eeeeee;"> 说明 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#eeeeee;"> -b file </td> 
 <td> 是否是块设备文件，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -c file </td> 
 <td> 是否是字符设备文件，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -d file </td> 
 <td> 是否是目录，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -f file </td> 
 <td> 是否是普通文件(既非目录，亦非设备文件)，若是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -g file </td> 
 <td> 是否设置了SGID位，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -k file </td> 
 <td> 是否设置粘着位，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -p file </td> 
 <td> 是否有名管道，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -u file </td> 
 <td> 是否设置SUID，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -r file </td> 
 <td> 是否可读，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -w file </td> 
 <td> 是否可写，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -x file </td> 
 <td> 是否可执行，是则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -s file </td> 
 <td> 是否为空或大小是否大于0，非空则true </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> -e file </td> 
 <td> 是否存在，是则true </td> 
 </tr> 
 </tbody> 
</table>

==注意shell脚本的表达式都要在\[\]内哦==

# Shell echo命令 #

类似于php的echo，shell的echo用于输出字符串，格式echo string

显示普通字符串：

> echo "Hello World"
> 
> *\#**可以不带引号*
> 
> echo Hello World

显示转义字符

> echo "\\"It is a test\\""
> 
> *\#**输出结果*
> 
> "It is a test"

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

> \#!/bin/sh
> 
> read name
> 
> echo "$name It is a test"

运行效果：

> \[root@www ~\]*\# sh test.sh*
> 
> OK                     *\#**标准输入*
> 
> OK It is a test        *\#**输出*

显示换行

> echo \-e "Ok ! \\n" *\# -e* *开启转义，\\n是换行*
> 
> echo "It is a test"

输出结果：注意ok后面有换行

> OK!
> 
> It it a tes

显示不换行

> \#!/bin/sh
> 
> echo \-e "OK! \\c" *\# -e* *开启转义** ，\\c表示 **不换行*
> 
> echo "It is a test"

结果：

> OK! It is a test

显示结果定向至文件

> echo "It is a test" > test.txt

原样输出字符，不转义不取变量，需要结合单引号

> echo '$name\\"'

输出结果

> $name\\"

显示命令执行结果

==命令用\`来包裹（飘号）==

> echo \`date\`

结果：

> 2020年 11月 22日 星期日 19:17:40 CST

# Shell printf命令 #

类似C语言的printf()函数，shell使用printf会比echo更具有跨平台移植性。可以类似C的printf()函数使用一些复杂的表达式，printf不支持自动换行，需要借助\\n

> printf format\-string \[args...\]

示例，模拟shell输出，

> $ echo "hello ,shell"
> 
> hello ,shell
> 
> $ printf "hello ,shell \\n"
> 
> hello ,shell
> 
> $

脚本化的printf命令使用：

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

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

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

> *\#!/bin/bash*
> 
> *\# format-string**为双引号*
> 
> printf "%d %s\\n" 1 "abc"
> 
> *\#* *单引号与双引号效果一样*
> 
> printf '%d %s\\n' 1 "abc"
> 
> *\#* *没有引号也可以输出*
> 
> printf %s abcdef
> 
> *\#* *格式只指定了一个参数，但多出的参数仍然会按照该格式输出，**format-string* *被重用*
> 
> printf %s abc def
> 
> printf "%s\\n" abc def
> 
> printf "%s %s %s\\n" a b c d e f g h i j
> 
> *\#* *如果没有* *arguments**，那么* *%s* *用**NULL**代替，**%d* *用* *0* *代替*
> 
> printf "%s and %d \\n"

Printf的转移序列

<table> 
 <thead> 
 <tr> 
 <td style="border-color:#eeeeee;"> 序列 </td> 
 <td style="border-color:#eeeeee;"> 说明 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#eeeeee;"> \a </td> 
 <td> 警告字符，通常为ASCII的BEL字符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \b </td> 
 <td> 后退 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \c </td> 
 <td> 抑制不显示输出结果中任何姐wide换行字符（只在%b格式指示控制符下的参数字符串中有效），而且任何留在参数里的字符，任何接下来的采纳书以及任何留在格式字符串中的字符，都被忽略。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \f </td> 
 <td> 换页 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \n </td> 
 <td> 换行 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \r </td> 
 <td> 回车 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \t </td> 
 <td> 水平tab </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \v </td> 
 <td> 竖直tab </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \\ </td> 
 <td> 转义后输出一个\符号 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \d dd </td> 
 <td> 表示1–3位的八进制字符，仅在格式字符串中有效。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> \0 dd d </td> 
 <td> 表示1–3位的八进制字符 </td> 
 </tr> 
 </tbody> 
</table>

# Shell test命令 #

shell中test命令用于测试条件是否成立，可进行数字、字符和文件的条件测试

> \#!/bin/bash
> 
> *\#**用之前的各种运算符，测试**test*
> 
> num1=100
> 
> num2=200
> 
> if test $\[num1\] -eq $\[num2\]
> 
> then
> 
>     echo 'true'
> 
> else
> 
>     echo 'false'
> 
> fi

# Shell 流程控制 #

区别于其他编程语言，shell的流程控制不可为空，如Java：

if(a>b){
    
      System.out.println("ok");
    
    }else{
    
      //此处不做任何事
    
    }

但是在shell中不能出现不做任何事的分支语句

### 1、if else ###

if语句格式

> if condition
> 
> then
> 
> command1
> 
> command2
> 
> ...
> 
> fi *\#* *是**if**的倒写*

每个句子可以用;分号结束，可以写在一行好几个语句。

if else格式

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

if else-if else格式

> if condition1
> 
> then
> 
> command1
> 
> elif condition2 *\#**类似**python**中，**else if**是写作**elif*
> 
> then
> 
> command2
> 
> else
> 
> command
> 
> fi

### 2、for循环 ###

shell的for循环格式：

> for var in item1 item2 ... itemN
> 
> do
> 
>     command1
> 
>     command2
> 
>     ...
> 
> done *\#for**循环结束的标识*
> 
> *\#**写成一行*
> 
> for var in item1 item2 ... itemN;do command1; command2;...;done;

### 3、while语句 ###

格式：

> while condition
> 
> do
> 
>     command
> 
> done

示例：

> \#!/bin/sh
> 
> int=1
> 
> while(( $int<=5 ))
> 
> do
> 
>         echo $int
> 
>         let "int++" *\# let**是个关键命令*
> 
> done

可以结合read命令接收输入信息

### 4、无限循环 ###

> while :
> 
> do
> 
>     command
> 
> done
> 
> *\#**或者*
> 
> while true
> 
> do
> 
>     command
> 
> done
> 
> *\#**或者*
> 
> for (( ; ; ))

### 5、until循环 ###

shell所有的until循环类似于一个特殊的for循环，知道满足条件时候才停止。一般还是while

> until condition
> 
> do
> 
>     command
> 
> done

条件可为任意测试条件，测试发生在循环末尾，因此循环至少执行一次—请注意这一点。

### 6、case ###

类似其他语言的switch…case语句

> case value in
> 
> mode1)
> 
>     command1
> 
>     ...
> 
>     ;; *\#case**的结束标志*
> 
> mode2)
> 
>     command2
> 
>     ...
> 
>     ;;
> 
> esac *\#case**的反写*

value只会匹配一个case，或者不匹配，则mode可用\*号通配

> 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

### 7、跳出循环 ###

shell也使用break和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 之间的! 游戏结束"
> 
>           break
> 
>       ;;
> 
>   esac
> 
> done

*  continue，跳出本次循环，执行下一轮循环

> \#!/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

### 8、esac ###

case语句区别于C语言，用esac作为结束标志，)和;;标识每个case。

# Shell函数 #

shell可以自定义函数，然后自己调用。函数格式：

> *\#function* *关键字为可选项，参数也是可选*
> 
> \[ function \] funname \[()\]
> 
> \{ 
> 
>   action;
> 
>   \[return int;\]
> 
> \}

说明：可以带function fun()定义，也可以fun()定义，不带参数。参数返回，可以显示加: return 返回，若不加，则返回最后一条指令结果。

> \#!/bin/bash
> 
> demoFun()\{ 
> 
>     echo "这是我的第一个 shell 函数!"
> 
> \}
> 
> echo "-----函数开始执行\-----"
> 
> demoFun
> 
> echo "-----函数执行完毕\-----"

含有返回值的函数：

> \#!/bin/bash
> 
> funWithReturn()\{ 
> 
>     echo "这个函数会对输入的两个数字进行相加运算..."
> 
>     echo "输入第一个数字: "
> 
>     read aNum
> 
>     echo "输入第二个数字: "
> 
>     read anotherNum
> 
>     echo "两个数字分别为 $aNum 和 $anotherNum !"
> 
>     return $(($aNum\+$anotherNum))
> 
> \}
> 
> funWithReturn
> 
> echo "输入的两个数字之和为 $? !"

==调用函数返回值，用$?符号==，函数必须在被调用前定义。

*  函数参数

在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 1表示第一个参数，$2表示第二个参数…

> \#!/bin/bash
> 
> 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)来获取参数。

# Shell 输入/输出重定向 #

类Uinx系统中，默认标准输入输出设备就是shell终端。重定向命令列表：

<table> 
 <thead> 
 <tr> 
 <td style="border-color:#eeeeee;"> 命令 </td> 
 <td style="border-color:#eeeeee;"> 说明 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#eeeeee;"> command &gt; file </td> 
 <td> 输出重定向到file </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> command &lt; file </td> 
 <td> 输出重定向到file </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> command &gt;&gt; file </td> 
 <td> 输出追加到file </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> n &gt; file </td> 
 <td> 文件描述符为n的文件重定向到file </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> n &gt;&gt; file </td> 
 <td> 文件描述符为n的文件追加到file </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> n &gt;&amp; m </td> 
 <td> 输出文件m和n合并 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> n &lt;&amp; m </td> 
 <td> 输入文件m和n合并 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#eeeeee;"> &lt;&lt; tag </td> 
 <td> 开始标记tag和结束标记tag之间的内容作为输入 </td> 
 </tr> 
 </tbody> 
</table>

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

### 1、输出重定向 ###

> command1 > file1

若file1存在，则被替代。可以用>>追加符号，则不替代。

### 2、输入重定向 ###

> command1 < file1
> 
> command1 < infile > outfile

同时替换输入和输出，执行command1，从文件infile读取内容，然后将输出写入到outfile中。

### 3、重定向深入讲解 ###

一般类unix系统命令运行会同时打开三个文件：

*  标准输入文件(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，可以这样写：

> *\#**模拟终端*
> 
> $ command 2 > file

若要追加>>符号，其中2代表标准错误文件的代号。

如果希望将stdout和stderr合并后重定向到file

> command > file 2>&1
> 
> *\#**或者*
> 
> command >> file 2>&1
> 
> *\#**如果输入、输出都重定向*
> 
> command <file1 >file2

### 4、Here Document ###

Here Document是shell的一种特殊重定向方式，用于将输入重定向到一个交互式shell脚本或程序：

> command << delimiter
> 
>     document
> 
> delimiter

作用将delimiter之间的document作为输入传递给command

注意：结尾的delimiter前后不得有任何符号，包括tab和空格。

> wc -l << EOF
> 
>     nihao
> 
>     zhendehenhao
> 
>     shime
> 
>     ok
> 
> EOF

输出结果，获得的EOF之间的内容的行数。

> 4

### 5、/dev/null文件 ###

若希望执行命令不在屏幕输出，可重定向到/dev/null

> command > /dev/null

/dev/null为特殊文件，写入的内容立即不见，不可读出。

如果屏蔽stdout和stderr

> command > /dev/null 2>&1

# Shell文件包含 #

shell也可以使用外部脚本，便于封装：

> . filename *\#**注意点号**(.)**与文件名之间有空格*
> 
> 或
> 
> source filename

示例：test1.sh

> \#!/bin/bash
> 
> url="http://www.runoob.com"

test2.sh

> \#!/bin/bash
> 
> *\#**使用* *.* *号来引用**test1.sh* *文件*
> 
> . ./test1.sh
> 
> *\#* *或者使用以下包含文件代码*
> 
> *\# source ./test1.sh*
> 
> echo "菜鸟教程官网地址：$url"

执行时候test2.sh只需要test2.sh有执行权限即可，test1.sh不一定需要。