Linux Shell 基础语法学习

最新推荐文章于 2022-08-02 14:28:36 发布

Looooking

最新推荐文章于 2022-08-02 14:28:36 发布

阅读量344

点赞数 1

分类专栏： Linux 文章标签： Linux Shell

本文链接：https://blog.csdn.net/TomorrowAndTuture/article/details/108037620

版权

Linux 专栏收录该内容

26 篇文章 2 订阅

订阅专栏

Shell 的基本语法可能并不算复杂，但是在 Linux 强大 buff 的加持之下，高手却能用它创造出变化万千。

hello world

[root@master ~]# echo "hello world"
hello world

[root@master shell_learning]# ./test.sh
-bash: ./test.sh: Permission denied
[root@master shell_learning]# chmod +x ./test.sh
[root@master shell_learning]# ./test.sh
hello world

${}、$()、$(())

${}：对变量的替换，同 $var。

[root@master shell_learning]# a=Linux
[root@master shell_learning]# echo $ab

[root@master shell_learning]# echo ${a}b
Linuxb

${} ：变量设定。

命令	分隔符	说明	结果
初始化：[root@master shell_learning]# file=/dir1/dir2/dir3/my.file.txt
echo ${file#*/}	/	拿掉 file 中第一个 / 及其左边的字符串	dir1/dir2/dir3/my.file.txt
echo ${file##*/}	/	拿掉 file 中最后一个 / 及其左边的字符串	my.file.txt
echo ${file#*.}	.	拿掉 file 中第一个 . 及其左边的字符串	file.txt
echo ${file##*.}	.	拿掉 file 中最后一个 . 及其左边的字符串	txt
echo ${file%/*}	/	拿掉 file 中最后一个 / 及其右边的字符串	/dir1/dir2/dir3
echo ${file%%/*}	/	拿掉 file 中第一个 / 及其右边的字符串	（空值）
echo ${file%.*}	.	拿掉 file 中最后一个 . 及其右边的字符串	/dir1/dir2/dir3/my.file
echo ${file%%.*}	.	拿掉 file 中第一个 . 及其右边的字符串	/dir1/dir2/dir3/my
echo ${file/dir/path}		将 file 中第一个 dir 替换为 path	/path1/dir2/dir3/my.file.txt
echo ${file//dir/path}		将 file 中所有的 dir 替换为 path	/path1/path2/path3/my.file.txt
注解
# 是去掉左边 (在键盘上 # 在 $ 的左边)		一个 # 表示左边开始最小匹配，## 表示从左边开始最大匹配（贪婪匹配），一个 % 表示右边开始最小匹配，%% 表示从右边开始最大匹配（贪婪匹配），
% 是去掉右边 (在键盘上 % 在 $ 的右边)		* 是用来匹配不要的字符，也就是想要去掉的那部分。还可以指定字符分隔符号，与 * 配合，决定取哪部分。

echo ${#file}		获取 file 变量长度	27
echo ${file-my.file.txt}		若 $file 没设定,则使用 my.file.txt 作传回值	/dir1/dir2/dir3/my.file.txt
echo ${file:-my.file.txt}		若 $file 没有设定或为空值,则使用 my.file.txt 作传回值	/dir1/dir2/dir3/my.file.txt
echo ${file+my.file.txt}		若 $file 设为空值或非空值,均使用 my.file.txt 作传回值	my.file.txt
echo ${file:+my.file.txt}		若 $file 为非空值,则使用 my.file.txt 作传回值	my.file.txt
echo ${file=txt}		若 $file 没设定,则回传 txt ,并将 $file 赋值为 txt	/dir1/dir2/dir3/my.file.txt
echo ${file:=txt}		若 $file 没设定或空值,则回传 txt ,将 $file 赋值为 txt	/dir1/dir2/dir3/my.file.txt
echo ${file?my.file.txt}		若 $file 没设定,则将 my.file.txt 输出至 STDERR	/dir1/dir2/dir3/my.file.txt
echo ${file:?my.file.txt}		若 $file 没设定或空值,则将 my.file.txt 输出至 STDERR	/dir1/dir2/dir3/my.file.txt

初始化：[root@master shell_learning]# A=(a b c def) # 定义字符数组
echo ${A[@]}		返回数组全部元素	a b c def
echo ${A[*]}		返回数组全部元素	a b c def
echo ${A[0]}		返回数组第一个元素	a
echo ${#A[@]}		返回数组元素总个数	4
echo ${#A[*]}		返回数组元素总个数	4
echo ${#A[3]}		返回第四个元素的长度，即 def 的长度	3
echo A[3]=xzy		则是将第四个组数重新定义为 xyz

$()：对命令的替换，同 ``（反引号）。

[root@master shell_learning]# ls
test_dir  test.sh  test.txt

[root@master shell_learning]# a=$(ls)
[root@master shell_learning]# echo $a
test_dir test.sh test.txt

[root@master shell_learning]# a=`ls`
[root@master shell_learning]# echo $a
test_dir test.sh test.txt

$(())：对内部内容进行整数运算 $((var1*var2))。或将其他进制转换为十进制 $((N#var))，其中 N 为进制。

[root@master shell_learning]# echo $(2*3)
-bash: 2*3: command not found

[root@master shell_learning]# echo $((2*3))
6
[root@master shell_learning]# a=5;b=7;c=2
[root@master shell_learning]# echo $((a+b*c))
19
[root@master shell_learning]# echo $(($a+$b*$c))
19

[root@master shell_learning]# echo $((2#110))
6
[root@master shell_learning]# echo $((16#FF))
255
[root@master shell_learning]# echo $((16#2a))
42
[root@master shell_learning]# echo $((16#2A))
42

[root@master shell_learning]# a=5;b=7
[root@master shell_learning]# ((a++))
[root@master shell_learning]# echo $a
6
[root@master shell_learning]# ((a--)); echo $a
5
[root@master shell_learning]# ((a<b)); echo $?
0
[root@master shell_learning]# ((a>b)); echo $?
1

Shell 变量

变量名和等号之间不能有空格，这个其实也好理解，因为在 Linux 当中，默认把空格当成命令行参数分隔的标识，如果有空格的话，第一个参数就被 Shell 当成命令了。

使用变量

[root@master shell_learning]# name='hello'
[root@master shell_learning]# echo $name
hello

for skill in Ada Coffe Action Java; do
    echo "I am good at ${skill}Script"
done

------------------------------------------------------------
[root@master shell_learning]# ./test.sh
I am good at AdaScript
I am good at CoffeScript
I am good at ActionScript
I am good at JavaScript

赋值变量

使用变量的时候才加美元符（$），赋值的时候不用。

I am good at JavaScript
[root@master shell_learning]# your_name="tom"
[root@master shell_learning]# echo $your_name
tom
[root@master shell_learning]# your_name="alibaba"
[root@master shell_learning]# echo $your_name
alibaba

只读变量

#!/bin/bash
myUrl="https://www.google.com"
readonly myUrl
myUrl="https://www.runoob.com"

------------------------------------------------------------
[root@master shell_learning]# ./test.sh
./test.sh: line 4: myUrl: readonly variable

删除变量

#!/bin/sh
myUrl="https://www.runoob.com"
unset myUrl
echo $myUrl

------------------------------------------------------------
[root@master shell_learning]# ./test.sh

Shell 字符串

单引号

单引号字符串的限制：

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

[root@master shell_learning]# echo 'Hello, I know you are \"$your_name\"! \n'
Hello, I know you are \"$your_name\"! \n

双引号

双引号的优点：

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

[root@master shell_learning]# echo "Hello, I know you are \"$your_name\"! \n"
Hello, I know you are "alibaba"! \n

字符串拼接

# test.sh

your_name="Looking"
greeting="hello, "$your_name" !"
greeting2="hello, $your_name !"
greeting3="hello, ${your_name} !"
echo $greeting
echo $greeting2
echo $greeting3

greeting4='hello, '$your_name' !'
greeting5='hello, ${your_name} !'
echo $greeting4
echo $greeting5

------------------------------------------------------------
[root@master shell_learning]# ./test.sh 
hello, Looking !
hello, Looking !
hello, Looking !
hello, Looking !
hello, ${your_name} !

获取字符串长度

[root@master shell_learning]# string='abcd'
[root@master shell_learning]# echo $string
abcd
[root@master shell_learning]# echo ${#string}
4

提取子字符串

[root@master shell_learning]# string="runoob is a great site"

# 这儿要给变量加上 {} 帮助 Shell 识别边界哟
[root@master shell_learning]# echo ${string:1:4} # 输出 unoo
unoo
[root@master shell_learning]# echo $string:1:4
runoob is a great site:1:4

查找子字符串

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

string="runoob is a great site"
echo `expr index "$string" io`

[root@master shell_learning]# ./test.sh 
4

[root@master shell_learning]# expr index "$string" io
4

注意： 以上脚本中 ` 是反引号，而不是单引号 '，不要看错了哦，相信你在 MySQL 脚本当中也见过这个反引号。

Shell 数组

定义数组

array_name=('hello' 'world' '!')
array_name2=('hello', 'world', '!')
array_name3=(
'hello'
'world'
'!'
)
array_name4=()
array_name4[0]='hello'
array_name4[1]='world'
array_name4[2]='!'

读取数组

array_name=('hello' 'world' '!')
array_name3=(
'hello'
'world'
'!'
)
array_name4=()
array_name4[0]='hello'
array_name4[1]='world'
array_name4[2]='!'

echo ${array_name[@]}
echo ${array_name2[@]}
echo ${array_name3[@]}
echo ${array_name4[@]}

------------------------------------------------------------
[root@master shell_learning]# ./test.sh 
hello world !

hello world !
hello world !

获取数组长度

array_name=('hello' 'world' '!')
length=${#array_name[@]}
echo $length

length_1=${#array_name[1]}
echo $length_1

------------------------------------------------------------
[root@master shell_learning]# ./test.sh 
3
5

Shell 注释

单行注释

以 # 开头的行就是注释，会被解释器忽略。

通过每一行加一个 # 号设置多行注释。

array_name=('hello' 'world' '!')
length=${#array_name[@]}
echo $length

length_1=${#array_name[1]}
echo $length_1

#--------------------------------------------
# 这是一个注释
# author：菜鸟教程
# site：www.runoob.com
# slogan：学的不仅是技术，更是梦想！
#--------------------------------------------
##### 用户配置区 开始 #####
#
#
# 这里可以添加脚本描述信息
# 
#
##### 用户配置区 结束  #####

array_name=('hello' 'world' '!')
length=${#array_name[@]}
echo $length

length_1=${#array_name[1]}
echo $length_1

comment(){
--------------------------------------------
 这是一个注释
 author：菜鸟教程
 site：www.runoob.com
 slogan：学的不仅是技术，更是梦想！
--------------------------------------------
#### 用户配置区 开始 #####


 这里可以添加脚本描述信息
 

#### 用户配置区 结束  #####
}

脚本执行时仍然正常输出结果：

[root@master shell_learning]# ./test.sh 
3
5

如果在开发过程中，遇到大段的代码需要临时注释起来，过一会儿又取消注释，怎么办呢？

每一行加个 # 符号太费力了，可以把这一段要注释的代码用一对花括号括起来，定义成一个函数，没有地方调用这个函数，这块代码就不会执行，达到了和注释一样的效果。

多行注释

array_name=('hello' 'world' '!')
length=${#array_name[@]}
echo $length

length_1=${#array_name[1]}
echo $length_1

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

EOF 也可以使用其他符号:

array_name=('hello' 'world' '!')
length=${#array_name[@]}
echo $length

length_1=${#array_name[1]}
echo $length_1

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

Shell 传递参数

# test.sh

echo "Shell 传递参数实例！";
echo "执行的文件名：$0";
echo "第一个参数为：$1";
echo "第二个参数为：$2";
echo "第三个参数为：$3";

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
执行的文件名：./test.sh
第一个参数为：hello
第二个参数为：world
第三个参数为：!

$#

传递到脚本的参数个数

# test.sh
echo "Shell 传递参数实例！"
echo "参数个数为：$#"

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
参数个数为：3

$*

以一个单字符串显示所有向脚本传递的参数。如"$*"用「"」括起来的情况、以"$1 $2 … $n"的形式输出所有参数。

# test.sh
echo "Shell 传递参数实例！"
echo "传递的参数作为一个字符串显示：$*";

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
传递的参数作为一个字符串显示：hello world !

$$

脚本运行的当前进程 ID 号

# test.sh
echo "Shell 传递参数实例！"
echo "脚本运行的当前进程ID号：$$";

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
脚本运行的当前进程ID号：5443

$!

# test.sh
echo "Shell 传递参数实例！"
echo "后台运行的最后一个进程的ID号：$!";

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
后台运行的最后一个进程的ID号：

$@

与$*相同，但是使用时加引号，并在引号中返回每个参数。
如"$@"用「"」括起来的情况、以"$1" "$2" … "$n" 的形式输出所有参数。

# test.sh
echo "Shell 传递参数实例！"
echo "传递的参数作为一个字符串显示：$@";

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
传递的参数作为一个字符串显示：：hello world !

$-

显示Shell使用的当前选项，与set命令功能相同。

# test.sh
echo "Shell 传递参数实例！"
echo "$-"

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
hB

$?

显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。

# test.sh
echo "Shell 传递参数实例！"
echo "$?"

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
Shell 传递参数实例！
0

$* and $@

$* 与 $@ 区别：

相同点：都是引用所有参数。
不同点：只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3，，则 " * " 等价于 "1 2 3"（传递了一个参数），而 "@" 等价于 "1" "2" "3"（传递了三个参数）

# test.sh
echo "-- \$* 演示 ---"
for i in "$*"; do
    echo $i
done

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

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello world !
-- $* 演示 ---
hello world !
-- $@ 演示 ---
hello
world
!

参数校验

-n str，字符串不为null，长度大于零。

# test.sh
if [ -n "$1" ]; then
    echo "包含第一个参数"
else
    echo "没有包含第一参数"
fi

------------------------------------------------------------
[root@master shell_learning]# ./test.sh hello
包含第一个参数
[root@master shell_learning]# ./test.sh
没有包含第一参数

中括号

Shell 里面的中括号（包括单中括号与双中括号）可用于一些条件的测试：

算术比较, 比如一个变量是否为0, [ $var -eq 0 ]。
文件属性测试，比如一个文件是否存在，[ -e $var ], 是否是目录，[ -d $var ]。
字符串比较, 比如两个字符串是否相同， [[ $var1 = $var2 ]]。

Shell 基本运算符

算术运算符

运算符	说明	举例
+	加法	`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 ]。

注意：

乘号(*)前边必须加反斜杠(\)才能实现乘法运算（转义）；
if...then...fi 是条件语句，后续将会讲解。

[root@master ~]# a=10
[root@master ~]# b=20
[root@master ~]# val=`expr $a + $b`
[root@master ~]# echo "a + b = $val"
a + b = 30

[root@master ~]# val=`expr $a - $b`
[root@master ~]# echo "a - b = $val"
a - b = -10

[root@master ~]# val=`expr $a \* $b`
[root@master ~]# echo "a * b = $val"
a * b = 200

[root@master ~]# val=`expr $b / $a`
[root@master ~]# echo "b / a = $val"
b / a = 2

[root@master ~]# val=`expr $b % $a`
[root@master ~]# echo "b % a = $val"
b % a = 0

[root@master ~]# 
> if [ $a == $b ]
> then
>     echo "a == b"
> fi

[root@master ~]# 
> if [ $a != $b ]
> then
>     echo "a != b"
> fi
a != b

关系运算符

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

[root@master ~]# a=10
[root@master ~]# b=20
[root@master ~]# 
> if [ $a -eq $b ]
> then
>    echo "$a -eq $b : a 等于 b"
> else
>    echo "$a -eq $b: a 不等于 b"
> fi
10 -eq 20: a 不等于 b

----------------------------------------
[root@master ~]# 
> if [ $a -ne $b ]
> then
>    echo "$a -ne $b: a 不等于 b"
> else
>    echo "$a -ne $b : a 等于 b"
> fi
10 -ne 20: a 不等于 b

----------------------------------------
[root@master ~]# 
> if [ $a -gt $b ]
> then
>    echo "$a -gt $b: a 大于 b"
> else
>    echo "$a -gt $b: a 不大于 b"
> fi
10 -gt 20: a 不大于 b

----------------------------------------
[root@master ~]# 
> if [ $a -lt $b ]
> then
>    echo "$a -lt $b: a 小于 b"
> else
>    echo "$a -lt $b: a 不小于 b"
> fi
10 -lt 20: a 小于 b

----------------------------------------
[root@master ~]# 
> if [ $a -ge $b ]
> then
>    echo "$a -ge $b: a 大于或等于 b"
> else
>    echo "$a -ge $b: a 小于 b"
> fi
10 -ge 20: a 小于 b

----------------------------------------
[root@master ~]# 
> if [ $a -le $b ]
> then
>    echo "$a -le $b: a 小于或等于 b"
> else
>    echo "$a -le $b: a 大于 b"
> fi
10 -le 20: a 小于或等于 b

布尔运算符

运算符	说明	举例
!	非运算，表达式为 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。

[root@master ~]# a=10
[root@master ~]# b=20
[root@master ~]# 
[root@master ~]# 
> if [ $a != $b ]
> then
>    echo "$a != $b : a 不等于 b"
> else
>    echo "$a == $b: a 等于 b"
> fi
10 != 20 : a 不等于 b

----------------------------------------
[root@master ~]# 
> if [ $a -lt 100 -a $b -gt 15 ]
> then
>    echo "$a 小于 100 且 $b 大于 15 : 返回 true"
> else
>    echo "$a 小于 100 且 $b 大于 15 : 返回 false"
> fi
10 小于 100 且 20 大于 15 : 返回 true

----------------------------------------
[root@master ~]# 
> if [ $a -lt 100 -o $b -gt 100 ]
> then
>    echo "$a 小于 100 或 $b 大于 100 : 返回 true"
> else
>    echo "$a 小于 100 或 $b 大于 100 : 返回 false"
> fi
10 小于 100 或 20 大于 100 : 返回 true

----------------------------------------
[root@master ~]#
> if [ $a -lt 5 -o $b -gt 100 ]
> then
>    echo "$a 小于 5 或 $b 大于 100 : 返回 true"
> else
>    echo "$a 小于 5 或 $b 大于 100 : 返回 false"
> fi
10 小于 5 或 20 大于 100 : 返回 false

逻辑运算符

运算符	说明	举例
&&	逻辑的 AND	[[ $a -lt 100 && $b -gt 100 ]] 返回 false
\|\|	逻辑的 OR	[[ $a -lt 100 \|\| $b -gt 100 ]] 返回 true

[root@master ~]# a=10
[root@master ~]# b=20
[root@master ~]#
> if [[ $a -lt 100 && $b -gt 100 ]]
> then
>    echo "10 不大于 100 且 20 不小于 100： 返回 true"
> else
>    echo "10 不大于 100 且 20 不小于 100： 返回 false"
> fi
10 不大于 100 且 20 不小于 100： 返回 false

----------------------------------------
[root@master ~]# 
[root@master ~]#
> if [[ $a -lt 100 || $b -gt 100 ]]
> then
>    echo "10 不大于 100 或 20 不小于 100：返回 true"
> else
>    echo "10 不大于 100 或 20 不小于 100：返回 false"
> fi
10 不大于 100 或 20 不小于 100：返回 true

字符串运算符

运算符	说明	举例
=	检测两个字符串是否相等，相等返回 true。	[ $a = $b ] 返回 false。
!=	检测两个字符串是否相等，不相等返回 true。	[ $a != $b ] 返回 true。
-z	检测字符串长度是否为0，为0返回 true。	[ -z $a ] 返回 false。
-n	检测字符串长度是否不为 0，不为 0 返回 true。	[ -n "$a" ] 返回 true。
$	检测字符串是否为空，不为空返回 true。	[ $a ] 返回 true。

[root@master ~]# a="abc"
[root@master ~]# b="efg"
[root@master ~]# 
[root@master ~]#
> if [ $a = $b ]
> then
>    echo "$a = $b : a 等于 b"
> else
>    echo "$a = $b: a 不等于 b"
> fi
abc = efg: a 不等于 b

----------------------------------------
[root@master ~]#
> if [ $a != $b ]
> then
>    echo "$a != $b : a 不等于 b"
> else
>    echo "$a != $b: a 等于 b"
> fi
abc != efg : a 不等于 b

----------------------------------------
[root@master ~]#
> if [ -z $a ]
> then
>    echo "-z $a : 字符串长度为 0"
> else
>    echo "-z $a : 字符串长度不为 0"
> fi
-z abc : 字符串长度不为 0

----------------------------------------
[root@master ~]#
> if [ -n "$a" ]
> then
>    echo "-n $a : 字符串长度不为 0"
> else
>    echo "-n $a : 字符串长度为 0"
> fi
-n abc : 字符串长度不为 0

----------------------------------------
[root@master ~]#
> if [ $a ]
> then
>    echo "$a : 字符串不为空"
> else
>    echo "$a : 字符串为空"
> fi
abc : 字符串不为空

文件测试运算符

操作符	说明	举例
-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。

[root@master ~]# file="/root/test.txt"
[root@master ~]#
> if [ -r $file ]
> then
>    echo "文件可读"
> else
>    echo "文件不可读"
> fi
文件可读

----------------------------------------
[root@master ~]#
> if [ -w $file ]
> then
>    echo "文件可写"
> else
>    echo "文件不可写"
> fi
文件可写

----------------------------------------
[root@master ~]#
> if [ -x $file ]
> then
>    echo "文件可执行"
> else
>    echo "文件不可执行"
> fi
文件不可执行

----------------------------------------
[root@master ~]#
> if [ -f $file ]
> then
>    echo "文件为普通文件"
> else
>    echo "文件为特殊文件"
> fi
文件为普通文件

----------------------------------------
[root@master ~]#
> if [ -d $file ]
> then
>    echo "文件是个目录"
> else
>    echo "文件不是个目录"
> fi
文件不是个目录

----------------------------------------
[root@master ~]#
> if [ -s $file ]
> then
>    echo "文件不为空"
> else
>    echo "文件为空"
> fi
文件不为空

----------------------------------------
[root@master ~]#
> if [ -e $file ]
> then
>    echo "文件存在"
> else
>    echo "文件不存在"
> fi
文件存在

Shell echo

显示普通字符串

[root@master ~]# 
[root@master ~]# echo "It is a test"
It is a test

显示转义字符

[root@master ~]# echo "\"It is a test\""
"It is a test"

显示变量

[root@master ~]# read name
OK
[root@master ~]# echo "$name It is a test"
OK It is a test

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

------------------------------------------------------------
[root@master ~]# ./test.sh 
OK
OK It is a test

显示换行

[root@master ~]# echo -e "OK! \n" # -e 开启转义
OK! 

[root@master ~]# echo "It is a test"
It is a test
[root@master ~]# echo "OK! \n" # 未开启转义
OK! \n

显示不换行

[root@master ~]# echo -e "OK! \c" # -e 开启转义 \c 不换行
OK! [root@master ~]# echo "It is a test"
It is a test

结果定向至文件

[root@master ~]# echo "It is a test" > myfile
[root@master ~]# cat myfile
It is a test

原样输出字符串

[root@master ~]# name="Looking"
[root@master ~]# echo '$name\"'
$name\"
[root@master ~]# echo "$name\""
Looking"

显示命令执行结果

注意： 这里使用的是反引号 `（esc 按键下边那个）, 而不是单引号 '。

[root@master ~]# date
Sun Aug 16 22:31:35 CST 2020
[root@master ~]# echo `date`
Sun Aug 16 22:31:46 CST 2020

Shell printf

# format-string为双引号
[root@master ~]# printf "%d %s\n" 1 "abc"
1 abc

# 单引号与双引号效果一样 
[root@master ~]# printf '%d %s\n' 1 "abc" 
1 abc 

# 没有引号也可以输出
[root@master ~]# printf %s abcdef
abcdef[root@master ~]# 

# 格式只指定了一个参数，但多出的参数仍然会按照该格式输出，format-string 被重用
[root@master ~]# printf %s abc def
abcdef[root@master ~]# 

[root@master ~]# printf "%s\n" abc def
abc
def

[root@master ~]# printf "%s %s %s\n" a b c d e f g h i j
a b c
d e f
g h i
j

# 如果没有 arguments，那么 %s 用 NULL 代替，%d 用 0 代替
[root@master ~]# printf "%s and %d \n"
 and 0 

[root@master ~]# printf "a string, no processing:<%s>\n" "A\nB"
a string, no processing:<A\nB>

[root@master ~]# printf "a string, no processing:<%b>\n" "A\nB"
a string, no processing:<A
B>

[root@master ~]# printf "www.runoob.com \a"
www.runoob.com [root@master ~]#

Shell test

数值测试

参数	说明
-eq	等于则为真
-ne	不等于则为真
-gt	大于则为真
-ge	大于等于则为真
-lt	小于则为真
-le	小于等于则为真

[root@master ~]# num1=100
[root@master ~]# num2=100
[root@master ~]#
> if test $[num1] -eq $[num2]
> then
>     echo '两个数相等！'
> else
>     echo '两个数不相等！'
> fi
两个数相等！

[root@master ~]#
> if [ $num1 == $num2 ]
> then
>     echo '两个数相等！'
> else
>     echo '两个数不相等！'
> fi
两个数相等！

[root@master ~]# a=5
[root@master ~]# b=6
[root@master ~]# result=$[ a + b ]
[root@master ~]# echo "result 为： $result"
result 为： 11
[root@master ~]# result=$[ a - b ]
[root@master ~]# echo "result 为： $result"
result 为： -1

字符串测试

参数	说明
=	等于则为真
!=	不相等则为真
-z 字符串	字符串的长度为零则为真
-n 字符串	字符串的长度不为零则为真

[root@master ~]# num1="ru1noob"
[root@master ~]# num2="runoob"
[root@master ~]#
> if test $num1 = $num2
> then
>     echo '两个字符串相等!'
> else
>     echo '两个字符串不相等!'
> fi
两个字符串不相等!

[root@master ~]#
> if [ $num1 == $num2 ];
> then
>     echo '两个字符串相等!'
> else
>     echo '两个字符串不相等!'
> fi
两个字符串不相等!

[root@master ~]# num1="runoob"
[root@master ~]# num2=""
[root@master ~]# test -z "$num1"
[root@master ~]# echo $?
1
[root@master ~]# test -n "$num1"
[root@master ~]# echo $?
0
[root@master ~]# test -z "$num2"
[root@master ~]# echo $?
0
[root@master ~]# test -n "$num2"
[root@master ~]# echo $?
1

文件测试

参数	说明
-e 文件名	如果文件存在则为真
-r 文件名	如果文件存在且可读则为真
-w 文件名	如果文件存在且可写则为真
-x 文件名	如果文件存在且可执行则为真
-s 文件名	如果文件存在且至少有一个字符则为真
-d 文件名	如果文件存在且为目录则为真
-f 文件名	如果文件存在且为普通文件则为真
-c 文件名	如果文件存在且为字符型特殊文件则为真
-b 文件名	如果文件存在且为块特殊文件则为真

# test.sh
cd /bin
if test -e ./bash
then
    echo '文件已存在!'
else
    echo '文件不存在!'
fi

------------------------------------------------------------
[root@master ~]# ./test.sh 
文件已存在!

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

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

------------------------------------------------------------
[root@master ~]# ./test.sh 
至少有一个文件存在!

其他测试

Shell 流程控制

if 和 if else

[root@master ~]# a=10
[root@master ~]# b=20
[root@master ~]#
> 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

[root@master ~]# num1=$[2*3]
[root@master ~]# num2=$[1+5]
[root@master ~]#
> if test $[num1] -eq $[num2]
> then
>     echo '两个数字相等!'
> else
>     echo '两个数字不相等!'
> fi
两个数字相等!

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

for 循环

一行流：for var in item1 item2 ... itemN; do command1; command2… done;

[root@master ~]#
> 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

------------------------------------------------------------
[root@master ~]#
> for loop in hello world !
> do
>     echo $loop
> done
hello
world
!

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

[root@master ~]#
> for((i=1; i<=5; i++));do
>     echo "这是第 $i 次调用";
> done;
这是第 1 次调用
这是第 2 次调用
这是第 3 次调用
这是第 4 次调用
这是第 5 次调用

------------------------------------------------------------
[root@master ~]#
> for((i=1; $i<=5; i++));do
>     echo "这是第 $i 次调用";
> done;
这是第 1 次调用
这是第 2 次调用
这是第 3 次调用
这是第 4 次调用
这是第 5 次调用

while 语句

[root@master ~]# int=1
[root@master ~]#
> while(( $int<=5 ))
> do
>     echo $int
>     let "int++"
> done
1
2
3
4
5

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

until 循环

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

condition 一般为条件表达式，如果返回值为 false，则继续执行循环体内的语句，否则跳出循环。

[root@master ~]# a=0
[root@master ~]# 
[root@master ~]#
> until [ ! $a -lt 10 ]
> do
>    echo $a
>    a=`expr $a + 1`
> done
0
1
2
3
4
5
6
7
8
9

------------------------------------------------------------
[root@master ~]#
> until [ $a -gt 20 ]
> do
>    echo $a
>    a=`expr $a + 1`
> done
10
11
12
13
14
15
16
17
18
19
20

case 命令

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

case 取值后面必须为单词in，每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后，其间所有命令开始执行直至 ;;。取值将检测匹配的每一个模式。一旦模式匹配，则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式，使用星号 * 捕获该值，再执行后面的命令。

# test.sh
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

------------------------------------------------------------
[root@master ~]# ./test.sh 
输入 1 到 4 之间的数字:
你输入的数字为:
3
你选择了 3
[root@master ~]# ./test.sh 
输入 1 到 4 之间的数字:
你输入的数字为:
5
你没有输入 1 到 4 之间的数字

# test.sh
site="runoob"

case "$site" in
   "runoob") echo "菜鸟教程"
   ;;
   "google") echo "Google 搜索"
   ;;
   "taobao") echo "淘宝网"
   ;;
esac

------------------------------------------------------------
[root@master ~]# ./test.sh 
菜鸟教程

break 命令

break命令允许跳出所有循环（终止执行后面的所有循环）。

# test.sh
while :
do
    echo -n "输入 1 到 5 之间的数字:"
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你输入的数字为 $aNum!"
        ;;
        *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
            break
        ;;
    esac
done

------------------------------------------------------------
[root@master ~]# ./test.sh 
输入 1 到 5 之间的数字:2
你输入的数字为 2!
输入 1 到 5 之间的数字:4
你输入的数字为 4!
输入 1 到 5 之间的数字:6
你输入的数字不是 1 到 5 之间的! 游戏结束

continue 命令

continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。

# test.sh
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

------------------------------------------------------------
[root@master ~]# ./test.sh 
输入 1 到 5 之间的数字: 3
你输入的数字为 3!
输入 1 到 5 之间的数字: 7
你输入的数字不是 1 到 5 之间的!
输入 1 到 5 之间的数字: 3
你输入的数字为 3!
输入 1 到 5 之间的数字: 
...

无限循环

while :
do
    command
done

while true
do
    command
done

for (( ; ; ))

Shell 函数

函数 demo

1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。
2、参数返回，可以显示加：return 返回，如果不加，将以最后一条命令运行结果，作为返回值。

# test.sh
demoFun(){
    echo "这是我的第一个 shell 函数!"
}
echo "-----函数开始执行-----"
demoFun
echo "-----函数执行完毕-----"

------------------------------------------------------------
[root@master ~]# ./test.sh 
-----函数开始执行-----
这是我的第一个 shell 函数!
-----函数执行完毕-----

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

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

------------------------------------------------------------
[root@master ~]# ./test.sh 
这个函数会对输入的两个数字进行相加运算...
输入第一个数字: 
23
输入第二个数字: 
32
两个数字分别为 23 和 32 !
输入的两个数字之和为 55 !

函数参数

# test.sh
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

------------------------------------------------------------
[root@master ~]# ./test.sh 
第一个参数为 1 !
第二个参数为 2 !
第十个参数为 10 !
第十个参数为 34 !
第十一个参数为 73 !
参数总数有 11 个!
作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !

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

另外，还有几个特殊字符用来处理参数（之前的小结有讲过）：

参数处理	说明
$#	传递到脚本或函数的参数个数
$*	以一个单字符串显示所有向脚本传递的参数
$$	脚本运行的当前进程ID号
$!	后台运行的最后一个进程的ID号
$@	与$*相同，但是使用时加引号，并在引号中返回每个参数。
$-	显示Shell使用的当前选项，与set命令功能相同。
$?	显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。

函数中的 $?

# test.sh
function demoFun1(){
    echo "这是我的第一个 shell 函数!"
    return `expr 1 + 1`
}

demoFun1
echo $?

function demoFun2(){
 echo "这是我的第二个 shell 函数!"
 expr 1 + 1
}

demoFun2
echo $?
demoFun1
echo 在这里插入命令！
echo $?

------------------------------------------------------------
[root@master ~]# ./test.sh 
这是我的第一个 shell 函数!
2
这是我的第二个 shell 函数!
2
0
这是我的第一个 shell 函数!
在这里插入命令！
0

$? 仅对其上一条指令负责，一旦函数返回后其返回值没有立即保存入参数，那么其返回值将不再能通过 $? 获得，因此，demoFun1 函数体里边有 return 语句，所以其执行后的 $? 没获得返回值 0。

调用 demoFun2 后，函数最后一条命令 expr 1 + 1 得到的返回值（$?值）为 0，意思是这个命令没有出错。所有的命令的返回值仅表示其是否出错，而不会有其他有含义的结果。

第二次调用 demoFun1 后，没有立即查看 $? 的值，而是先插入了一条别的 echo 命令，最后再查看 $? 的值得到的是 0，也就是上一条 echo 命令的结果，而 demoFun1 的返回值被覆盖了。

函数结果作为条件参数

函数与命令的执行结果可以作为条件语句使用。要注意的是，和 C 语言不同，shell 语言中 0 代表 true，0 以外的值代表 false。

# test.sh
echo "Hello World !" | grep -e Hello
echo $?
echo "Hello World !" | grep -e Bye
echo $?
if echo "Hello World !" | grep -e Hello
then
    echo true
else
    echo false
fi

if echo "Hello World !" | grep -e Bye
then
    echo true
else
    echo false
fi

function demoFun1(){
    return 0
}

function demoFun2(){
    return 12
}

if demoFun1
then
    echo true
else
    echo false
fi

if demoFun2
then
    echo ture
else
    echo false
fi

------------------------------------------------------------
Hello World !
0
1
Hello World !
true
false
true
false

grep 是从给定字符串中寻找匹配内容的命令。首先看出如果找到了匹配的内容，会打印匹配部分且得到的返回值 $? 为 0，如果找不到，则返回值 $? 为 1。接下来分别将这两次执行的 grep 命令当作条件语句交给 if 判断，得出返回值 $? 为 0，即执行成功时，条件语句为 true，当返回值 $? 为 1，即执行失败时，条件语句为 false。之后再用函数的 return 值作为测试，其中 demoFun1 返回值为 0，demoFun2 返回值选择了任意一个和 0 不同的整数，这里为 12。将函数作为条件语句交给 if 判断，得出返回值为 0 时，依然为 true，而返回值只要不是 0，条件语句都判断为 false。

Shell 输入输出重定向

命令	说明
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）。

输出重定向

执行后，并没有在终端输出信息，这是因为输出已被从默认的标准输出设备（终端）重定向到指定的文件。

[root@master ~]# who > users
[root@master ~]# cat users
root     pts/0        2020-08-19 20:56 (192.168.128.1)

输出重定向会覆盖文件内容：

[root@master ~]# echo "Hello World" > users
[root@master ~]# cat users
Hello World

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

[root@master ~]# echo "I am Looking" >> users
[root@master ~]# cat users
Hello World
I am Looking

输入重定向

和输出重定向一样，Unix 命令也可以从文件获取输入，语法为：

command1 < file1

这样，本来需要从键盘获取输入的命令会转移到文件读取内容。

注意：输出重定向是大于号(>)，输入重定向是小于号(<)。

接着以上实例，我们需要统计 users 文件的行数：

[root@master ~]# wc -l users
2 users

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

[root@master ~]# wc -l < users
2

注意：上面两个例子的结果不同：第一个例子，会输出文件名；第二个不会，因为它仅仅知道从标准输入读取内容。

重定向深入

一般情况下，每个 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 前后的空格会被忽略掉。

[root@master workspace]# wc -l << EOF
>     欢迎来到
>     菜鸟教程
>     www.runoob.com
> EOF
3

[root@master workspace]# 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

注意：0 是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。

这里的 2 和 > 之间不可以有空格，2> 是一体的时候才表示错误输出。

Shell 文件包含

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

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

或

source filename

# test1.sh
url="http://www.runoob.com"

# test2.sh
. ./test1.sh

# 或者使用以下包含文件代码
# source ./test1.sh

echo "菜鸟教程官网地址：$url"

------------------------------------------------------------
# test2.sh
# . ./test1.sh

# 或者使用以下包含文件代码
source ./test1.sh

echo "菜鸟教程官网地址：$url"

我们为 test2.sh 添加可执行权限并执行：

[root@master workspace]# chmod +x test2.sh
[root@master workspace]# ./test2.sh 
菜鸟教程官网地址：http://www.runoob.com

注意：被包含的文件 test1.sh 可以不需要可执行权限。

to be continued

------------------------------------------------------------

Looooking

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录