声明:看了这个,只能是对shell的语法有了认识,编程是一种技能,讲究熟能生巧。如果想真的掌握shell编程,请写大量的shell脚本进行练习。
什么是shell
Shell 是一个用 C 语言编写的程序,它是用户使用 Linux 的桥梁。Shell 既是一种命令语言,又是一种程序设计语言。
Shell 是指一种应用程序,这个应用程序提供了一个界面,用户通过这个界面访问操作系统内核的服务。
Ken Thompson 的 sh 是第一种 Unix Shell,Windows Explorer 是一个典型的图形界面 Shell。
Linux 的 Shell 种类众多,常见的有:
- Bourne Shell(/usr/bin/sh或/bin/sh)
- Bourne Again Shell(/bin/bash)
- C Shell(/usr/bin/csh)
- K Shell(/usr/bin/ksh)
- Shell for Root(/sbin/sh)
本教程关注的是 Bash,也就是 Bourne Again Shell,由于易用和免费,Bash 在日常工作中被广泛使用。同时,Bash 也是大多数Linux 系统默认的 Shell。
在一般情况下,人们并不区分 Bourne Shell
和 Bourne Again Shell
,所以,像 #!/bin/sh
,它同样也可以改为 #!/bin/bash
。
#!
告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell
程序。
打开文本编辑器(可以使用 vi/vim 命令来创建文件),新建一个文件 test.sh,扩展名为 sh(sh代表shell),扩展名并不影响脚本执行,见名知意就好,如果你用 php 写 shell 脚本,扩展名就用 php 好了。
#!/bin/bash
echo "Hello World !"
运行 Shell 脚本有两种方法:
- 作为可执行程序
- 作为解释器参数
1、作为可执行程序:
将上面的代码保存为 test.sh,并 cd 到相应目录:
chmod +x ./test.sh #使脚本具有执行权限
./test.sh #执行脚本
注意,一定要写成 ./test.sh
,而不是 test.sh
,运行其它二进制的程序也一样,直接写 test.sh
,linux
系统会去 PATH
里寻找有没有叫 test.sh
的,而只有 /bin, /sbin, /usr/bin,/usr/sbin
等在 PATH
里,你的当前目录通常不在 PATH
里,所以写成 test.sh
是会找不到命令的,要用 ./test.sh
告诉系统说,就在当前目录找。
2、作为解释器参数:
这种运行方式是,直接运行解释器,其参数就是 shell 脚本的文件名,如:
/bin/sh test.sh
/bin/php test.php
这种方式运行的脚本,不需要在第一行指定解释器信息,写了也没用。
Shell 变量
定义变量时,变量名不加美元符号($,PHP语言中变量需要),如:
your_name="runoob.com"
注意,变量名和等号之间不能有空格,这可能和你熟悉的所有编程语言都不一样。同时,变量名的命名须遵循如下规则:
- 命名只能使用英文字母,数字和下划线,首个字符不能以数字开头。
- 中间不能有空格,可以使用下划线(_)。
- 不能使用标点符号。
- 不能使用bash里的关键字(可用help命令查看保留关键字)。
除了显式地直接赋值,还可以用语句给变量赋值,有两种方式
- 运用
$
- 运用两个反斜点(esc下面那个,CSDN打不出来)
示例:
for file in `ls /etc`
或
for file in $(ls /etc)
以上语句将 /etc 下目录的文件名循环出来。
使用变量
使用一个定义过的变量,只要在变量名前面加美元符号即可,如:
your_name="qinjx"
echo $your_name
echo ${your_name}
变量名外面的花括号是可选的,加不加都行,加花括号是为了帮助解释器识别变量的边界,比如下面这种情况:
for skill in Ada Coffe Action Java; do
echo "I am good at ${skill}Script"
done
如果不给skill变量加花括号,写成echo "I am good at $skillScript"
,解释器就会把$skillScript
当成一个变量(其值为空),代码执行结果就不是我们期望的样子了。
推荐给所有变量加上花括号,这是个好的编程习惯。
已定义的变量,可以被重新定义,如:
your_name="tom"
echo $your_name
your_name="alibaba"
echo $your_name
这样写是合法的,但注意,第二次赋值的时候不能写$your_name="alibaba"
,使用变量的时候才加美元符($)。
删除变量
使用 unset
命令可以删除变量。语法:
unset variable_name
变量被删除后不能再次使用。unset 命令不能删除只读变量。
变量类型
运行shell时,会同时存在三种变量:
- 局部变量 局部变量在脚本或命令中定义,仅在当前shell实例中有效,其他shell启动的程序不能访问局部变量。
- 环境变量 所有的程序,包括shell启动的程序,都能访问环境变量,有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
- shell变量 shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量,有一部分是局部变量,这些变量保证了shell的正常运行
Shell 字符串
字符串是shell编程中最常用最有用的数据类型(除了数字和字符串,也没啥其它类型好用了),字符串可以用单引号,也可以用双引号,也可以不用引号。
单双引号的区别跟PHP类似。
单引号属于强引用,它会忽略所有被引起来的字符的特殊处理,被引用起来的字符会被原封不动的使用,唯一需要注意的点是不允许引用自身。
双引号属于弱引用,它会对一些被引起来的字符进行特殊处理,主要包括以下情况:
- $加变量名可以取变量的值
- 反引号和$()引起来的字符会被当做命令执行后替换原来的字符
- 当需要使用字符($ ` " \)时必须进行转义,也就是在前面加\
示例:
[root@localhost ~]# echo '$PWD'
$PWD
[root@localhost ~]# echo "$PWD"
/root
[root@localhost ~]# echo '$(echo hello world)'
$(echo hello world)
[root@localhost ~]# echo "$(echo hello world)"
hello world
[root@localhost ~]# echo '`echo hello world`'
`echo hello world`
[root@localhost ~]# echo "`echo hello world`"
hello world
[root@localhost ~]# echo '$ ` " \'
$ ` " \
[root@localhost ~]# echo "\$ \` \" \\"
$ ` " \
拼接字符串
跟python
一样,把几个字符串写一起就成了拼接字符串。
# 使用双引号拼接
greeting="hello, "$your_name" !" # 请注意,字符串与字符串之间不要有空格
greeting_1="hello, ${your_name} !"
获取字符串长度
string="abcd"
echo ${#string} #输出 4
提取子字符串
以下实例从字符串第 2 个字符开始截取 4 个字符:
string="runoob is a great site"
echo ${string:1:4} # 输出 unoo
# 第一个数,一定要是大于等于0的数
# 第二个数,是正数时,表示匹配串的长度
# 是负数时,表示匹配到第几个字符 (类似于python的从后往前分配-1,-2,-3等下标)
查找子字符串
查找字符 i 或 o 的位置(哪个字母先出现就计算哪个):
string="runoob is a great site"
echo `expr index "$string" io` # 输出 4
注意: 以上脚本中 ` 是反引号,而不是单引号 ',不要看错了哦。
Shell 数组
bash支持一维数组(不支持多维数组),并且没有限定数组的大小。
类似于 C 语言,数组元素的下标由 0
开始编号。获取数组中的元素要利用下标,下标可以是整数或算术表达式,其值应大于或等于 0。
定义数组
在 Shell 中,用括号来表示数组,数组元素用"空格"符号分割开。定义数组的一般形式为:
数组名=(值1 值2 ... 值n)
例如:
array_name=(value0 value1 value2 value3)
或者:
array_name=(
value0
value1
value2
value3
)
还可以单独定义数组的各个分量:
array_name[0]=value0
array_name[1]=value1
array_name[n]=valuen
可以不使用连续的下标,而且下标的范围没有限制。
读取数组
读取数组元素值的一般格式是:
${数组名[下标]}
例如:
valuen=${array_name[n]}
使用 @ 符号可以获取数组中的所有元素,例如:
echo ${array_name[@]}
获取数组的长度
获取数组长度的方法与获取字符串长度的方法相同,例如:
# 取得数组元素的个数
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得数组单个元素的长度
lengthn=${#array_name[n]}
Shell 注释
以 # 开头的行就是注释,会被解释器忽略。这个和python是一样的。
也可以用多行注释:
:<<EOF
注释内容...
注释内容...
注释内容...
EOF
注意EOF可以替换成别的字符。
Shell 传递参数
我们可以在执行 Shell 脚本时,向脚本传递参数,脚本内获取参数的格式为:$n
。n
代表一个数字,1
为执行脚本的第一个参数,2
为执行脚本的第二个参数,以此类推……
示例:
以下实例我们向脚本传递三个参数,并分别输出,其中 $0
为执行的文件名:
# author:vth
echo "shell 传递参数实例!";
echo "执行的文件名:$0";
echo "第一个参数为:$1";
echo "第二个参数为:$2";
echo "第三个参数为:$3";
输出:
[root@vth 20190408]# sh test.sh a b c
shell 传递参数实例!
执行的文件名:test.sh
第一个参数为:a
第二个参数为:b
第三个参数为:c
另外,还有几个特殊字符用来处理参数:
实例:
#!/bin/bash
# author:vth
echo "shell 传递参数实例!";
echo "执行的文件名:$0";
echo "第一个参数为:$1";
echo "第二个参数为:$2";
echo "第三个参数为:$3";
echo "$#";
echo "$*";
结果:
[root@vth 20190408]# sh test.sh a b c
shell 传递参数实例!
执行的文件名:test.sh
第一个参数为:a
第二个参数为:b
第三个参数为:c
3
a b c
$*
与 $@
区别:
相同点:都是引用所有参数。
不同点:只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3,,则 " *
" 等价于 "1 2 3"
(传递了一个参数),而 “@
” 等价于 "1" "2" "3"
(传递了三个参数)。
意思大概是这样的,$*
把所有参数收集成一个参数,$@
就不这样。
Shell 数组
数组中可以存放多个值。Bash Shell
只支持一维数组(不支持多维数组),初始化时不需要定义数组大小(与 PHP
类似)。
与大部分编程语言类似,数组元素的下标由0
开始。
Shell
数组用括号来表示,元素用"空格"符号分割开,语法格式如下:
array_name=(value1 ... valuen)
示例:
#!/bin/bash
# author:vth
my_array=(A B "C" D)
我们也可以使用下标来定义数组:
array_name[0]=value0
array_name[1]=value1
array_name[2]=value2
读取数组
读取数组元素值的一般格式是:
${array_name[index]}
示例:
arr=(1 2 3 4 5 "s" "a") # 第一种定义数组的方式
echo ${arr[0]}
echo ${arr[1]}
echo ${arr[2]}
echo ${arr[3]}
echo ${arr[4]}
echo ${arr[5]}
arr1[0]="b" # 第二种
arr1[3]="c" # 注意并没有连续
echo ${arr1[0]}
echo ${arr1[1]}
echo ${arr1[2]}
echo ${arr1[3]}
结果:
1
2
3
4
5
s
b
c
获取数组中的所有元素
使用@
或 *
可以获取数组中的所有元素,例如:
示例:
arr=(1 2 3 4 5 "s" "a")
arr1[0]="b"
arr1[3]="c"
echo "数组的元素为: ${arr[*]}"
echo "数组的元素为: ${arr[@]}"
echo "数组的元素为: ${arr1[*]}"
echo "数组的元素为: ${arr1[@]}"
结果:
数组的元素为: 1 2 3 4 5 s a
数组的元素为: 1 2 3 4 5 s a
数组的元素为: b c
数组的元素为: b c
获取数组的长度
获取数组长度的方法与获取字符串长度的方法相同,只需要在前面加上#
就可以了。例如:
示例:
arr=(1 2 3 4 5 "s" "a")
arr1[0]="b"
arr1[3]="c"
echo "数组的元素为: ${#arr[*]}"
echo "数组的元素为: ${#arr[@]}"
echo "数组的元素为: ${#arr1[*]}"
echo "数组的元素为: ${#arr1[@]}"
结果:
数组的元素为: 7
数组的元素为: 7
数组的元素为: 2
数组的元素为: 2
Shell 基本运算符
Shell 和其他编程语言一样,支持多种运算符,包括:
- 算数运算符
- 关系运算符
- 布尔运算符
- 字符串运算符
- 文件测试运算符
原生bash不支持简单的数学运算,但是可以通过其他命令来实现,例如awk
和expr
,expr
最常用。
expr
是一款表达式计算工具,使用它能完成表达式的求值操作。
例如,两个数相加(注意使用的是反引号 ` 而不是单引号 '):
示例:
val=`expr 2 + 3` # 注意,expr不能用乘法,不知道为啥
# 更新,expr可以用乘法,只不过需要转义
# 而且expr后面的表达式必须是用空格隔开的,不然会报语法错误
echo "和为:${val}"
val=`expr 3 - 1`
echo "差为:${val}"
val=`expr 7 / 3` # 注意expr弄出来的只能整除,向下取整
echo "商为:${val}"
val=`expr 100 / 4`
echo "商为:${val}"
输出:
和为:5
差为:2
商为:2
商为:25
有两点需要注意的:
- 表达式和运算符之间要有空格,例如
2+2
是不对的,必须写成2 + 2
,这与我们熟悉的大多数编程语言不一样。 - 完整的表达式要被 两个` 包含,注意这个字符不是常用的单引号,在 Esc 键下边。
算数运算符
算术运算符实例:
echo `expr 4 + 2`
echo `expr 4 - 2`
echo `expr 4 \* 2`
echo `expr 4 / 2`
echo `expr 4 % 2`
b=1
a=$b #赋值
if [ $a == $b ] # 注意,==连接的两个值和方括号之间都要有空格
then
echo "a等于b"
fi
if [ $a != $b ]
then
echo "a不等于b"
fi
输出:
6
2
8
2
0
a等于b
关系运算符
关系运算符只支持数字,不支持字符串,除非字符串的值是数字,也就是说,数字字符串在shell中是被认为是数字的。
下表列出了常用的关系运算符,假定变量 a 为 10,变量 b 为 20:
助记:
-eq # equal
-ne # no equal
-gt # great than
-lt # low than
-ge # great equal
-le # low equal
实例:
a=10
b=20
if [ $a -eq $b ]
then
echo "$a -eq $b : a 等于 b"
else
echo "$a -eq $b: a 不等于 b"
fi
if [ $a -ne $b ]
then
echo "$a -ne $b: a 不等于 b"
else
echo "$a -ne $b : a 等于 b"
fi
if [ $a -gt $b ]
then
echo "$a -gt $b: a 大于 b"
else
echo "$a -gt $b: a 不大于 b"
fi
if [ $a -lt $b ]
then
echo "$a -lt $b: a 小于 b"
else
echo "$a -lt $b: a 不小于 b"
fi
if [ $a -ge $b ]
then
echo "$a -ge $b: a 大于或等于 b"
else
echo "$a -ge $b: a 小于 b"
fi
if [ $a -le $b ]
then
echo "$a -le $b: a 小于或等于 b"
else
echo "$a -le $b: a 大于 b"
fi
输出:
10 -eq 20: a 不等于 b
10 -ne 20: a 不等于 b
10 -gt 20: a 不大于 b
10 -lt 20: a 小于 b
10 -ge 20: a 小于 b
10 -le 20: a 小于或等于 b
布尔运算符
下表列出了常用的布尔运算符,假定变量 a 为 10,变量 b 为 20:
助记:
-o # or
-a # and
实例:
a=10
b=20
if [ $a != $b ]
then
echo "$a != $b : a 不等于 b"
else
echo "$a != $b: a 等于 b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
echo "$a 小于 100 且 $b 大于 15 : 返回 true"
else
echo "$a 小于 100 且 $b 大于 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
echo "$a 小于 100 或 $b 大于 100 : 返回 true"
else
echo "$a 小于 100 或 $b 大于 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
echo "$a 小于 5 或 $b 大于 100 : 返回 true"
else
echo "$a 小于 5 或 $b 大于 100 : 返回 false"
fi
输出:
10 != 20 : a 不等于 b
10 小于 100 且 20 大于 15 : 返回 true
10 小于 100 或 20 大于 100 : 返回 true
10 小于 5 或 20 大于 100 : 返回 false
逻辑运算符
以下介绍 Shell 的逻辑运算符,假定变量 a 为 10,变量 b 为 20:
实例:
a=10
b=20
if [[ $a -lt 100 && $b -gt 100 ]]
then
echo "返回 true"
else
echo "返回 false"
fi
if [[ $a -lt 100 || $b -gt 100 ]]
then
echo "返回 true"
else
echo "返回 false"
fi
输出:
返回 false
返回 true
字符串运算符
下表列出了常用的字符串运算符,假定变量 a 为 “abc”,变量 b 为 “efg”:
实例:
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
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 : 字符串不为空
文件测试运算符
文件测试运算符用于检测 Unix
文件的各种属性。
属性检测描述如下:
实例:
file="/var/www/runoob/test.sh"
if [ -r $file ]
then
echo "文件可读"
else
echo "文件不可读"
fi
if [ -w $file ]
then
echo "文件可写"
else
echo "文件不可写"
fi
if [ -x $file ]
then
echo "文件可执行"
else
echo "文件不可执行"
fi
if [ -f $file ]
then
echo "文件为普通文件"
else
echo "文件为特殊文件"
fi
if [ -d $file ]
then
echo "文件是个目录"
else
echo "文件不是个目录"
fi
if [ -s $file ]
then
echo "文件不为空"
else
echo "文件为空"
fi
if [ -e $file ]
then
echo "文件存在"
else
echo "文件不存在"
fi
输出:
文件不可读
文件不可写
文件不可执行
文件为特殊文件
文件不是个目录
文件为空
文件不存在
Shell echo命令
Shell
的 echo
指令与 PHP
的 echo
指令类似,都是用于字符串的输出。命令格式:
echo string
1.显示普通字符串:
echo "It is a test"
这里的双引号完全可以省略,以下命令与上面实例效果一致:
echo It is a test
2.显示转义字符
echo "\"It is a test\"" # 用\进行转义
输出:
"It is a test"
同样,双引号也可以省略
echo \"It is a test\" # 用\进行转义
3.显示变量
read 命令从标准输入中读取一行,并把输入行的每个字段的值指定给 shell 变量
实例:
#! /bin/bash
read name
echo "$name"
输出:
输入:vth ccc
vth ccc
再来一个:
#! /bin/bash
read name name1
echo "${name}------${name1}"
输出:
[weitonghui_i@16c32g2t-engine-qa06 20190409]$ sh test.sh
vth zz bjfu
vth------zz bjfu
也就是说,从前往后收集字段,如果变量不够用的,那么最后一个变量收集剩余所有的字段。如果变量比字段多,那么没有分到字段的变量就什么都没有。
4.显示换行
echo -e "OK! \n" # -e 开启转义
echo "It is a test"
输出:
OK!
It is a test
5.显示不换行
#!/bin/sh
echo -e "OK! \c" # -e 开启转义 \c 不换行
echo "It is a test"
输出结果:
OK! It is a test
6.显示结果定向至文件
echo "It is a test" > myfile
7.原样输出字符串,不进行转义或取变量(用单引号)
echo '$name\"'
输出:
$name\"
8.显示命令执行结果
echo `date`
注意: 这里使用的是反引号 `, 而不是单引号 '。
结果将显示当前日期
Thu Jul 24 10:08:46 CST 2014
Shell printf 命令
上一章节我们学习了 Shell 的 echo
命令,本章节我们来学习 Shell 的另一个输出命令 printf
。
printf
命令模仿 C 程序库(library)里的 printf()
程序。
printf
由 POSIX 标准所定义,因此使用 printf
的脚本比使用 echo
移植性好。
printf 使用引用文本或空格分隔的参数,外面可以在 printf 中使用格式化字符串,还可以制定字符串的宽度、左右对齐方式等。默认 printf 不会像 echo 自动添加换行符,我们可以手动添加 \n。
printf 命令的语法:
printf format-string [arguments...]
参数说明:
- format-string: 为格式控制字符串
- arguments: 为参数列表。
实例:
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
总之,除了不加(),还有格式串和参数之间用空格来分隔外,别的都和c一样。
更多实例:
# 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"
输出:
1 abc
1 abc
abcdefabcdefabc
def
a b c
d e f
g h i
j
and 0
printf的转义序列
Shell test 命令
Shell中的 test 命令用于检查某个条件是否成立,它可以进行数值、字符和文件三个方面的测试。
数值测试
num1=100
num2=100
if test $[num1] -eq $[num2]
then
echo '两个数相等!'
else
echo '两个数不相等!'
fi
输出:
两个数相等!
代码中的 []
执行基本的算数运算,如:
#! /bin/bash
a=10
b=2
result=$[a+b]
echo $result
result=$[a-b]
echo $result
result=$[a*b]
echo $result
result=$[a/b]
echo $result
result=$[a%b]
echo $result
输出:
12
8
20
5
0
字符串测试
实例:
num1="ru1noob"
num2="runoob"
if test $num1 = $num2
then
echo '两个字符串相等!'
else
echo '两个字符串不相等!'
fi
输出:
两个字符串不相等!
文件测试
实例:
cd /bin
if test -e ./bash
then
echo '文件已存在!'
else
echo '文件不存在!'
fi
结果:
文件已存在!
另外,Shell还提供了与( -a )、或( -o )、非( ! )三个逻辑操作符用于将测试条件连接起来,其优先级为:"!“最高,”-a"次之,"-o"最低。例如:
cd /bin
if test -e ./notFile -o -e ./bash
then
echo '至少有一个文件存在!'
else
echo '两个文件都不存在'
fi
输出:
至少有一个文件存在!
Shell 流程控制
和Java、PHP等语言不一样,sh的流程控制不可为空,如(以下为PHP流程控制写法):
<?php
if (isset($_GET["q"])) {
search(q);
}
else {
// 不做任何事情
}
在sh/bash里可不能这么写,如果else分支没有语句执行,就不要写这个else。
if else
if
if 语句语法格式:
if condition
then
command1
command2
...
commandN
fi
写成一行的写法(适用于终端命令提示符):
if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi
输出:
true
末尾的fi
就是if
倒过来拼写,后面还会遇到类似的。
if else
语法格式:
if condition
then
command1
command2
...
commandN
else
command
fi
if else-if else
语法格式:
if condition1
then
command1
elif condition2
then
command2
else
commandN
fi
以下实例判断两个变量是否相等:
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 "没有符合的条件"
fi
输出:
a 小于 b
if else
语句经常与test
命令结合使用,如下所示:
num1=$[2*3]
num2=$[1+5]
if test $[num1] -eq $[num2]
then
echo '两个数字相等!'
else
echo '两个数字不相等!'
fi
输出结果:
两个数字相等!
for 循环
与其他编程语言类似,Shell
支持for
循环。
for
循环一般格式为:
for var in item1 item2 ... itemN
do
command1
command2
...
commandN
done
也可以写成一行:
for var in item1 item2 ... itemN; do command1; command2… done;
当变量值在列表里,for
循环即执行一次所有命令,使用变量名获取列表中的当前取值。命令可为任何有效的shell命令和语句。in
列表可以包含替换、字符串和文件名。
in
列表是可选的,如果不用它,for
循环使用命令行的位置参数。
例如,顺序输出当前列表中的数字:
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 # 请注意,这种情况下echo并没有自作多情的换行
# 也只有这种情况不会自作多情的换行了
缺省in
的情况:
for i
do
echo $i
done
输出:
1
2
3
while 语句
while
循环用于不断执行一系列命令,也用于从输入文件中读取数据;命令通常为测试条件。其格式为:
while condition
do
command
done
以下是一个基本的while
循环,测试条件是:如果int
小于等于5
,那么条件返回真。int
从0
开始,每次循环处理时,int
加1
。运行上述脚本,返回数字1到5,然后终止。
int=1
while(( $int<=5 ))
do
echo $int
let int++
done
输出:
1
2
3
4
5
while
循环可用于读取键盘信息。下面的例子中,输入信息被设置为变量FILM
,按<Ctrl-D>
结束循环。
echo '按下 <CTRL-D> 退出'
echo -n '输入你最喜欢的网站名: '
while read FILM
do
echo "是的!$FILM 是一个好网站"
done
输出:
按下 <CTRL-D> 退出
输入你最喜欢的网站名: www.baidu.com
是的!www.baidu.com 是一个好网站
无限循环
无限循环语法格式:
while :
do
command
done
或者是:
while true
do
command
done
或者是:
for (( ; ; ))
until 循环
until
循环执行一系列命令直至条件为 true
时停止。
until
循环与 while
循环在处理方式上刚好相反。
一般 while
循环优于 until
循环,但在某些时候—也只是极少数情况下,until
循环更加有用。
这俩一个是高中数学讲的当型,一个是直到型
语法格式:
until condition
do
command
done
condition
一般为条件表达式,如果返回值为 false
,则继续执行循环体内的语句,否则跳出循环。
以下实例我们使用 until
命令来输出 0 ~ 9
的数字:
#!/bin/bash
a=0
until [ ! $a -lt 10 ]
do
echo $a
a=`expr $a + 1`
done
输出:
0
1
2
3
4
5
6
7
8
9
case
Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式,如果匹配成功,执行相匹配的命令。case语句格式如下:
case 值 in
模式1)
command1
command2
...
commandN
;;
模式2)
command1
command2
...
commandN
;;
esac
case
工作方式如上所示。取值后面必须为单词in
,每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后,其间所有命令开始执行直至 ;;
。
取值将检测匹配的每一个模式。一旦模式匹配,则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式,使用星号 *
捕获该值,再执行后面的命令(相当于其他语言的default)。
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
输出:
输入 1 到 4 之间的数字:
你输入的数字为:
3
你选择了 3
跳出循环
在循环过程中,有时候需要在未达到循环结束条件时强制跳出循环,Shell使用两个命令来实现该功能:break
和continue
。
break命令
break
命令允许跳出本层循环。
下面的例子中,脚本进入死循环直至用户输入数字大于5。要跳出这个循环,返回到shell提示符下,需要使用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
输出:
输入 1 到 5 之间的数字:3
你输入的数字为 3!
输入 1 到 5 之间的数字:7
你输入的数字不是 1 到 5 之间的! 游戏结束
continue
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
运行代码发现,当输入大于5的数字时,该例中的循环不会结束,语句 echo "游戏结束"
永远不会被执行。
esac
case
的语法和C family
语言差别很大,它需要一个esac
(就是case
反过来)作为结束标记,每个case
分支用右圆括号,用两个分号表示break
。
Shell 函数
linux shell
可以用户定义函数,然后在shell
脚本中可以随便调用。
shell
中函数的定义格式如下:
[ function ] funname ()
{
action;
[return int;]
}
说明:
- 1、可以带
function fun()
定义,也可以直接fun()
定义,不带任何参数。 - 2、参数返回,可以显示加:
return
返回,如果不加,将以最后一条命令运行结果,作为返回值。return
后跟数值n(0-255
)
示例:
testfunc()
{
echo "start"
echo "end"
return 1
}
test1func()
{
echo "start"
return 2
}
testfunc
echo $? # 代表了testfunc的返回值
test1func
echo $? # $?代表了函数的返回值
# 总之,$#就代表了最近执行的函数的返回值
输出:
start
end
1
start
2
计算两数之和:
func()
{
read a
read b
return `expr $a + $b`
}
func
echo "两数之和为:${?}"
输出:
1
2
两数之和为:3
注意:所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分,直至shell
解释器首次发现它时,才可以使用。调用函数仅使用其函数名即可。
函数参数
在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}
来获取参数。
另外,还有几个特殊字符用来处理参数:
Shell 输入/输出重定向
大多数 UNIX 系统命令从你的终端接受输入并将所产生的输出发送回到您的终端。一个命令通常从一个叫标准输入的地方读取输入,默认情况下,这恰好是你的终端。同样,一个命令通常将其输出写入到标准输出,默认情况下,这也是你的终端。
重定向命令列表如下:
需要注意的是文件描述符 0
通常是标准输入(STDIN
),1
是标准输出(STDOUT
),2
是标准错误输出(STDERR
)。
输出重定向
重定向一般通过在命令间插入特定的符号来实现。特别的,这些符号的语法如下所示:
command1 > file1
上面这个命令执行command1
然后将输出的内容存入file1
。
注意任何file1
内的已经存在的内容将被新内容替代。如果要将新内容添加在文件末尾,请使用>>
操作符。
实例
执行下面的 who
命令,它将命令的完整的输出重定向在用户文件中(user.dat
):
who > user.dat
输出:
xm tty1 2019-03-07 16:23 (:0)
xm pts/1 2019-03-29 18:35 (:0.0)
root pts/2 2019-04-08 21:40 (192.168.2.1)
root pts/3 2019-04-09 08:14 (192.168.2.1)
root pts/4 2019-04-09 22:24 (192.168.2.1)
输入重定向
和输出重定向一样,Unix
命令也可以从文件获取输入,语法为:
command1 < file1
这样,本来需要从键盘获取输入的命令会转移到文件读取内容。
注意:输出重定向是大于号(>
),输入重定向是小于号(<
)。
示例:
接着以上实例,我们需要统计 user.dat
文件的行数,执行以下命令:
wc -l user.dat
输出:
5 user.dat
也可以将输入重定向到 user.dat
文件:
wc -l < user.dat
输出:
5
注意:上面两个例子的结果不同:第一个例子,会输出文件名;第二个不会,因为它仅仅知道从标准输入读取内容。
command1 < infile > outfile
同时替换输入和输出,执行command1
,从文件infile
读取内容,然后将输出写入到outfile
中。
重定向深入讲解
一般情况下,每个 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
,可以这样写:
command 2 > file
如果希望 stderr
追加到 file
文件末尾,可以这样写:
command 2 >> file
2
表示标准错误文件(stderr
)。
如果希望将 stdout
和 stderr
合并后重定向到 file
,可以这样写:
command > file 2>&1
或者:
command >> file 2>&1
如果希望对 stdin
和 stdout
都重定向,可以这样写:
command < file1 >file2
command
命令将 stdin
重定向到 file1
,将 stdout
重定向到 file2
。
Here Document
Here Document
是 Shell
中的一种特殊的重定向方式,用来将输入重定向到一个交互式 Shell
脚本或程序。
基本格式:
command << delimiter
document
delimiter
它的作用是将两个 delimiter
之间的内容(document
) 作为输入传递给 command
。
注意:
结尾的delimiter
一定要顶格写,前面不能有任何字符,后面也不能有任何字符,包括空格和 tab
缩进。
开始的delimiter
前后的空格会被忽略掉。
示例:
在命令行中通过 wc -l
命令计算 Here Document
的行数:
[root@vth 20190409]# wc -l << E
> dsa
> dsa
> fd
> E
输出:
3
注意,delimiter
是啥都行,什么好记用什么。
我们也可以将 Here Document
用在脚本中,例如:
#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com
cat << EOF
欢迎来到
菜鸟教程
www.runoob.com
EOF
输出:
欢迎来到
菜鸟教程
www.runoob.com
/dev/null 文件
如果希望执行某个命令,但又不希望在屏幕上显示输出结果,(深藏功与名)那么可以将输出重定向到 /dev/null
:
command > /dev/null
/dev/null
是一个特殊的文件,写入到它的内容都会被丢弃;如果尝试从该文件读取内容,那么什么也读不到。但是 /dev/null
文件非常有用,将命令的输出重定向到它,会起到"禁止输出"的效果。
如果希望屏蔽 stdout
和 stderr
,可以这样写:
command > /dev/null 2>&1
Shell 文件包含
和其他语言一样,Shell 也可以包含外部脚本(相当于c语言的include
)。这样可以很方便的封装一些公用的代码作为一个独立的文件。
Shell
文件包含的语法格式如下:
. filename # 注意点号(.)和文件名中间有一空格
或
source filename
实例1:
out.sh 中的内容:
i="www.baidu.com"
test.sh 中的内容:
. ./out.sh
echo "${i}"
输出:
www.baidu.com
示例2:
out.sh中的内容:
i="www.baidu.com"
echo "我是在out中,${i}"
test.sh中的内容:
. ./out.sh
echo "${i}"
输出:
我是在out中,www.baidu.com
www.baidu.com
注:被包含的文件 out.sh 不需要可执行权限,只要test.sh有可执行权限就可以了。