linux学习——shell脚本

菜鸟教程shell在线编辑器
大目录整理:

  • 1.第一个 Shell 脚本尝试
  • 2.Shell 变量
  • 3.Shell 传递参数
  • 4.Shell 基本运算符
  • 5.Shell echo 命令
  • 6.Shell printf 命令
  • 7.Shell test 命令
  • 8.Shell 流程控制
  • 9.Shell 函数
  • 10.Shell 输入/输出重定向
  • 11.Shell 文件包含

1.第一个 Shell 脚本尝试

  • 第一个Shell脚本(输出"Hello World!")
#!/bin/bash
echo "Hello World !"

"#!" 是一个约定的标记,它告诉系统这个脚本需要什么解释器来执行,即使用哪一种 Shell,此处为最广泛使用的Bourne Again Shell,也是大多数linux系统默认的Shell。

运行Shell脚本有两种方法:

  • 作为可执行程序
#cd到文件所在目录
chmod +x ./test.sh  #使脚本具有执行权限
./test.sh                   #执行脚本
Hello World.png
  • 作为解释器参数
    这种运行方式是直接运行解释器,其参数就是shell脚本的文件名,如:
/bin/sh test.sh
/bin/php test.php

这种方式运行的脚本,不需要在第一行指定解释器信息,写了也没用。

2.Shell 变量

定义变量时,变量名不加"$"符号,如:

your_name = "zkn"

注意:变量名与等号之间不能有空格,且变量名的命名须遵循如下规则:

  • 命名只能使用英文字母、数字和下划线,首个字符不能以数字开头
  • 中间不能有空格,可以使用下划线"_"
  • 不能使用标点符号
  • 不能使用bash里的关键字(可用help命令查看保留关键字)
    有效的Shell变量名示例如下:

ZKN
linux_shell
_pjp
abc23

无效的变量命名:

?var=12
user*name=zkn

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

for file in 'ls /etc'
或
for file in $(ls /etc)

以上语句将/etc下目录的文件名循环出来

使用变量

使用一个定义过的变量,只要在变量名前加"$"即可,如:

your_name="zkn"
echo $your_name
echo ${your name}

变量名外面的花括号是可选的,加不加都行,加花括号是为了帮助解释器识别变量的边界,比如下面这种情况:

for i in A B C D; do
    echo "one by one ${i}123"
done

如果不给i变量加上花括号,解释器就会把$i123当成一个变量,输出空值。
推荐给所有变量加上花括号,这是个好的编程习惯
已定义的变量,也可以被重新定义,如:

your_name="zkn"
echo ${your_name}
your_name="pjp"
echo ${your_name}

这样写是合法的,但注意,第二次赋值的时候,不能写

$your_name="pjp"

使用变量的时候才加"$"。

只读变量

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

#!/bin/bash
myUrl="http://www.google.com"
readonly myUrl
myUrl="https://www.jianshu.com/u/8c84e7108714"

运行脚本,结果如下:

./test.sh: line 19: myUrl: readonly variable

删除变量

使用unset命令可以删除变量,如:

unset variable_name

变量被删除后不能再次使用,unset命令不能删除只读变量。
实例:

#!/bin/sh
myUrl="https://www.jianshu.com/u/8c84e7108714"
unset myUrl
echo ${myUrl}

以上实例执行将没有任何输出。

变量类型

运行shell时,会同时存在三种变量:

  • 局部变量 局部变量在脚本或命令中定义,仅在当前shell实例中有效,其他shell启动的程序不能访问局部变量。
  • 环境变量 所有的程序,包括shell启动的程序,都能访问环境变量,有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
  • shell变量 shell变量由shell程序设置的特殊变量。shell变量中有一部分是环境变量,有一部分是局部变量,这些变量保证了shell的正常运行。

Shell字符串

字符串是shell编程中最常用最有用的数据类型(除了数字和字符串,也没啥其他类型好用了),字符串可以用单引号,也可以用双引号,也可以不用引号。单双引号的区别跟php类似。

单引号

