bash学习记录——实验楼

1. 简介

Bash(GNU Bourne-Again Shell )是一个为GNU计划编写的Unix shell,它是许多Linux平台默认使用的shell。

shell是一个命令解释器,是一个介于操作系统内核与用户之间的绝缘层。准确地说,他也是能力很强的计算机语言,被称为解释性语言或脚本语言。它可以通过将系统调用、公共程序、工具和编译过的二进制程序“粘合”在一起来建立应用,这是大多数脚本语言的共同特征,所以有时候脚本语言又称为“胶水语言”。

事实上,所有的UNIX命令和工具再加上公共程序,对于shell脚本来说,都是可调用的。Shell脚本对于管理系统任务和其他的重复工作的例程来说,表现得非常好,根本不需要那些华而不实的成熟紧凑的编译型程序语言。

2. 初步练习

1.Hello World

行首以 # 开头(除#!之外)的是注释。#!是用于指定当前脚本的解释器,我们这里为bash,且应该指明完整路径,所以为/bin/bash

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ vim hello.sh #使用vim编辑hello.sh
echo Hello World #向文件中输入以下内容
# 运行Bash脚本的方式
# 1 使用shell来执行
$ sh hello.sh
# 2 使用bash来执行
$ bash hello.sh
# 3 使用.来执行
$ . ./hello.sh
# 4 使用source来执行
$ source hello.sh
# 5 还可以赋予脚本所有者执行权限,允许用户执行该脚本
$ chmod u+rx hello.sh
$ ./hello.sh

2. 使用重定向

比如我们想要保存刚刚的hello world为一个文本,那么该怎么办呢?

==>==是重定向,会在当前目录下生成一个my.txt

1
2
3
4
#!/bin/bash
$ echo "Hello World" > my.txt
$ cat my.txt
# 输出Hello World

3. 使用脚本清除/var/log/wtmp里边的东西

说白了就是在脚本文件中写入命令,然后在外部使用bash命令调用sh文件(实验内容为编写cleanlogs.sh文件,然后使用命令调用该文件)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 先查看wtmp文件中是否有东西
cat /var/log/wtmp

# 使用vim编辑 cleanlogs.sh

######################################
####以下内容为cleanlogs.sh文件内容####
#!/bin/bash

# 初始化一个变量
LOG_DIR=/var/log

cd $LOG_DIR

cat /dev/null > wtmp

echo "Logs cleaned up."

exit
######################################


sudo ./cleanlogs.sh
  • 由于脚本中含有对系统日志文件的清楚操作,这要求要有管理员权限.不然会报permission denied错误

    使用sudo命令调用管理员权限才能执行成功:

    $ sudo ./cleanlogs.sh

  • #!/bin/bash这一行是表示使用/bin/bash作为脚本的解释器,这行要放在脚本的行首并且不要省略

  • 脚本正文中以#号开头的行都是注释语句,这些行在脚本的实际执行过程中不会被执行。这些注释语句能方便我们在脚本中做一些注释或标记,让脚本更具可读性。

1. 遇到权限不够的提示,为什么,如何解决?

权限不够加sudo啊,可是你会发现

sudo cat /dev/null > /var/log/wtmp 一样会提示权限不够,为什么呢?因为sudo只能让cat命令以sudo的权限执行,而对于>这个符号并没有sudo的权限,我们可以使用

sudo sh -c "cat /dev/null > /var/log/wtmp " 让整个命令都具有sudo的权限执行

2. 为什么cleanlogs.sh可以将log文件清除?

因为/dev/null ,里面是空的,重定向到 /var/log/wtmp 文件后,就清空了 wtmp 文件的内容。

3. 简单热身——新建|复制|修改|清楚

1. 步骤一 新建一个test.sh 输出Hello Shiyanlou!

