Shell变量、运算符

发表于

Shell 是操作系统的最外层，为用户提供了一个与系统交互的界面，它不仅支持直接输入命令来控制进程和文件，还整合了编程语言的特性，使用户能够通过编写脚本实现复杂的任务。可以说，Shell 是用户与 Linux 操作系统之间的重要桥梁。

Linux 系统中的 Shell 种类非常丰富，常见的有 Bourne Shell（/usr/bin/sh​）、Bourne Again Shell（/usr/bin/bash​）、C Shell、Korn Shell（K Shell）等。由于不同的 Shell 拥有不同的语法特性，它们之间的脚本通常不能直接通用。然而，在众多选择中，最为流行且广泛使用的便是 Bash（Bourne Again Shell），它功能强大、兼容性好，几乎是所有现代 Linux 发行版的默认 Shell，后面shell默认为Bash。

接下来探讨 Shell 脚本的基本语法与核心功能，并通过实际案例展示如何利用 Bash 脚本高效地完成任务。在运维过程中，常涉及到查询登录文档、追踪流量、监控主机硬件状态、用户使用情况以及主机软件更新查询等操作。为了避免每次手动处理这些繁琐任务，编写 固定的自动化处理流程 —— 即 Shell 脚本，成为了必要的解决方案。Shell 脚本是利用 Shell 的功能编写的程序，它是一个 纯文本文件，包含了 Shell 的语法和指令，并结合 正规文法、管道命令和 数据流重定向 等功能，能够自动化执行多种系统管理任务，从而提高工作效率并减少人工操作的错误。

shell脚本一般文件名以.sh结尾，文件的第一行定义出该脚本的类型。其基本格式如下：

1
2
3
4
5
6
7
8
9
10
11
12
#--------------------------------------------
#!bin/bash                           
# scripte:  test.sh                  
# author:   zyming                   
# date:     2024-12-4                
# funtion:  echo the scripts arguments 
#--------------------------------------------

echo "脚本名： $0" 
echo "已接收参数数量： $#" 
echo "所有参数： $*"
echo "返回状态:  $?"

如上述脚本的注释记录了必要的信息，例如脚本功能，编写时间等，功能为输出shell脚本的传递参数。

如何去执行脚本呢？在执行之前首先要赋予执行权限：

1
chmod uo+x test.sh

其次可以直接运行或者sh运行：

1
2
3
4
5
6
7
./test.sh 或者/usr/bin/sh test.sh

[zyming@localhost ~]$ /usr/bin/sh test.sh 1 2 3
脚本名： test.sh
已接收参数数量： 3
所有参数： 1 2 3
返回状态:  0

返回状态0表示正常执行结束退出。

变量

Shell是非类型的编程语言，不像c++/java编程要声明变量，shell给一个变量赋值，实际上就是定义了变量。定义变量时，变量不加$，而使用的时候需要，标准引用变量格式。

Shell变量可以分为2类：

  1. 局部变量只在创建它们的shell脚本中使用；
  2. 环境变量可以在创建它们的shell以及派生出的任意子进程中使用。

变量名的命名遵循以下规则：

  1. 只含数字、字母和下划线
  2. 不能以数字开头
  3. 避免使用Shell关键字：例如，for， if，then…
  4. 常量使用大写字母：例如，PI=3.14…
  5. 避免使用空格

有效的变量名如下：

1
2
3
LD_LIBRARY_PATH="/bin/"
_var="123"
var2="abc"

无效的变量名如下：

1
2
3
4
5
6
7
8
#避免使用if作为变量名
if="some_value"
#避免使用 $ 等特殊符号
variable_with_$=42
?var=123
user*name=runoob
#避免空格
variable with space="value"

除了显示地直接赋值，还可以用语句给变量赋值，如：

1
2
3
for file in `ls /etc`
或
for file in $(ls /etc)

以上语句将/etc下的文件名循环赋值给file。

只读变量

使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。

下面的例子尝试更改只读变量，结果报错：

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

