hello shell
#!/bin/bash
echo "Hello World !"
shell 概述
shell是一个介于用户和OS之间的interface（接口），专门用来帮助用户访问操作系统。
bash开始的时候其实是sh的一种实现，但是随着需求越来越多，bash中又加入很多sh中并没有包含的功能，甚至bash中有一些行为会更改sh中的需求。因此并不能完全的说bash是sh的实现。
#!/bin/bash
告诉操作系统，应该sh的bash来执行下面的script。
#!/bin/bin
告诉操作系统，应该sh的bin来执行下面的script。
/bin/bash -ex
`-e`: 如果shell command中的任何一行failed，整个shell script file的运行会在这个command处立刻终止
- `-x`: 在shell script的执行过程中，将command以及参数全部在标准输出中console出来
注释
-
单行注释
#--------------------------------------------
# 这是一个注释
# author：菜鸟教程
# site：www.runoob.com
# slogan：学的不仅是技术，更是梦想！
#--------------------------------------------
##### 用户配置区 开始 #####
#
#
# 这里可以添加脚本描述信息
#
#
##### 用户配置区 结束 #####
-
多行注释
:<<EOF
注释内容...
注释内容...
注释内容...
EOF
:<<'
注释内容...
注释内容...
注释内容...
'
:<<!
注释内容...
注释内容...
注释内容...
!
运行shell方法
-
作为可执行程序
chmod +x ./test.sh #使脚本具有执行权限
./test.sh #执行脚本
-
作为解释器参数
/bin/sh test.sh
/bin/php test.php
shell 变量
-
定义变量
your_name="runoob.com"
-
命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。
-
中间不能有空格，可以使用下划线 _。
-
不能使用标点符号。
-
不能使用bash里的关键字（可用help命令查看保留关键字）。
-
使用变量
your_name="qinjx"
echo $your_name
echo ${your_name}
-
只读变量
使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。
#!/bin/bash
myUrl="https://www.google.com"
readonly myUrl
myUrl="https://www.runoob.com"
-
只读变量
使用 unset 命令可以删除变量。语法
unset variable_name
-
变量类型
运行shell时，会同时存在三种变量：
- 1)局部变量 局部变量在脚本或命令中定义，仅在当前shell实例中有效，其他shell启动的程序不能访问局部变量。
- 2) 环境变量 所有的程序，包括shell启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
- 3) shell变量 shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了shell的正常运行
字符串
-
字符串定义
字符串是shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了），字符串可以用单引号，也可以用双引号，也可以不用引号。
str='this is a string'
your_name="runoob"
str="Hello, I know you are "$your_name"! \n"
echo -e $str
-
字符串长度
string="abcd"
echo ${#string} #输出 4
-
提取字符串
string="runoob is a great site"
echo ${string:1:4} # 输出 unoo
-
查找字符串长度
查找字符 i 或 o 的位置(哪个字母先出现就计算哪个)：
string="runoob is a great site"
echo `expr index "$string" io` # 输出 4
date
-
显示时间
-
格式化时间
若要指定格式显示日期，可以使用“+”开头的字符串指定其格式，详细格式如下： 指令 作用
- %n 下一行
- %t 跳格
- %H 小时(00-23)
- %I 小时(01-12)
- %k 小时(0-23)
- %l 小时(1-12)
- %M 分钟(00-59)
- %p 显示本地 AM 或 PM
- %r 直接显示时间 (12 小时制，格式为 hh:mm:ss [AP]M)
- %s 从 1970 年 1 月 1 日 00:00:00 UTC 到目前为止的秒数
- %S 秒(00-60)
- %T 直接显示时间 (24 小时制)
- %X 相当于 %H:%M:%S
- %Z 显示时区
- %a 星期几 (Sun-Sat)
- %A 星期几 (Sunday-Saturday)
- %b 月份 (Jan-Dec)
- %B 月份 (January-December)
- %c 直接显示日期与时间
- %d 日 (01-31)
- %D 直接显示日期 (mm/dd/yy)
- %h 同 %b
- %j 一年中的第几天 (001-366)
- %m 月份 (01-12)
- %U 一年中的第几周 (00-53)
- %w 一周中的第几天 (0-6)
- %W 一年中的第几周 (00-53)
- %x 直接显示日期 (mm/dd/yy)
- %y 年份的最后两位数字 (00.99)
- %Y 完整年份 (0000-9999) 上述格式只需要掌握几个常用的即可。 例如%Y表示年，%m表示月，%d表示日，%H表示小时，%M表示分钟，%S表示秒，%s表示从 1970 年 1 月 1 日 00:00:00 UTC 到目前为止的秒数，相当于time函数，%w表示一周中的第几天。实例见下：
date " now i： %Y-%m-%d %H:%M:%S"
-
显示经过运算后的时间（date -d）
//3年前
date "+%Y-%m-%d %H:%M:%S" -d "-3 year"
//3天前
date "+%Y-%m-%d %H:%M:%S" -d "-3 day"
//二个月前
date "+%Y-%m-%d %H:%M:%S" -d "-2 month"
//二年 10前
date -d "-2 year -10 day" "+%Y-%m-%d"
date 命令的另一个扩展是 -d 选项，使用这个功能强大的选项，通过将日期作为引号括起来的参数提供，您可以快速地查明一个特定的日期。-d 选项还可以告诉您，相对于当前日期若干天的究竟是哪一天，从现在开始的若干天或若干星期以后，或者以前（过去）。通过将这个相对偏移使用引号括起来，作为 -d 选项的参数，就可以完成这项任务。
//3天前
date -d '3 days ago'
//显示60秒前的时间
date -d '60 second ago'
//显示3月1天后的时间
date -d '3 months 1 day'
//显示12月25日在当年的哪一天
date -d '25 Dec' +%j
shell 数组
bash支持一维数组（不支持多维数组），并且没有限定数组的大小。 类似于 C 语言，数组元素的下标由 0 开始编号。获取数组中的元素要利用下标，下标可以是整数或算术表达式，其值应大于或等于 0。
-
数组定义
在 Shell 中，用括号来表示数组，数组元素用"空格"符号分割开。定义数组的一般形式为：数组名=(值1 值2 ... 值n)
array_name=(value0 value1 value2 value3)
-
读取数组
${数组名[下标]}
valuen=${array_name[n]}
使用 @ 符号可以获取数组中的所有元素，例如：
echo ${array_name[@]}
-
获取数组长度
获取数组长度的方法与获取字符串长度的方法相同
# 取得数组元素的个数
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得数组单个元素的长度
lengthn=${#array_name[n]}
shell 传递参数
我们可以在执行 Shell 脚本时，向脚本传递参数，脚本内获取参数的格式为： $n。n 代表一个数字，1 为执行脚本的第一个参数，2 为执行脚本的第二个参数，以此类推…
以下实例我们向脚本传递三个参数，并分别输出，其中 $0 为执行的文件名（包含文件路径）：
#!/bin/bash\
# author:菜鸟教程\
# url:www.runoob.com\
\
echo "Shell 传递参数实例！";\
echo "执行的文件名：$0";\
echo "第一个参数为：$1";\
echo "第二个参数为：$2";\
echo "第三个参数为：$3";
为脚本设置可执行权限，并执行脚本，输出结果如下所示：
$ chmod +x test.sh
$ ./test.sh 1 2 3
Shell 传递参数实例！
执行的文件名：./test.sh
第一个参数为：1
第二个参数为：2
第三个参数为：3
另外，还有几个特殊字符用来处理参数：
| $# | 传递到脚本的参数个数 |
|---|---|
| $* | 以一个单字符串显示所有向脚本传递的参数。 如"1 n"的形式输出所有参数。 |
| $$ | 脚本运行的当前进程ID号 |
| $! | 后台运行的最后一个进程的ID号 |
| $@ | 与@"用「"」括起来的情况、以"2" … "$n" 的形式输出所有参数。 |
| $- | 显示Shell使用的当前选项，与set命令功能相同。 |
| $? | 显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。 |
#!/bin/bash\
# author:菜鸟教程\
# url:www.runoob.com\
\
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\
# author:菜鸟教程\
# url:www.runoob.com\
\
echo "-- \$* 演示 ---"\
for i in "$*"; do\
echo $i\
done\
\
echo "-- \$@ 演示 ---"\
for i in "$@"; do\
echo $i\
done
$ chmod +x test.sh
$ ./test.sh 1 2 3
-- $* 演示 ---
1 2 3
-- $@ 演示 ---
1
2
3
shell 基本运算符
- 算数运算符
- 关系运算符
- 布尔运算符
- 字符串运算符
- 文件测试运算符
原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，expr 最常用。
expr 是一款表达式计算工具，使用它能完成表达式的求值操作。
-
算术运算符
下表列出了常用的算术运算符，假定变量 a 为 10，变量 b 为 20：
| 运算符 | 说明 | 举例 |
|---|---|---|
| + | 加法 | expr $a + $b 结果为 30。 |
| - | 减法 | expr $a - $b 结果为 -10。 |
| * | 乘法 | expr $a \* $b 结果为 200。 |
| / | 除法 | expr $b / $a 结果为 2。 |
| % | 取余 | expr $b % $a 结果为 0。 |
| = | 赋值 | a=$b 把变量 b 的值赋给 a。 |
| == | 相等。用于比较两个数字，相同则返回 true。 | [ b ] 返回 false。 |
| != | 不相等。用于比较两个数字，不相同则返回 true。 | [ b ] 返回 true。 |
注意： 条件表达式要放在方括号之间，并且要有空格，例如: [b] 是错误的，必须写成 [ b ] 。
#!/bin/bash\
# author:菜鸟教程\
# url:www.runoob.com\
\
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
注意：
-
乘号(*)前边必须加反斜杠()才能实现乘法运算；
-
if...then...fi 是条件语句，后续将会讲解。
-
在 MAC 中 shell 的 expr 语法是： $((表达式)) ，此处表达式中的 "*" 不需要转义符号 "" 。
-
关系运算符
关系运算符只支持数字，不支持字符串，除非字符串的值是数字。 下表列出了常用的关系运算符，假定变量 a 为 10，变量 b 为 20：
| 运算符 | 说明 | 举例 |
|---|---|---|
| -eq | 检测两个数是否相等，相等返回 true。 | [ b ] 返回 false。 |
| -ne | 检测两个数是否不相等，不相等返回 true。 | [ b ] 返回 true。 |
| -gt | 检测左边的数是否大于右边的，如果是，则返回 true。 | [ b ] 返回 false。 |
| -lt | 检测左边的数是否小于右边的，如果是，则返回 true。 | [ b ] 返回 true。 |
| -ge | 检测左边的数是否大于等于右边的，如果是，则返回 true。 | [ b ] 返回 false。 |
| -le | 检测左边的数是否小于等于右边的，如果是，则返回 true。 | [ b ] 返回 true。 |
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：
| 运算符 | 说明 | 举例 |
|---|---|---|
| ! | 非运算，表达式为 true 则返回 false，否则返回 true。 | [ ! false ] 返回 true。 |
| -o | 或运算，有一个表达式为 true 则返回 true。 | [ b -gt 100 ] 返回 true。 |
| -a | 与运算，两个表达式都为 true 才返回 true。 | [ b -gt 100 ] 返回 false。 |
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:
| 运算符 | 说明 | 举例 | ||
|---|---|---|---|---|
| && | 逻辑的 AND | [[ a -lt 100 && b -gt 100 ]] 返回 false | ||
| || | 逻辑的 OR | [[ $a -lt 100 | $b -gt 100 ]] 返回 true |
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"： 运算符 | 说明 | 举例 | | --- | --------------------------- | --------------------- | | = | 检测两个字符串是否相等，相等返回 true。 | [ b ] 返回 false。 | | != | 检测两个字符串是否不相等，不相等返回 true。 | [ b ] 返回 true。 | | -z | 检测字符串长度是否为0，为0返回 true。 | [ -z a" ] 返回 true。 | | a ] 返回 true。
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 文件的各种属性。 属性检测描述如下：
| 操作符 | 说明 | 举例 |
|---|---|---|
| -b file | 检测文件是否是块设备文件，如果是，则返回 true。 | [ -b $file ] 返回 false。 |
| -c file | 检测文件是否是字符设备文件，如果是，则返回 true。 | [ -c $file ] 返回 false。 |
| -d file | 检测文件是否是目录，如果是，则返回 true。 | [ -d $file ] 返回 false。 |
| -f file | 检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。 | [ -f $file ] 返回 true。 |
| -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。 |
| -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。 |
其他检查符：
- -S: 判断某文件是否 socket。
- -L: 检测文件是否存在并且是一个符号链接。
#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com
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 输入/输出重定向
大多数 UNIX 系统命令从你的终端接受输入并将所产生的输出发送回到您的终端。一个命令通常从一个叫标准输入的地方读取输入，默认情况下，这恰好是你的终端。同样，一个命令通常将其输出写入到标准输出，默认情况下，这也是你的终端。 重定向命令列表如下：
| 命令 | 说明 |
|---|---|
| command > file | 将输出重定向到 file。 |
| command < file | 将输入重定向到 file。 |
| command >> file | 将输出以追加的方式重定向到 file。 |
| n > file | 将文件描述符为 n 的文件重定向到 file。 |
| n >> file | 将文件描述符为 n 的文件以追加的方式重定向到 file。 |
| n >& m | 将输出文件 m 和 n 合并。 |
| n <& m | 将输入文件 m 和 n 合并。 |
| << tag | 将开始标记 tag 和结束标记 tag 之间的内容作为输入。 |
-
需要注意的是文件描述符 0 通常是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。
-
输出重定向
ommand1 > file1
执行下面的 who 命令，它将命令的完整的输出重定向在用户文件中(users):
$ who > users
执行后，并没有在终端输出信息，这是因为输出已被从默认的标准输出设备（终端）重定向到指定的文件。
你可以使用 cat 命令查看文件内容：
$ cat users
_mbsetupuser console Oct 31 17:35
tianqixin console Oct 31 17:35
tianqixin ttys000 Dec 1 11:33
如果不希望文件内容被覆盖，可以使用 >> 追加到文件末尾
$ echo "菜鸟教程：www.runoob.com" >> users
$ cat users
菜鸟教程：www.runoob.com
菜鸟教程：www.runoob.com
$
-
输入重定向
command1 < file1
接着以上实例，我们需要统计 users 文件的行数,执行以下命令：
$ wc -l users
result: 2 users
也可以将输入重定向到 users 文件：
$ wc -l < users
result 2
- 注意：上面两个例子的结果不同：第一个例子，会输出文件名；第二个不会，因为它仅仅知道从标准输入读取内容。
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
-
Here Document
Here Document 是 Shell 中的一种特殊的重定向方式，用来将输入重定向到一个交互式 Shell 脚本或程序。
它的基本的形式如下
command << delimiter
document
delimiter
它的作用是将两个 delimiter 之间的内容(document) 作为输入传递给 command。
在命令行中通过 wc -l 命令计算 Here Document 的行数：
$ wc -l << EOF
欢迎来到
菜鸟教程
www.runoob.com
EOF
3 # 输出结果为 3 行
$
cat << EOF
欢迎来到
菜鸟教程
www.runoob.com
EOF
执行以上脚本，输出结果：
欢迎来到
菜鸟教程
www.runoob.com
-
/dev/null 文件
command > /dev/null
/dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到"禁止输出"的效果。
如果希望屏蔽 stdout 和 stderr，可以这样写：
$ command > /dev/null 2>&1
注意： 0 是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。
这里的 2 和 > 之间不可以有空格，2> 是一体的时候才表示错误输出。
shell test 命令
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。
-
数值测试
| 参数 | 说明 |
|---|---|
| -eq | 等于则为真 |
| -ne | 不等于则为真 |
| -gt | 大于则为真 |
| -ge | 大于等于则为真 |
| -lt | 小于则为真 |
| -le | 小于等于则为真 |
num1=100\
num2=100\
if test $[num1] -eq $[num2]\
then\
echo '两个数相等！'\
else\
echo '两个数不相等！'\
fi
输出结果：
两个数相等！
代码中的 [] 执行基本的算数运算，如：
#!/bin/bash\
\
a=5\
b=6\
\
result=$[a+b] # 注意等号两边不能有空格\
echo "result 为： $result"
result 为： 11
-
字符串测试
| 参数 | 说明 |
|---|---|
| = | 等于则为真 |
| != | 不相等则为真 |
| -z 字符串 | 字符串的长度为零则为真 |
| -n 字符串 | 字符串的长度不为零则为真 |
num1="ru1noob"\
num2="runoob"\
if test $num1 = $num2\
then\
echo '两个字符串相等!'\
else\
echo '两个字符串不相等!'\
fi
输出结果：
两个字符串不相等!
-
文件测试
| 参数 | 说明 |
|---|---|
| -e 文件名 | 如果文件存在则为真 |
| -r 文件名 | 如果文件存在且可读则为真 |
| -w 文件名 | 如果文件存在且可写则为真 |
| -x 文件名 | 如果文件存在且可执行则为真 |
| -s 文件名 | 如果文件存在且至少有一个字符则为真 |
| -d 文件名 | 如果文件存在且为目录则为真 |
| -f 文件名 | 如果文件存在且为普通文件则为真 |
| -c 文件名 | 如果文件存在且为字符型特殊文件则为真 |
| -b 文件名 | 如果文件存在且为块特殊文件则为真 |
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
if condition
then
command1
command2
...
commandN
fi
写成一行（适用于终端命令提示符）：
if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi
-
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循环
for var in item1 item2 ... itemN
do
command1
command2
...
commandN
done
for var in item1 item2 ... itemN; do command1; command2… 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
顺序输出字符串中的字符：
#!/bin/bash
for str in This is a string
do
echo $str
done
输出结果：
This
is
a
string
-
while 语句
while 循环用于不断执行一系列命令，也用于从输入文件中读取数据。其语法格式为：
while condition
do
command
done
-
无限循环
while :
do
command
done
或者
while true
do
command
done
或者
for (( ; ; ))
-
until 循环
until 循环执行一系列命令直至条件为 true 时停止。
until 循环与 while 循环在处理方式上刚好相反。
一般 while 循环优于 until 循环，但在某些时候—也只是极少数情况下，until 循环更加有用。
until 语法格式:
until condition
do
command
done
condition 一般为条件表达式，如果返回值为 false，则继续执行循环体内的语句，否则跳出循环。
以下实例我们使用 until 命令来输出 0 ~ 9 的数字：
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 ... esac
case ... esac 为多选择语句，与其他语言中的 switch ... case 语句类似，是一种多分支选择结构，每个 case 分支用右圆括号开始，用两个分号 ;; 表示 break，即执行结束，跳出整个 case ... esac 语句，esac（就是 case 反过来）作为结束标记。
可以用 case 语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令。
case ... esac 语法格式如下：
case 值 in
模式1)
command1
command2
...
commandN
;;
模式2)
command1
command2
...
commandN
;;
esac
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
-
跳出循环
-
break
break命令允许跳出所有循环（终止执行后面的所有循环）。
下面的例子中，脚本进入死循环直至用户输入数字大于5。要跳出这个循环，返回到shell提示符下，需要使用break命令
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命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。
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 文件包含
和其他语言一样，Shell 也可以包含外部脚本。这样可以很方便的封装一些公用的代码作为一个独立的文件。
Shell 文件包含的语法格式如下：
. filename # 注意点号(.)和文件名中间有一空格
或
source filename
实例
创建两个 shell 脚本文件。
test1.sh 代码如下：
#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com
url="http://www.runoob.com"
test2.sh 代码如下：
#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com
#使用 . 号来引用test1.sh 文件
. ./test1.sh
# 或者使用以下包含文件代码
# source ./test1.sh
echo "菜鸟教程官网地址：$url"
接下来，我们为 test2.sh 添加可执行权限并执行：
$ chmod +x test2.sh
$ ./test2.sh
菜鸟教程官网地址：http://www.runoob.com