str='this is a string'

单引号字符串的限制:

  • 单引号里的任何字符都会原样输出,单引号字符串中的变量是无效的;
  • 单引号字符串中不能出现单独一个单引号(对单引号使用转义符后也不行),但可成对出现,作为字符串拼接使用。

双引号

示例:

your_name='zkn'
str ="Hello,I konw you are \"$your_name\"! "
echo $str

输出结果为:

Hello,I konw you are "zkn"!

双引号的优点:

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

拼接字符串

#使用双引号拼接
your_name="zkn"
greeting="hello,"$your_name"!"
greeting_1="hello,${your_name}!"
echo $greeting $greeting_1
#使用单引号拼接
greeting_2='hello,'$your_name'!'
greeting_3='hello,${your_name}!'
echo $greeting_2 $greeting_3

输出结果为:

hello,zkn! hello,zkn!
hello,zkn! hello,${your_name}!

获取字符串长度

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

提取子字符串

以下示例从字符串第2个字符开始,截取4个字符:

string="zknpjp is good"
echo ${string:1:4} ##输出 knpj

默认是从0开始编号,所以第2个字符是k,然后截取 knpj 4个字符。

查找子字符串

查找字符i或o的位置(哪个字母先出现就计算哪个):

string="zknpjp is good"
echo `expr index "$string" io`#输出8,一个空格也算一位

注意:以上脚本中 ` 是反引号,而不是单引号 '。

Shell数组

bash支持一维数组(不支持多维数组),并且没有限定数组的大小。初始化时不需要定义数组大小。
类似于C语言,数组元素的下标由0开始编号。获取数组中的元素要利用下标,下标可以是正数或者算术表达式,其值应大于等于0。

定义数组

在shell中,用括号来表示数组,数组元素用空格“ ”符号分隔开。定义数组的一般形式为:

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

例如:

array_name=(value0 value1 value2 value3)

或者

array_name=(
value0
value1
value2
value3
)

实例:

my_array=(A B "C" D)

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

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

以“#”开头的行就是注释,会被解释器忽略。
每一行加一个#号。例如:

#--------------------------------------------
# 这是一个注释
# author:zkn
#--------------------------------------------
##### 用户配置区 开始 #####
#
# 这里可以添加脚本描述信息
# 
##### 用户配置区 结束  #####

如果开发过程中,遇到大段代码需要临时注释起来,过一会儿又取消注释,怎么处理?每一行加#太费力,可以把这一段要注释的代码用一对花括号括起来,定义成一个函数,没有地方调用这个函数,这块代码就不会执行,达到和注释一样的效果。

多行注释

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

:<<EOF
注释内容...
注释内容...
注释内容...
EOF

EOF也可以使用其他符号:

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

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

3.Shell 传递参数

我们可以在执行shell脚本时,向脚本传递参数,脚本内获取参数的格式为:$nn代表一个数字,1为执行脚本的第一个参数,2为执行脚本的第二个参数,以此类推。

实例:

以下实例我们向脚本传递三个参数,并分别输出,其中$0为执行的文件名:

#!/bin/bash
echo "Shell 传递参数实例:";
echo "执行的文件名:$0";
echo "第一个参数为:$1";
echo "第二个参数为:$2";
echo "第三个参数为:$3";

为脚本设置可执行权限,并执行脚本,输出结果如下所示:

$ chmod +x test.sh
$ ./test.sh 1 2 3
Shell 传递参数实例:
第一个参数为:1
第二个参数为:2
第三个参数为:3

另外,还有几个特殊字符用来处理参数:

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

示例:

#!/bin/bash
echo "Shell 传递参数实例!";
echo "第一个参数为:$1";
echo "参数个数为:$#";
echo "传递的参数作为一个字符串显示:$*";
echo "$!";
echo "$@";
echo "$-";
echo "$?";

执行脚本,输出结果如下所示:

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

1 2 3
hB
0

$*与$@区别:

  • 相同点:都是引用所有参数。
  • 不同点:只有在双引号中体现出来。假设在脚本运行时写了三个参数1、2、3,则"*"等价于"1 2 3"(传递了一个参数),而"@"等价于"1""2""3"(传递了三个参数)。
echo "-- \$* 演示 --"
for i in "$*";do
    echo $i
done

echo "-- \$@ 演示 --"
for i in "$@";do
    echo $i
done

执行脚本,输出结果如下所示:

./test.sh 1 2 3
-- $* 演示 --
1 2 3
-- $@ 演示 --
1
2
3

4.Shell 基本运算符

Shell和其他编程语言一样,支持多种运算符,包括:

  • 算术运算符
  • 关系运算符
  • 布尔运算符
  • 字符串运算符
  • 文件测试运算符
    原生bash不支持简单的数学运算,但是可以通过其他命令来实现,例如awk和expr,其中expr最常用。expr是一款表达式计算工具,使用它能完成表达式的求值操作。
    例如,两个数相加(注意使用的是反引号"`",而不是单引号"'"):