myUrl="https://www.google.com"
readonly myUrl
myUrl="https://www.runoob.com"

#运行结果如下：
/bin/sh: NAME: This variable is read only.

删除变量

使用 unset 命令可以删除变量。用法：

1
unset variable_name

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

数据类型

字符串变量

在 Shell中，变量通常被视为字符串。你可以使用单引号 ‘ 或双引号 “ 来定义字符串，例如：

1
2
3
my_string='Hello, World!'
或者
my_string="Hello, World!"

其中，单引号’里的内容会原样输出，而双引号“的内容里存在变量或者表达式则会被解析为其具体的数值。

整数变量

使用 declare 或 typeset 命令来声明整数变量。这样的变量只包含整数值，例如：

1
declare -i my_integer=42

这样的声明告诉 Shell 将 my_integer 视为整数，如果尝试将非整数值赋给它，Shell会尝试将其转换为整数。

数组变量

Shell 也支持数组，允许你在一个变量中存储多个值。数组可以是整数索引数组或关联数组，以下是一个简单的整数索引数组的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
my_array=(1 2 3 4 5)

#输出数组
echo ${my_array[*]} # {}是必须的

#输出数组元素
echo ${my_array[n]} # n这里可以是0~4

#循环处理数组
for i in ${!my_array[*]} # 加!表示i从0开始
do
echo "$i -> ${my_array[$i]}"
done