1
2
3
4
5
6
7
8
#题目未要求文件路劲 直接新建并输出
echo "Hello Shiyanlou!" > test.sh
#或者
touch /home/shiyanlou/test.sh
cat > /home/shiyanlou/test.sh << EOF
#!/bin/bash
echo "Hello Shiyanlou!"
EOF

2. 步骤二复制test.sh为test2.sh,修改test2.sh实验将Hello Shiyanlou 保存为my.txt文本

1
2
3
4
5
6
#复制语句
cp /home/shiyanlou/test{,2}.sh

#修改test2.sh的代码为:
#!/bin/bash
echo "Hello Shiyanlou!" > my.txt

3. 步骤三新建一个cleantest.sh脚本运行实现清空test.sh里的内容

1
2
3
4
5
6
7
$ touch /home/shiyanlou/cleantest.sh
$ cat > /home/shiyanlou/cleantest.sh << EOF
###cleantest.sh文件内容####
#!/bin/bash
cat /dev/null > test.sh
EOF
##########################

4. 特殊字符

1. 注释(#)

行首以 # 开头(除#!之外)的是注释。#!是用于指定当前脚本的解释器,我们这里为bash,且应该指明完整路径,所以为/bin/bash

当然,在echo中转义的 # 是不能作为注释的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#创建一个test.sh文件
$ vim test.sh

########test.sh##########
#!/bin/bash

echo "The # here does not begin a comment."
echo 'The # here does not begin a comment.'
echo The \# here does not begin a comment.
echo The # 这里开始一个注释
echo $(( 2#101011 )) # 数制转换(使用二进制表示),不是一个注释,双括号表示对于数字的处理

# 欢迎来到实验楼参观学习
#########################

2. 分号(;)

1. 命令分隔符

使用分号(;)可以在同一行上写两个或两个以上的命令。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
$vim test2.sh


# test2.sh #
#!/bin/bash
echo hello; echo there
filename=ttt.sh
if [ -e "$filename" ]; then # 注意: "if"和"then"需要分隔,-e用于判断文件是否存在
echo "File $filename exists."; cp $filename $filename.bak
else
echo "File $filename not found."; touch $filename
fi; echo "File test complete."

###############


#执行文件
bash test2.sh #结果如下如所示↓

image-20200815001913808

解释说明

上面脚本使用了一个if分支判断一个文件是否存在,如果文件存在打印相关信息并将该文件备份;如果不存在打印相关信息并创建一个新的文件。最后将输出”测试完成”。

2. 终止case选项(双分号)

使用双分号(;;)可以终止case选项

1
2
3
4
5
6
7
8
9
10
11
12
13
$ vim test3.sh

# test3.sh #
varnaem = b
case "$varname" in
[a-z]) echo "abc";;
[0-9]) echo "123";;
esac
#################

#执行脚本
bash test3.sh
#输出abc

3. 点号(.)

==等价于source命令==

4. 引号

1. 双引号

“STRING”将会阻止(解释)STRING中大部分特殊的字符

2. 单引号

‘STRING’将会阻止STRING中所有特殊字符的解释,这是一种比使用“更强烈的形式。

2-4-1

同样是$HOME,单引号会直接认为是字符,而双引号会认为是一个变量

5. 斜线和反斜线

1. 斜线(/)——文件路径分隔符

2. 反斜线(\)——转义符

  • 符号 说明
  • \n 表示新的一行
  • \r 表示回车
  • \t 表示水平制表符
  • \v 表示垂直制表符
  • \b 表示后退符
  • \a 表示”alert”(蜂鸣或者闪烁)
  • \0xx 转换为八进制的ASCII码, 等价于0xx
  • “ 表示引号字面的意思

6. 反引号(`)

命令替换

反引号中的命令会优先执行,如:

1
2
$ cp `mkdir back` test.sh back
$ ls

7. 冒号(:)

1. 空命令

等价于“NOP”(no op ,一个什么也不干的命令)。也可以被认为与shell的内建命令==true==作用相同

2. 变量扩展/子串替换

1
2
3
$ : > test.sh   # 文件“test.sh”现在被清空了
# 与 cat /dev/null > test.sh 的作用相同
# 然而,这并不会产生一个新的进程, 因为“:”是一个内建命令

“:”还用来在 /etc/passwd$PATH 变量中做分隔符,如:

1
2
$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/sbin:/usr/sbin:/usr/games

8. 问号(?)——三元操作符

1
2
3
4
5
#!/bin/bash

a=10
(( t=a<50?8:9 ))
echo $t

9. 美元符号

变量替换

10. 小括号

1. 命令组

在括号中的变量,由于是在子shell中,所以对于脚本剩下的部分是不可用的。父进程,也就是脚本本身,将不能够读取在子进程中创建的变量,也就是在子shell 中创建的变量。如:

1
$ vim test20.sh

输入代码:

1
2
3
4
5
6
#!/bin/bash

a=123
( a=321; )

echo "$a" #a的值为123而不是321,因为括号将判断为局部变量

运行代码:

1
2
$ bash test20.sh
a = 123

在圆括号中 a 变量,更像是一个局部变量。

2.初始化数组

创建数组

1
$ vim test21.sh

输入代码:

1
2
3
4
#!/bin/bash

arr=(1 4 5 7 9 21)
echo ${arr[3]} # get a value of arr

运行代码:

1
2
$ bash test21.sh
7

11. 大括号

1.文件名扩展

复制 t.txt 的内容到 t.back 中

1
$ vim test22.sh

输入代码:

1
2
3
4
5
6
7
8
#!/bin/bash

if [ ! -w 't.txt' ];
then
touch t.txt
fi
echo 'test text' >> t.txt
cp t.{txt,back}

运行代码:

1
$ bash test22.sh

查看运行结果:

1
2
3
$ ls
$ cat t.txt
$ cat t.back

注意: 在大括号中,不允许有空白,除非这个空白被引用或转义。

2.代码块

代码块,又被称为内部组,这个结构事实上创建了一个匿名函数(一个没有名字的函数)。然而,与“标准”函数不同的是,在其中声明的变量,对于脚本其他部分的代码来说还是可见的。

1
$ vim test23.sh

输入代码:

1
2
3
4
5
#!/bin/bash

a=123
{ a=321; }
echo "a = $a"

运行代码:

1
2
$ bash test23.sh
a = 321

变量 a 的值被更改了。

12. 中括号

1.条件测试

条件测试表达式放在[ ]中。下列练习中的-lt (less than)表示小于号。

1
$ vim test24.sh

输入代码:

1
2
3
4
5
6
7
8
9
#!/bin/bash

a=5
if [ $a -lt 10 ]
then
echo "a: $a"
else
echo 'a>=10'
fi

运行代码:

1
2
$ bash test24.sh
a: 5

双中括号([[ ]])也用作条件测试(判断),后面的实验会详细讲解。

2.数组元素

在一个array结构的上下文中,中括号用来引用数组中每个元素的编号。

1
$ vim test25.sh

输入代码:

1
2
3
4
5
#!/bin/bash

arr=(12 22 32)
arr[0]=10
echo ${arr[0]}

运行代码:

1
2
$ bash test25.sh
10

13. 尖括号

重定向

test.sh > filename:重定向test.sh的输出到文件 filename 中。如果 filename 存在的话,那么将会被==覆盖==。

test.sh &> filename:重定向 test.sh 的 stdout(标准输出)和 stderr(标准错误)到 filename 中。

test.sh >&2:重定向 test.sh 的 stdout 到 stderr 中。

test.sh >> filename:把 test.sh 的输出==追加==到文件 filename 中。如果filename 不存在的话,将会被创建。

14. 竖线(|)

管道

分析前边命令的输出,并将输出作为后边命令的输入。这是一种产生命令链的好方法。

1
$ vim test26.sh

输入代码:

1
2
3
4
#!/bin/bash

tr 'a-z' 'A-Z'
exit 0

现在让我们输送ls -l的输出到一个脚本中:

1
2
$ chmod 755 test26.sh
$ ls -l | ./test26.sh

输出的内容均变为了大写字母。

15. 破折号(-)

1.选项,前缀

在所有的命令内如果想使用选项参数的话,前边都要加上“-”。

1
$ vim test27.sh

输入代码:

1
2
3
4
5
6
7
8
#!/bin/bash

a=5
b=5
if [ "$a" -eq "$b" ]
then
echo "a is equal to b."
fi

运行代码:

1
2
$ bash test27.sh
a is equal to b.

2.用于重定向stdin或stdout

下面脚本用于备份最后24小时当前目录下所有修改的文件.

1
$ vim test28.sh

输入代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/bash

BACKUPFILE=backup-$(date +%m-%d-%Y)
# 在备份文件中嵌入时间.
archive=${1:-$BACKUPFILE}
# 如果在命令行中没有指定备份文件的文件名,
# 那么将默认使用"backup-MM-DD-YYYY.tar.gz".

tar cvf - `find . -mtime -1 -type f -print` > $archive.tar
gzip $archive.tar
echo "Directory $PWD backed up in archive file \"$archive.tar.gz\"."

exit 0

运行代码:

1
2
$ bash test28.sh
$ ls

16. 波浪号(~)——表示home目录

5. 变量和参数

1. 变量定义

1.概念

变量的名字就是变量保存值的地方。引用变量的值就叫做变量替换。

如果 variable 是一个变量的名字,那么 $variable 就是引用这个变量的值,即这变量所包含的数据。

$variable 事实上只是 ${variable} 的简写形式。在某些上下文中 $variable 可能会引起错误,这时候你就需要用 ${variable} 了。

2.定义变量

定义变量时,变量名不加美元符号($,PHP语言中变量需要),如: myname=”shiyanlou”

注意

变量名和等号之间不能有空格。同时,变量名的命名须遵循如下规则:

  • 首个字符必须为字母(a-z,A-Z)。
  • 中间不能有空格,可以使用下划线(_)。
  • 不能使用标点符号。
  • 不能使用bash里的关键字(可用help命令查看保留关键字)。

除了直接赋值,还可以用语句给变量赋值,如:for file in ls /etc

2. 使用变量

变量名前加美元符号,如:

1
2
3
4
5
6
7
8
myname="shiyanlou"
echo $myname
echo ${myname}
echo ${myname}Good
echo $mynameGood

myname="miao"
echo ${myname}

花括号帮助解释器识别变量的边界,若不加,解释器会把mynameGood当成一个变量(值为空)

推荐给所有变量加花括号

已定义的变量可以重新被定义

3. 只读变量

使用 readonly 命令可以将变量定义为只读变量,只读变量的值不能被改变。 下面的例子尝试更改只读变量,结果报错:

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

运行脚本,结果如下:

1
/bin/sh: NAME: This variable is read only.

4. 特殊变量

1.局部变量

这种变量只有在代码块或者函数中才可见。后面的实验会详细讲解。

2.环境变量

这种变量将影响用户接口和 shell 的行为。

在通常情况下,每个进程都有自己的“环境”,这个环境是由一组变量组成的,这些变量中存有进程可能需要引用的信息。在这种情况下,shell 与一个一般的进程没什么区别。

3.位置参数

从命令行传递到脚本的参数:0,0,1,2,2,3…

0就是脚本文件自身的名字,0就是脚本文件自身的名字,1 是第一个参数,2 是第二个参数,2是第二个参数,3 是第三个参数,然后是第四个。9 之后的位置参数就必须用大括号括起来了,比如,9之后的位置参数就必须用大括号括起来了,比如,{10},{11},11,{12}。

  • $# : 传递到脚本的参数个数
  • $* : 以一个单字符串显示所有向脚本传递的参数。与位置变量不同,此选项参数可超过 9个
  • $$$$ : 脚本运行的当前进程 ID号
  • $! : 后台运行的最后一个进程的进程 ID号
  • $@ : 与$*相同,但是使用时加引号,并在引号中返回每个参数
  • $: 显示shell使用的当前选项,与 set命令功能相同
  • $? : 显示最后命令的退出状态。 0表示没有错误,其他任何值表明有错误。
4.位置参数实例

这个十分重要,在我们运行一套脚本的时候,有时候是需要参数的,这里我们教大家如何获取参数

1
$ vim test30.sh

输入代码(中文皆为注释,不用输入):

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
39
40
41
42
#!/bin/bash

# 作为用例, 调用这个脚本至少需要10个参数, 比如:
# bash test.sh 1 2 3 4 5 6 7 8 9 10
MINPARAMS=10

echo

echo "The name of this script is \"$0\"."

echo "The name of this script is \"`basename $0`\"."


echo

if [ -n "$1" ] # 测试变量被引用.
then
echo "Parameter #1 is $1" # 需要引用才能够转义"#"
fi

if [ -n "$2" ]
then
echo "Parameter #2 is $2"
fi

if [ -n "${10}" ] # 大于$9的参数必须用{}括起来.
then
echo "Parameter #10 is ${10}"
fi

echo "-----------------------------------"
echo "All the command-line parameters are: "$*""

if [ $# -lt "$MINPARAMS" ]
then
echo
echo "This script needs at least $MINPARAMS command-line arguments!"
fi

echo

exit 0

运行代码:

1
2
3
4
5
6
7
8
9
10
11
12
$ bash test30.sh 1 2 10


The name of this script is "test.sh".
The name of this script is "test.sh".

Parameter #1 is 1
Parameter #2 is 2
-----------------------------------
All the command-line parameters are: 1 2 10

This script needs at least 10 command-line arguments!

6. 基本运算符

1. 算数运算符

5-1-1

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
$vim test.sh
#!/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

运行

1
2
3
4
5
6
7
$bash test.sh
a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a != b
  • 原生bash不支持简单的数学运算,但是可以通过其他命令来实现,例如 awkexprexpr 最常用。
  • expr 是一款表达式计算工具,使用它能完成表达式的求值操作。
  • 注意使用的反引号(esc键下边)
  • 表达式和运算符之间要有空格$a + $b写成$a+$b不行
  • 条件表达式要放在方括号之间,并且要有空格[ $a == $b ]写成[$a==$b]不行
  • 乘号(*)前边必须加反斜杠(\)才能实现乘法运算

2. 关系运算符(大于、小于、等于)

运算符 说明
-eq 检测两个数是否相等,相等返回true.
-ne 检测两个数是都相等,不相等返回true
-gt 检测左边的数是否大于右边的,如果是,则返回true
-lt 检测左边的数是否小于右边的,如果是,则返回true
-ge 检测左边的数是否大于右边的,如果是,则返回true
-le 检测左边的数是否小于右边的,如果是,则返回true

3. 逻辑运算符

运算符 说明
&& 逻辑的AND
\ \ 逻辑的OR

4. 字符运算符

运算符 说明
= 检测两个字符串是否相等,相等则返回true
!= 检测两个字符串是否相等,不相等则返回true
-z 检测两个字符串长度是否为0,为0则返回true
-n 检测两个字符串长度是否为0,不为0则返回true
str 检测字符串是否为空,不为空返回true

5. 文件测试运算符

5-5-1

6. 浮点运算(小数运算)

浮点运算,比如实现求圆的面积和周长。

expr 只能用于整数计算,可以使用 bc 或者 awk 进行浮点数运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/bash

raduis=2.4

pi=3.14159

girth=$(echo "scale=4; 3.14 * 2 * $raduis" | bc)

area=$(echo "scale=4; 3.14 * $raduis * $raduis" | bc)

echo "girth=$girth"

echo "area=$area"

以上代码如果想在环境中运行,需要先安装 bc

1
2
$ sudo apt-get update
$ sudo apt-get install bc

7. 流程控制(if-else)

1. if else

和Java、PHP等语言不一样,sh的流程控制不可为空

在sh/bash里可不能这么写,如果else分支没有语句执行,就不要写这个else。

1.if

if 语句语法格式:

1
2
3
4
5
6
7
if condition
then
command1
command2
...
commandN
fi

2.if else

if else 语法格式:

1
2
3
4
5
6
7
8
9
if condition
then
command1
command2
...
commandN
else
command
fi

if-elif-else 语法格式:

1
2
3
4
5
6
7
8
9
if condition1
then
command1
elif condition2
then
command2
else
commandN
fi

以下实例判断两个变量是否相等:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a=10
b=20
if [ $a == $b ]
then
echo "a == b"
elif [ $a -gt $b ]
then
echo "a > b"
elif [ $a -lt $b ]
then
echo "a < b"
else
echo "Ineligible"
fi

输出结果:

1
a < b

if else语句经常与test命令结合使用

1
2
3
4
5
6
7
8
num1=$[2*3]
num2=$[1+5]
if test $[num1] -eq $[num2]
then
echo 'Two numbers are equal!'
else
echo 'The two numbers are not equal!'
fi

输出结果:

1
Two numbers are equal!

2. for循环

for循环一般格式为:

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

例如,顺序输出当前列表中的数字:

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

输出结果:

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

顺序输出字符串中的字符:

1
2
3
4
for str in This is a string
do
echo $str
done

输出结果:

1
2
3
4
This
is
a
string

for循环高级用法

1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/bash
PREFIX=192.168.1.
for i in `seq 100 110`
do
  echo -n "${PREFIX}$i "
  ping -c5 ${PREFIX}${i} >/dev/null 2>&1
  if [ "$?" -eq 0 ];then
    echo "OK"
  else
    echo "Failed"
  fi
done

3. while语句

while循环用于不断执行一系列命令,也用于从输入文件中读取数据;命令通常为测试条件。其格式为:

1
2
3
4
5
6
7
8
9
10
11
while condition
do
command
done
#!/bin/bash
int=1
while(( $int<=5 ))
do
echo $int
let "int++"
done

运行脚本,输出:

1
2
3
4
5
1
2
3
4
5
  • 如果int小于等于5,那么条件返回真。int从1开始,每次循环处理时,int加1。运行上述脚本,返回数字1到5,然后终止。
  • 使用了 Bash let 命令,它用于执行一个或多个表达式,变量计算中不需要加上 $ 来表示变量

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

1
2
3
4
5
6
echo 'press <CTRL-D> exit'
echo -n 'Who do you think is the most handsome: '
while read MAN
do
echo "Yes!$MAN is really handsome"
done

4. 无限循环

无限循环语法格式:

1
2
3
4
5
6
7
8
9
while :
do
command
done
或者
while true
do
command
done

或者

1
for (( ; ; ))
  1. until循环

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

1
2
3
4
until condition
do
command
done

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

  1. case

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
casein
模式1)
command1
command2
...
commandN
;;
模式2)
command1
command2
...
commandN
;;
esac
  • 取值后面必须为单词in,每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后,其间所有命令开始执行直至 ;;
  • 取值将检测匹配的每一个模式。一旦模式匹配,则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式,使用星号 * 捕获该值,再执行后面的命令。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
echo 'Enter a number between 1 and 4:'
echo 'The number you entered is:'
read aNum
case $aNum in
1) echo 'You have chosen 1'
;;
2) echo 'You have chosen 2'
;;
3) echo 'You have chosen 3'
;;
4) echo 'You have chosen 4'
;;
*) echo 'You did not enter a number between 1 and 4'
;;
esac

输入不同的内容,会有不同的结果,例如:

1
2
3
4
Enter a number between 1 and 4:
The number you entered is:
3
You have chosen 3

7. 跳出循环

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

==break命令==

break命令允许跳出所有循环(终止执行后面的所有循环)。 下面的例子中,脚本进入死循环直至用户输入数字大于5。要跳出这个循环,返回到shell提示符下,需要使用break命令。

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/bash
while :
do
echo -n "Enter a number between 1 and 5:"
read aNum
case $aNum in
1|2|3|4|5) echo "The number you entered is $aNum!"
;;
*) echo "The number you entered is not between 1 and 5! game over!"
break
;;
esac
done

执行以上代码,输出结果为:

1
2
3
4
Enter a number between 1 and 5:3
The number you entered is 3!
Enter a number between 1 and 5:7
The number you entered is not between 1 and 5! game over!

8. continue

continue命令与break命令类似,只有一点差别,它不会跳出所有循环,仅仅跳出当前循环。 对上面的例子进行修改:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/bin/bash
while :
do
echo -n "Enter a number between 1 and 5: "
read aNum
case $aNum in
1|2|3|4|5) echo "The number you entered is $aNum!"
;;
*) echo "The number you entered is not between 1 and 5!"
continue
echo "game over"
;;
esac
done

运行代码发现,当输入大于5的数字时,该例中的循环不会结束,语句 echo "Game is over!" 永远不会被执行。

9. esac

case的语法和C family语言差别很大,它需要一个esac(就是case反过来)作为结束标记,每个case分支用右圆括号,用两个分号表示break。

8. 函数

1. 函数定义

shell中函数的定义格式如下:

1
2
3
4
5
6
7
8
9
[ function ] funname [()]

{

action;

[return int;]

}

说明:

  • 可以带function fun() 定义,也可以直接fun() 定义,不带任何参数。

  • 参数返回,可以显示加:return 返回,如果不加,将以最后一条命令运行结果,作为返回值。 return后跟数值n(0-255)

下面的例子定义了一个函数并进行调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/bin/bash

demoFun(){
echo "This is my first shell function!"
}
echo "-----Execution-----"
demoFun
echo "-----Finished-----"


Output the result:
-----Execution-----
This is my first shell function!
-----Finished-----

下面定义一个带有return语句的函数:

1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/bash
funWithReturn(){
echo "This function will add the two numbers of the input..."
echo "Enter the first number: "
read aNum
echo "Enter the second number: "
read anotherNum
echo "The two numbers are $aNum and $anotherNum !"
return $(($aNum+$anotherNum))
}
funWithReturn
echo "The sum of the two numbers entered is $? !"

输出类似下面:

1
2
3
4
5
6
7
This function will add the two numbers of the input...
Enter the first number:
1
Enter the second number:
2
The two numbers are 1 and 2 !
The sum of the two numbers entered is 3 !
  • 函数返回值在调用该函数后通过 $? 来获得

  • 所有函数在使用前必须定义。

2. 函数参数

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

1
2
3
4
5
6
7
8
9
10
11
#!/bin/bash
funWithParam(){
echo "The first parameter is $1 !"
echo "The second parameter is $2 !"
echo "The tenth parameter is $10 !"
echo "The tenth parameter is ${10} !"
echo "The eleventh parameter is ${11} !"
echo "The total number of parameters is $# !"
echo "Outputs all parameters as a string $* !"
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73

输出结果:

1
2
3
4
5
6
7
The first parameter is 1 !
The second parameter is 2 !
The tenth parameter is 10 !
The tenth parameter is 34 !
The eleventh parameter is 73 !
The total number of parameters is 11 !
Outputs all parameters as a string 1 2 3 4 5 6 7 8 9 34 73 !

注意

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