#!/bin/bash
val=`expr 2 + 2` #2和"+"之间,必须有空格
echo "两数之和为:$val"

运行脚本,输出结果如下所示:

两数之和为:4

两点注意:

  • 表达式和运算符之间要有空格,例如2+2是不对的,会直接输出2+2,必须要写成2 + 2,这与我们熟悉的大多数编程语言不一样。
  • 完整的表达式要被` `包含,注意这个字符不是常用的单引号,而是反引号,在Esc键下面。

算术运算符

下面列出了常用的算术运算符,假定变量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 [ $a == $b ]返回false
!= 不相等。用于比较两个数字,不相同则返回true。 [ $a != $b ]返回true

注意:条件表达式要放在方括号之间,并且要有空格,例如:[ $a==$b ]是错误的,必须写成[ $a == $b ]
算术运算符实例:

#!/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 $a / $b`
echo "a / b : $val"

val=`expr $a % $b`
echo "a % b : $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
a / b : 0
a % b : 10
a 不等于 b

注意:

  • 乘号(*)前边必须加反斜杠()
  • if...then...fi是条件语句,后续将会讲解
  • 在MAC中shell的expr语法是:$((表达式)),此处表达式中的"*"不需要转义符号""。

关系运算符

关系运算符只支持数字,不支持字符串,除非字符串的值是数字。
下标列出了常用的关系运算符,假定变量a为10,变量b为20。

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

关系运算符实例如下:

#!/bin/bash
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 -nq $b: a 不等于 b"
else
    echo "$a -nq $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 -nq 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 [ $a -lt 20 -o $b -gt 100 ]返回true
-a 与运算,两个表达式都为true才返回true [ $a -lt 20 -a $b -gt 100 ]返回false

布尔运算符实例如下:

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

逻辑运算符实例如下:

#!/bin/bash
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 [ $a = $b ]返回false
!= 检测两个字符串是否相等,不相等返回true [ $a != $b ]返回false
-z 检测字符串长度是否为0,为0返回true [ -z $a ]返回false
-n 检测字符串长度是否为0,不为0返回true [ -n "$a" ]返回true
str 检测字符串是否为空,不为空返回true [ $a ]返回true

字符串运算符实例如下:

#!/bin/bash
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 ]返回flase
-p file 检测文件是否有名管道,如果是,则返回true [ -p $file ]返回false
-u file 检测文件是否设置了SUID [ -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

变量file表示文件"/home/jwb/test.sh",他的大小为528字节,具有rwx权限。下面的代码,将检测文件的各种属性:

#!/bin/bash
file="/home/jwb/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

执行脚本,输出结果如下所示:

文件可读
文件可写
文件可执行
文件为普通文件
文件不是目录
文件不为空
文件存在

5.Shell echo命令

Shell的echo指令与PHP指令类似,都是用于字符串的输出。命令格式:

echo string

1.显示普通字符串:

echo "It is a test"

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

echo It is a test

2.显示转义字符

echo "\"It is a test\""

结果将是:

"It is a test"

同样,双引号也可以省略。

3.显示变量

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

#!/bin/sh
read name
echo "My name is $name"

以上代码保存为test.sh,name接收标准输入的变量,结果将是:

./test.sh
zkn                        #标准输入
My name is zkn    #输出

read 命令一个一个词组地接收输入的参数,每个词组需要使用空格进行分隔;如果输入的词组个数大于需要的参数个数,则多出的词组将被作为整体为最后一个参数接收。例如:

read firstStr secondStr
echo "第一个参数:$firstStr;第二个参数:$secondStr"

执行测试:

./test.sh
1 2 3 4 5
第一个参数:1;第二个参数:2 3 4 5

再看个实例:

read -p "请输入一段文字:" -n 6 -t 5 -s password
echo -e "\npassword is $password"

参数说明:

  • -p 输入文字
  • -n 输入字符长度限制(此处达到6位自动结束)
  • -t 输入限时(达到限制时间,自动结束)
  • -s 隐藏输入内容
    执行脚本,输入"zknpjp",结果如下:
./test.sh
请输入一段文字:
password is zknpjp

4.显示换行

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

执行脚本,输出结果如下所示:

OK!  

It is a test

5.不显示换行

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

注意:这里使用的是反引号" ` ",而不是单引号" ' "。
结果将显示当前日期:

Fri Aug 31 23:32:10 PDT 2018

6.Shell printf 命令

  • 上一章节我们学习了shell的echo命令,本章节我们来学习Shell的另一个输出命令printf。
  • printf命令模仿C程序库(library)里的printf程序。
  • printf是POSIX标准所定义,因此使用printf的脚本比使用echo移植性好。
  • printf使用引用文本或空格分割的参数,外面可以在printf中使用格式化字符串,还可以指定字符串的宽度、左右对齐方式等。默认printf不会像echo自动添加换行符,我们可以手动添加\n。
    printf命令的语法:
printf format-string [arguements...]

参数说明:

  • format-string:为格式控制字符串
  • arguments:为参数列表
    实例如下:
$ 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" 杨过 男 56.3
printf "%-10s %-8s %-4.2f\n" 小龙女 女 46.126

执行脚本,输出结果如下所示:

姓名     性别   体重kg
郭靖     男      66.12
杨过     男      56.30
小龙女  女      46.13

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

执行脚本,输出结果如下所示:

1 abc
1 abc
abcdefabcdefabc
def
a b c
d e f
g h i
j  
 and 0 

%d %s %c %f 格式替代符详解:

  • d: Decimal 十进制整数 -- 对应位置参数必须是十进制整数,否则报错!
  • s: String 字符串 -- 对应位置参数必须是字符串或者字符型,否则报错!
  • c: Char 字符 -- 对应位置参数必须是字符串或者字符型,否则报错!
  • f: Float 浮点 -- 对应位置参数必须是数字型,否则报错!
$  printf "%d %s %c\n" 1 "abc" "def"
1 abc d

如:其中最后一个参数是 "def",%c 自动截取字符串的第一个字符作为结果输出。

printf的转义序列

序列 说明
\a 警告字符,通常为ASCII的BEL字符
\b 后退
\c 抑制(不显示)输出结果中任何结尾的换行字符(只在%b格式指示符控制下的参数字符串中有效),而且,任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符,都被忽略
\f 换页(formfeed)
\n 换行
\r 回车(Carriage return)
\t 水平制表符
\v 垂直制表符
\\ 一个字面上的反斜杠字符
\ddd 表示1到3位数八进制值的字符。仅在格式字符串中有效
\0ddd 表示1到3位的八进制值字符

实例:

$ printf "a string, no processing:<%s>\n" "A\nB"
a tring, no processing:<A\nB>

$ printf "a string, no processing:<%b>\n" "A\nB"
a tring, no processing:<A
B>

$ printf "zkn \a"
zkn

$

7.Shell test命令

Shell中的test命令用于检查某个条件是否成立,它可以进行数值、字符和条件三个方面的测试。

数值测试

实例演示:

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

字符串测试

实例演示:

num1="zkn"
num2="pjp"
if test $num1 = $num2
then
    echo "两个字符串相等!"
else
    echo "两个字符串不相等!"

输出结果为:

两个字符串不相等!

文件测试

实例演示:

cd /home/jwb
if test -e ./test.sh
then
    echo "文件已存在!"
else
    echo "文件不存在!"
fi

输出结果为:

文件已存在!

另外,Shell还提供了与(-a)、或(-o)、非(!)三个逻辑操作符用于将测试条件连接起来,其优先级为:"!"最高,"-a"次之,"-o"最低。例如:

cd /home/jwb
if test -e ./notFile -o -e ./test.sh
then
    echo '至少有一个文件存在!'
else
    echo '两个文件都不存在!'
fi

输出结果为:

至少有一个文件存在!

8.Shell 流程控制

if else

  • if
    if 语句语法格式:
if condtion
then
    command1
    command2
    ...
    commandN
fi

写成一行(适用于终端命令提示符):

if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi

末尾的fi就是if倒过来拼写。

if else

if else 语法格式:

if condtion
then
    command1
    command2
    ...
    commandN
else
    command
fi

if else-if else

if else-if else 语法格式:

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

while语句

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

while condition
do
    command
done

以下是一个基本的while循环,测试条件是:如果int小于等于5,那么条件返回真。int从0开始,每次循环处理时,int加1。运行上述脚本,返回数字1到5,然后终止。

#!/bin/bash
int=1
while ( ( $int < 6 ) ) #或者while [ $int -lt 6 ]
do 
    echo $int
    let "int++"
done

运行脚本,输出结果为:

1
2
3
4
5

过程中使用了Bash let命令,它用于执行一个或多个表达式,变量计算中不需要加上$来表示变量,具体可查阅:Bash let命令
while循环可用于读取键盘信息。下面的例子中,输入信息被设置为变量FILM,按<Ctrl-D>结束循环。

echo '按下<Ctrl-D>退出'
echo -n '输入你最喜欢的网站名:'
while read FILM
do
    echo "是的! $FILM 是一个好网站"
done

运行脚本,输出结果例如:

按下<Ctrl-D>退出
输入你最喜欢的网站名:zkn
是的! zkn 是一个好网站

无限循环

无限循环语法格式:

while :
do 
    command
done

或者

while true
do
    command
done

或者

for (( ; ; ))

for循环格式为:

for((assignment;condition;next))
do
    command1
    command2
    ...
    commandN
done

如上所示,这里的for循环与C中的相似,但并不完全相同。
通常情况下shell变量调用需要加$,但是for的(())中不需要,下面来看一个例子:

#!/bin/bash
for((i=1;i<=5;i++))
do
    echo "这是第 $i 次调用"
done

执行脚本,输出结果为:

这是第 1 次调用
这是第 2 次调用
这是第 3 次调用
这是第 4 次调用
这是第 5 次调用

与C中相似,赋值和下一步执行可以放到代码之前循环语句之中执行,这里要注意一点:如果要在循环体中进行for中的next操作,记得变量要加$,不然程序会变成死循环。

until 循环

until 循环执行一系列命令直至条件为true时停止。
until 循环与 while 循环在处理方式上刚好相反。
一般 while 循环优于 until 循环,但在某些时候,也只是极少数情况下,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 值 in
模式1)
    command1
    command2
    ...
    commandN
    ;;