#输出数组长度
echo ${#my_array[*]}

或者关联数组：

1
2
3
declare -A associative_array
associative_array["name"]="John"
associative_array["age"]=30

经测试，关联数组的输出方法与整数索引数组基本一致，不同之处在于，一个通过索引来访问数组，一个通过键来访问数组。

环境变量

这些是由操作系统或用户设置的特殊变量，用于配置 Shell 的行为和影响其执行环境。例如，PATH 变量包含了操作系统搜索可执行文件的路径，HISTSIZE变量设置了可记录的历史指令的条数。但需注意，Linux操作系统有不止一个环境，他们是总环境/etc/profile和用户环境/home/[user]/.bash_profile，通常如果相同的环境变量有不一致的地方以用户自己的环境变量为准。

1
2
3
4
5
6
echo $PATH

#临时添加环境变量PATH
export PATH=$PATH:/new/path # 增加到变量已存放数值的末尾
或者
export PATH=/new/path:$PATH # 增加到变量已存放数值的开头

为了让路径的修改在每次登录后都生效，可以将 export PATH=...​ 这条命令添加到你的用户配置文件中（如 .bashrc​ 或 .bash_profile​，具体取决于你的系统配置）。

1
2
## 使改动生效
source ~/.bash_profile

传递参数

我们可以在执行 Shell 脚本时，向脚本传递参数，脚本内获取参数的格式为 $n，n 代表一个数字，1 为执行脚本的第一个参数，2 为执行脚本的第二个参数。

例如可以使用 $1、$2 等来引用传递给脚本的参数，其中 $1 表示第一个参数，$2 表示第二个参数，依此类推。

选项 含义
$0 当前程序名称
$n 第n个参数
$$ 脚本运行的当前进程ID号
$! 后台运行的最后一个进程的ID号
$* 以一个单字符串显示所有向脚本传递的参数。当前程序的所有参数（不包括程序本身）
$@ 以”$1” “$2” … “$n” 的形式输出所有参数。用于循环。
$# 参数个数（不包括程序本身）
$? 程序返回值
$- 显示Shell使用的当前选项，与set命令功能相同。
$UID 用户ID
$PWD 当前目录

运算符

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

  • 算数运算符
  • 关系运算符
  • 布尔运算符
  • 字符串运算符
  • 文件测试运算符

原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，expr 最常用。expr 是一款表达式计算工具，使用它能完成表达式的求值操作。例如，两个数相加(注意使用的是反引号 ` 而不是单引号 ‘ )：

1
val=`expr = 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。
== 相等。 [ $a == $b ] 返回 false。
!= 不相等。 [ $a != $b ] 返回 true。

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

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#--------------------------------------------
#!bin/bash                           
# scripte:  arith.sh                  
# author:   zyming                   
# date:     2024-12-9                
# funtion:  display Arithmetic operations 
#--------------------------------------------

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

#执行结果
: ' 
[zyming@localhost ~]$ ./arith.sh 
a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a 不等于 b
'

注意：

  • expr中乘号(*)前边必须加反斜杠(\)才能实现乘法运算；或使用 $((表达式)) ，此处表达式中的 “*“ 不需要转义符号 “\“；
  • if…then…fi 是条件语句，后续将会讲解；
  • 执行输出结果被注释，后续将会讲解。

关系运算符

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

运算符 说明 举例
-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。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#--------------------------------------------
#!bin/bash                           
# scripte:  rela.sh                  
# author:   zyming                   
# date:     2024-12-9                
# funtion:  display relation operations 
#--------------------------------------------

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

#执行结果
: '
[zyming@localhost ~]$ ./rela.sh 
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。 [ $a -lt 20 -o $b -gt 100 ] 返回 true。
-a / && 与运算，两个表达式都为 true 才返回 true。 [ $a -lt 20 -a $b -gt 100 ] 返回 false。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#--------------------------------------------
#!bin/bash                         
# scripte:  bool.sh                
# author:   zyming                 
# date:     2024-12-9              
# funtion:  display bool operations 
#--------------------------------------------

a=10
b=20

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

#执行结果
: '
[zyming@localhost ~]$ ./bool.sh 
10 小于 100 且 20 大于 15 : 返回 true
10 小于 100 或 20 大于 100 : 返回 true
10 小于 5 或 20 大于 100 : 返回 false
'

字符串运算符

下表列出了常用的字符串运算符，假定变量 a 为 “abc”，变量 b 为 “efg”：

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

检测字符串是否不为空，不为空返回 true。 [ $a ] 返回 true。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#--------------------------------------------
#!bin/bash                         
# scripte:  string.sh                
# author:   zyming                 
# date:     2024-12-9              
# funtion:  display string operations 
#--------------------------------------------

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

文件测试运算符

操作符 说明 举例
-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。
FILE1 -nt FILE2 FILE1 is newer (modification date) than FILE2
FILE1 -ot FILE2 FILE1 is older than FILE2

实例

变量 file 表示文件 /home/zyming/test.sh，它的大小为 6 字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#--------------------------------------------
#!bin/bash                         
# scripte:  test2.sh                
# author:   zyming                 
# date:     2024-12-9              
# funtion:  display test operations 
#--------------------------------------------

file="/home/zyming/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 本身没有像 C、C++ 或 Java 那样的 ++ 和 – 操作符，但可以通过其他方式实现相同的功能。以下是一些常见的方法：

使用 let 命令

let 命令允许对整数进行算术运算。

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

# 初始化变量
num=5

# 自增
let num++

# 自减
let num--

echo $num

使用(())进行算术运算

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

# 初始化变量
num=5

# 自增
((num++)) # 或者num=$((num ++))

# 自减
((num--)) # 或者num=$((num --))

echo $num

多行注释

使用Here文档

1
2
3
4
5
:<<EOF
注释内容...
注释内容...
注释内容...
EOF

以上例子中，: 是一个空命令，用于执行后面的 Here 文档，<<EOF 表示开启 Here 文档，EOF 是 Here 文档的标识符，在这两个标识符之间的内容都会被视为注释，不会被执行。EOF 也可以使用其他符号:

  • COMMENT
  • 单引号’
  • 感叹号!

直接使用冒号

我们也可以使用了冒号 : 命令，并用单引号 ‘ 将多行内容括起来。由于冒号是一个空命令，这些内容不会被执行。格式为：: + 空格 + 单引号。

1
2
3
4
: '
这是注释的部分。
可以有多行内容。
'

参考

Shell 变量 | 菜鸟教程

Shell 传递参数 | 菜鸟教程

Shell 基本运算符 | 菜鸟教程