模式2)
    command1
    command2
    ...
    commandN
    ;;
esac

case工作方式如上所示。取值后面必须为单词in,每一种模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后,其间所有命令开始执行直至";;"。
取值将检测匹配的每一种模式。一旦模式匹配,则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式,使用星号*捕获该值再执行后面的命令。
下面的脚本提示输入1到4,与每一种模式进行匹配:

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之间的整数4
你输入的数字为 4
输入1到5之间的整数1
你输入的数字为 1
输入1到5之间的整数0
你输入的不是1到5之间的整数!游戏结束!
continue

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之间的整数!"
            continue
            echo "游戏结束!"
        ;;
    esac
done

此时运行代码发现,当输入数字不是1到5之间的整数时,该例中的循环还是不会结束,语句echo "游戏结束"永远不会被执行。

esac

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

9.Shell 函数

linux shell 可以用户定义函数,然后再shell脚本中可以随便调用。
shell中函数的定义格式如下:

[ function ] funname [()]
{
    action;
    [return int;]
}

说明:

  • 可以带function fun()定义,也可以直接fun()定义,不带任何参数。
  • 参数返回,可以显示加 return 返回,如果不加,将以最后一条命令允许结果,作为返回值。n后跟数值n(0-255)
    下面的例子定义了一个函数并进行调用:
#!/bin/bash
demoFun(){
    echo "这是我的第一个shell函数!"
}
echo "----函数开始执行----"
demoFun
echo "----函数执行完毕----"

执行脚本,输出结果为:

----函数开始执行----
这是我的第一个shell函数!
----函数执行完毕----

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

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

执行脚本,输出结果比如:

这个函数会对输入的两个数字进行相加运算
输入第一个数字:
3
输入第二个数字:
4
两个数字分别为 3 和 4 !
输入的两个数字之和为 7 !

函数返回值在调用该函数后通过$?来获得。
注意:所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分,直至shell解释器首次发现它时,才可以使用。调用函数仅使用其函数名即可。

函数参数

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

#!/bin/bash
funWithParam(){
    echo "第一个参数为 $1 !"
    echo "第二个参数为 $2 !"
    echo "第十个参数为 $10 !"
    echo "第十个参数为 ${10} !"
    echo "第十一个参数为 ${11} !"
    echo "参数总数有 $# 个"
    echo "作为一个字符串输出所有参数 $*"
}
funWriteParam 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}来获取参数。

10.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).

输出重定向

重定向一般通过在命令间插入特定的符号来实现。特别的,这些符号的语法如下所示:

command1 > file1

上面这个命令执行command1,然后将输出的内容存入filel。
注意:任何file1内的已经存在的内容将被新内容替代。如果要将新内容添加在文件末尾,请使用>>操作符。

实例

执行下面的who命令,它将命令完整的输出重定向在用户文件中(users):

$ who > users

执行后,并没有在终端输出信息,这是因为输出已被从默认的标准输出设备(终端)重定向到指定文件。
你可以使用cat命令查看文件内容:

$ cat users
hadoop   tty1         2018-08-29 19:46 (:0)
hadoop   pts/0        2018-08-29 19:47 (:0.0)
root     pts/1        2018-08-29 19:48 (nn)
root     pts/2        2018-09-02 18:41 (192.168.80.1)
root     pts/3        2018-09-03 04:23 (192.168.80.1)

输出重定向会覆盖文件内容,例如:

$ echo "zkn" > users
$ cat users
zkn
$

如果不希望文件内容被覆盖,可以使用 >> 追加到文件末尾,例如:

$ echo "zkn" >> users
$ cat users
zkn
zkn
$

输入重定向

和输出重定向一样,Unix命令也可以从文件获取输入,格式为:

command1 < file1

这样,本来需要从键盘获取输入的命令会转移到文件读取内容。
注意:输出重定向是大于号( > ),输入重定向是小于号( < )。

实例

接着以上实例,我们需要统计users文件的行数,执行以下命令:

$ wc -l users
2 users

也可以将输入重定向到users文件:

$ wc -l < users
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

如果希望将stdout和stderr合并后重定向到file,可以这样写:

$ command > file 2>&!
或
$ command >> file 2>&1

备注:这里的&没有固定的意思。放在>后面的&,表示重定向的目标不是一个文件,而是一个文件描述符,内置的文件描述符如下:

0 => stdin
1 => stdout
2 => stderr

换言之 2>1 代表stderr重定向到当前路径下文件名为1regular file中,而2>&1代表将stderr重定向到文件描述符1的文件(即/dev/stdout)中,这个文件就是stdoutfile system中的映射。
&>file是一种特殊的用法,也可以写成>&file,二者的意思完全相同,都等价于

>file 2>&1

此处&>或者>&视作整体,分开没有单独的含义。
如果希望对stdin和stdout都重定向,可以这样写:

$ command < file1 > file2

此时,command命令将stdin重定向到file1,将stdout重定向到file2。

顺序问题
find /etc -name .bashrc > list 2>&1
#为什么不能调下顺序,比如:
find /etc -name .bashrc 2>&1 > list

这个从左到右是有顺序的。
第一种:

xxx > list 2>&1

先将要输出到stdout的内容重定向到文件,此时文件list就是这个程序的stdout,再将stderr重定向到stdout,也就是文件list
第二种:

xxx 2>&1 >list

先将要输出到stderr的内容重定向到stdout,此时会产生一个stdout的拷贝,作为程序的stderr,而程序原本要输出到stdout的内容,依然是对接在stdout原身上的,因此第二步重定向stdout,对stdout拷贝不产生任何影响。

Here Document

Here Document是Shell中的一种特殊的重定向方式,用来将输入重定向到一个交互式Shell脚本或程序。它的基本形式如下:

command << delimiter
    document
delimiter

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

注意:

  • 结尾的delimiter一定要定格写,前面不能有任何字符,后面也不能有任何字符,包括空格和tab缩进。
  • 开始的delimiter前后的空格会被忽略掉。
实例

在命令行中通过 wc -l 命令计算 Here Document 的行数:

$ wc -l << EOF
    欢迎学习
    shell
EOF
3     #输出结果为2

我们也可以将 Here Document 用在脚本中,例如:

#!/bin/bash
cat << EOF
欢迎学习
shell
EOF

执行脚本,输出结果为:

欢迎学习
shell

/dev/null文件

如果希望执行某个命令,但又不希望在屏幕上输出结果,那么可以将输出重定向到/dev/null:

$ command > /dev/null

/dev/null是一个特殊的文件,写入到它的内容都会被丢弃;如果尝试从该文件读取内容,那么什么也读不到。但是/dev/null文件非常有用,将命令的输出重定向到它,会起到"禁止输出"的效果。
如果希望屏蔽stdout和stderr,可以这样写:

$ command > /dev/null 2>&1
  • 注意:0*是标准输入(STDIN),1是标准输出(STDOUT),2是标准错误输出(STDERR)。

11.Shell 文件包含

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

. filename  #注意点号(.)和文件名中间有一空格
或
source filename
实例

创建两个shell脚本文件。
test1.sh代码如下:

#!/bin/bash
c1 = "shell"

test2.sh代码如下:

#!/bin/bash
#使用 . 号来引用./test1.sh文件
. ./test1.sh
#或者使用以下包含文件代码
#source ./test1.sh
echo "zkn在学习$c1"

接下来,我们为test2.sh添加可执行权限并执行:

$ chomd +x test2.sh
$ ./test2.sh
zkn在学习shell

*** 注:*此时被包含的文件test1.sh并不需要可执行权限。

推荐阅读更多精彩内容

  • 官网 中文版本 好的网站 Content-type: text/htmlBASH Section: User ...
    不排版阅读 3,096评论 0 5
  • .bat脚本基本命令语法 目录 批处理的常见命令(未列举的命令还比较多,请查阅帮助信息) 1、REM 和 :: 2...
    庆庆庆庆庆阅读 6,224评论 1 16
  • 系统管理与维护命令 date date(选项)(参数) | 选项 | 说明 | | :-------- | ...
    蓓蓓的万能男友阅读 2,817评论 0 4
  • linux资料总章2.1 1.0写的不好抱歉 但是2.0已经改了很多 但是错误还是无法避免 以后资料会慢慢更新 大...
    O感悟人生O阅读 10,149评论 2 33
  • 教育,一定是后天的,没有先天的说法。生理遗传对于人的成长而言,没有太多的影响,更多还是后天成长的氛围决...
    黄智华阅读 120评论 0 1