Shell Bash变量与运算符（含条件测试与流程控制）

在Linux Bash脚本开发中，变量与运算符是基础核心知识点，贯穿脚本编写的全过程。本文将详细讲解Bash变量的特性、各类运算符的使用方法，以及基于运算符的条件测试和流程控制语句，搭配实操案例，帮助新手快速上手。

一、Bash变量基础（重点）

1.1 变量类型特性

Bash 变量没有严格的类型定义，本质上所有变量都是字符串。但存在一个特殊情况：若一个字面常量或变量的值是纯数字（不包含字母、符号等其他字符），Bash会自动将其视为长整型值，支持进行算术运算和比较运算。

也可以通过内置命令显式声明整型变量，格式如下：

declare -i 变量名  # 显式声明变量为整型

演示示例

# 未显式声明，纯数字自动视为整型
num=10
echo $((num + 5))  # 输出：15（算术运算正常）

# 显式声明整型变量
declare -i int_num=20
int_num=$int_num+10  # 整型变量直接支持运算，无需特殊格式
echo $int_num  # 输出：30

# 字符串变量无法进行算术运算
str_num="10a"
echo $((str_num + 5))  # 报错，提示参数错误（非纯数字）

1.2 数组变量

Bash 2.x 及以上版本支持一维数组，数组下标从 0 开始，无需提前声明数组长度，赋值方式灵活。

（1）数组声明与赋值

# 方式1：使用declare -a声明数组
declare -a variable
# 方式2：直接赋值（批量赋值）
variable=(item1 item2 item3 ...)
# 方式3：指定下标赋值（无需按顺序）
variable[n]=value

（2）数组引用

${variable[n]}  # 引用数组第n个元素（n从0开始）
${variable[*]}  # 引用数组所有元素
${#variable[*]} # 查看数组元素个数

（3）数组删除

unset variable[n]  # 删除数组第n个元素
unset variable     # 删除整个数组

（4）实操案例

# 声明并赋值数组
declare -a stu
stu=(math1101 math1102 math1103)
echo ${stu[0]}   # 输出：math1101（第一个元素）
echo ${stu[*]}   # 输出：math1101 math1102 math1103（所有元素）
echo ${#stu[*]}  # 输出：3（元素个数）

# 非顺序赋值
x[3]=100
echo ${x[*]}     # 输出：100（仅赋值的元素）
state=(ME [3]=CA [2]=NT)
echo ${state[*]} # 输出：ME NT CA（下标0为ME，下标2为NT，下标3为CA）

# 数组删除演示
unset stu[1]     # 删除stu数组第2个元素（下标1）
echo ${stu[*]}   # 输出：math1101 math1103（删除后剩余元素）
unset x          # 删除整个x数组
echo ${x[*]}     # 输出：空（数组已删除）

二、算术运算符与算术运算方式

2.1 常用算术运算符

Linux Shell中，常用算术运算符用于整数运算（不支持浮点数，浮点数需借助bc、awk等工具），具体如下表所示：

运算符	说明	举例	结果
+	加运算	3+5	8
-	减运算	5-3	2
*	乘运算	5*3	15
/	除运算（整数除法，舍去小数）	8/3	2
%	取余运算（余数符号与被除数一致）	15%4	3
**	幂运算（求一个数的n次方）	5**3	125

演示示例

# 结合算术扩展，演示所有运算符
echo $((3+5))    # 加运算，输出：8
echo $((5-3))    # 减运算，输出：2
echo $((5*3))    # 乘运算，输出：15
echo $((8/3))    # 除运算（舍去小数），输出：2
echo $((15%4))   # 取余运算，输出：3
echo $((5**3))   # 幂运算，输出：125

# 浮点数运算演示（借助bc工具）
echo "8/3" | bc -l  # 输出：2.6666666666666666666（保留多位小数）
echo "2.5+3.8" | bc # 输出：6.3

2.2 算术运算扩展（最常用）

Bash提供两种常用的算术运算扩展方式，语法简洁，支持复杂表达式，括号内变量前的$符号可省略。

（1）语法格式

• $expression：简易扩展，不支持复杂逻辑

• $((expression))：推荐扩展，支持复杂算术表达式

（2）实操案例

# 基础运算
num1=$[4+1]; echo $num1  # 输出：5
num1=$(($num1*2-3)); echo $num1  # 输出：7（5*2-3=7）

# 复杂表达式（幂运算、取余、加减混合）
((num2=2+3**2-1001%5)); echo $num2  # 输出：2+9-1=10
num2=$((2+3**2-1001%5)); echo $num2  # 输出：10（与上一行等价）
echo $((2+3**2-1001%5))  # 直接输出表达式结果：10

# 变量省略$符号演示
a=5; b=3
echo $((a + b * 2))  # 输出：11（a、b前省略$，正常运算）

2.3 Shell内置命令let

let 是Bash内置命令，专门用于执行算术运算，语法简洁，但有严格的格式要求。

核心注意事项

• 赋值符号（=）和运算符（+、-等）两边不能留空格（除非用双引号包裹）；

• 若将字符串赋值给整型变量，变量值会自动设为0；

• 若变量值为字符串，进行算术运算时，该变量会被视为0；

• 推荐给表达式加双引号，避免空格带来的语法错误。

实操案例

num2=1; echo $num2  # 输出：1
let num2=4+1; echo $num2  # 输出：5（正确，无空格）
let num2=$num2+1; echo $num2  # 输出：6（变量参与运算）

# 错误示例（空格问题）
# let num2=4 + 1  # 报错，运算符两边不能留空格

# 正确示例（用双引号忽略空格）
let "num2=4 + 1"; echo $num2  # 输出：5

# 字符串赋值给整型变量
declare -i str_var
str_var="test"
echo $str_var  # 输出：0（字符串自动转为0）
let str_var=str_var + 5  # 字符串视为0，运算后为5
echo $str_var  # 输出：5

2.4 通用表达式计算命令expr

expr 是Linux通用的表达式计算命令，支持算术运算、比较运算、字符串运算和逻辑运算，格式要求严格。

核心注意事项

• 表达式中，参数与操作符之间必须用空格分隔；

• 乘法符号（*）、括号（()）必须加反斜杠（\）转义，否则会被Shell解析为特殊符号；

• 运算结果会直接输出，需用变量接收才能后续使用。

实操案例

expr 5 % 3  # 输出：2（取余运算）
expr 5 \* 3  # 输出：15（乘法运算，*必须转义）
expr 2 + 5 \* 2 - 3 % 2  # 输出：2+10-1=11（遵循运算优先级）
expr \( 2 + 5 \) \* 2 - 3  # 输出：14-3=11（括号转义，改变运算优先级）

# 变量接收expr运算结果
result=$(expr 10 / 2)
echo $result  # 输出：5

2.5 自增自减运算符

自增自减运算符用于变量的自增（+1）或自减（-1），分为前置和后置两种，核心区别在于"变量值改变的时机"。

核心规则

• 前置操作（++variable、--variable）：先改变变量值，再将改变后的值用于表达式；

• 后置操作（variable++、variable--）：先将变量当前值用于表达式，再改变变量值；

• 操作元只能是变量，不能是常数或表达式（如++1、(num+2)++ 均不合法）；

• 变量值必须为整数型，否则运算报错。

演示示例

# 前置自增/自减
a=5
echo $((++a))  # 先自增（a变为6），再输出，结果：6
echo $a        # 输出：6（变量已改变）

b=5
echo $((--b))  # 先自减（b变为4），再输出，结果：4
echo $b        # 输出：4（变量已改变）

# 后置自增/自减
c=5
echo $((c++))  # 先输出当前值（5），再自增（c变为6），结果：5
echo $c        # 输出：6（变量已改变）

d=5
echo $((d--))  # 先输出当前值（5），再自减（d变为4），结果：5
echo $d        # 输出：4（变量已改变）

三、条件测试（核心应用）

条件测试是脚本逻辑判断的基础，用于判断"某个条件是否满足"，进而执行不同的命令。Bash中所有测试都有"退出状态"：退出状态为0表示条件为真（命令成功），非0表示条件为假（命令失败）。

状态变量 $? 用于保存上一条命令的退出状态值。

3.1 条件测试的三种格式

格式	说明	注意事项
test <测试表达式>	基础测试格式，与格式2等价	表达式前后无特殊要求
\<测试表达式\>	简化格式，替代test命令	后、 前必须留空格；不支持通配符、&&、||、<、>
\[ \<测试表达式\> ]	Bash 2.x+ 扩展格式，功能更强大	\[ 后、 ] 前必须留空格；支持通配符、&&、||、<、>

补充说明

除了上述三种格式，还可以用 ((表达式)) 进行整数相关的条件测试（后续会详细说明）。

实操案例（状态变量$?）

# 测试命令是否成功（查找当前用户在passwd文件中是否存在）
grep $USER /etc/passwd
echo $?  # 输出：0（条件为真，命令成功）

# 测试命令失败场景
grep hello /etc/passwd; echo $?  # 输出：1（条件为假，命令失败）

# 三种测试格式对比演示
test 5 -eq 5; echo $?  # 格式1，输出：0（真）
[ 5 -ne 3 ]; echo $?   # 格式2，输出：0（真）
[[ 5 -gt 3 ]]; echo $? # 格式3，输出：0（真）
((5 < 10)); echo $?    # (( ))格式，输出：0（真）

3.2 常用条件测试操作符

条件测试表达式的核心是"操作符"，根据测试类型可分为4类：整数比较、字符串测试、文件测试、逻辑运算。

（1）整数比较运算符

用于比较两个整数的大小，支持三种测试格式（ 、\[ ]、(( ))），操作符略有差异。

测试格式	操作符	说明	示例
或 \[ ]	-eq	int1 等于 int2	5 -eq 5 → 真（0）
或 \[ ]	-ne	int1 不等于 int2	\[ 5 -ne 3 ] → 真（0）
或 \[ ]	-gt	int1 大于 int2	5 -gt 3 → 真（0）
或 \[ ]	-ge	int1 大于或等于 int2	\[ 5 -ge 5 ] → 真（0）
或 \[ ]	-lt	int1 小于 int2	3 -lt 5 → 真（0）
或 \[ ]	-le	int1 小于或等于 int2	\[ 3 -le 5 ] → 真（0）
(( ))	==、!=、>、<、>=、<=	与编程语言一致，更直观	((5 > 3)) → 真（0）

注意事项

• 和 \[ ] 中，操作符两边必须留空格；

• (( )) 中，操作符两边可留空格，也可不留；

• 若变量为非整数，进行整数比较会报错（退出状态非0）。

实操案例

x=1; [ $x -eq 1 ]; echo $?  # 输出：0（真）
x=a; [ $x -eq 1 ]; echo $?  # 输出：2（报错，非整数）
((x == 1)); echo $?  # 输出：1（假）
((x+1 >= 2)); echo $?  # 输出：0（真）

# 多种格式对比演示
num1=10; num2=5
[ $num1 -gt $num2 ]; echo $?  # [ ]格式，输出：0（真）
[[ $num1 -ge $num2 ]]; echo $? # [[ ]]格式，输出：0（真）
((num1 <= 20)); echo $?       # (( ))格式，输出：0（真）
[ $num1 -lt $num2 ]; echo $?  # 输出：1（假）

（2）字符串测试运算符

用于测试字符串的长度、是否相等、是否为子串等，支持 和 \[ ] 格式，\[ ] 功能更强大（支持通配符、=~ 子串匹配）。

测试格式	操作符	说明	示例
或 \[ ]	-z str	字符串str长度为0（空字符串），返回真	-z "" → 真（0）
或 \[ ]	-n str	字符串str长度不为0，返回真	\[ -n "test" ] → 真（0）
或 \[ ]	str	等价于 -n str，字符串非空返回真	"test" → 真（0）
	str1 = str2 / str1 != str2	字符串相等/不相等（=和==等价）	"a" = "b" → 假（1）
\[ ]	str1 == str2 / str1 != str2	字符串相等/不相等，支持通配符	\[ "Tom" == To? ] → 真（0）
\[ ]	str1 =~ str2	str2是str1的子串，返回真	\[ "test" =\~ "es" ] → 真（0）
\[ ]	str1 > str2 / str1 < str2	按ASCII码顺序比较字符串	\[ "a" \< "b" ] → 真（0）

补充：字符串空值/非空值检查（实操常用）

# 定义测试变量
name=""  # 空字符串
name2="Shell"  # 非空字符串

# 检查空值（四种方式等价）
[ "$name" = "" ]
[ -z "$name" ]
[ ! "$name" ]
[ "X${name}" = "X" ]  # 最安全，避免变量为空时语法报错

# 检查非空值（四种方式等价）
[ "$name" != "" ]
[ -n "$name" ]
[ "$name" ]
[ "X${name}" != "X" ]

（3）文件测试运算符

用于测试文件/目录的存在性、属性、访问权限等，是脚本中操作文件的核心测试方式，支持 和 \[ ] 格式。

操作符	说明	示例
-f fname	fname存在且是普通文件，返回真	-f /etc/passwd → 真（0）
-L fname	fname存在且是链接文件，返回真	\[ -L /etc/rc.local ] → 视实际情况返回
-d fname	fname存在且是目录，返回真	-d /home → 真（0）
-e fname	fname（文件/目录）存在，返回真	\[ -e /tmp ] → 真（0）
-s fname	fname存在且大小大于0，返回真	-s /var/log/messages → 视实际情况返回
-r fname	fname存在且当前用户可读，返回真	\[ -r /etc/passwd ] → 真（0）
-w fname	fname存在且当前用户可写，返回真	-w /tmp/test.txt → 视实际情况返回
-x fname	fname存在且当前用户可执行，返回真	\[ -x /bin/ls ] → 真（0）

注：更多文件测试符可通过 man test 查看在线帮助。

演示示例

# 测试系统常用文件/目录
[ -f /etc/passwd ]; echo $?  # 测试是否为普通文件，输出：0（真）
[ -d /home ]; echo $?        # 测试是否为目录，输出：0（真）
[ -e /tmp ]; echo $?         # 测试是否存在，输出：0（真）
[ -x /bin/ls ]; echo $?      # 测试是否可执行，输出：0（真）

# 测试自定义文件（先创建测试文件）
touch test.txt
echo "test content" > test.txt
[ -s test.txt ]; echo $?     # 测试文件大小是否大于0，输出：0（真）
[ -w test.txt ]; echo $?     # 测试是否可写，输出：0（真）

# 清理测试文件
rm -f test.txt

（4）逻辑运算符

用于组合多个测试条件，实现复杂逻辑判断，分为逻辑非（!）、逻辑与（&&）、逻辑或（||），不同测试格式的操作符不同。

测试格式	逻辑与	逻辑或	逻辑非
	-a（两个条件都为真，结果为真）	-o（两个条件有一个为真，结果为真）	!（条件取反）
\[ ] 或 (( ))	&&（与上面等价，更直观）	||（与上面等价，更直观）	!（条件取反）

注意事项

• 中使用 -a、-o 时，不能随意添加括号，若需分组需转义（如 \( expr1 \) -a \( expr2 \)）；

• \[ ] 和 (( )) 中，&&、|| 可直接使用，无需转义，支持分组；

• 命令行中，&&、|| 也可作为"命令聚合"，表示"前一条命令成功/失败后，执行后一条命令"（非逻辑运算）。

实操案例

x=1; name=Tom;
# [ ] 中使用逻辑与
[ $x -eq 1 -a -n $name ]; echo $?  # 输出：0（两个条件都为真）
# [ ] 中分组（需转义）
[ \( $x -eq 1 \) -a \( -n $name \) ]; echo $?  # 输出：0

# [[ ]] 中使用逻辑与，支持通配符
[[ $x -eq 1 && $name = To? ]]; echo $?  # 输出：0

# 命令聚合（&& 表示前一条成功才执行后一条）
(( $x == 1 )) && [[ $name = To? ]]; echo $?  # 输出：0

# 逻辑非和逻辑或演示
# 逻辑非（取反条件）
[ ! $x -eq 2 ]; echo $?  # 输出：0（原条件x=2为假，取反后为真）
[[ ! $name = "Jerry" ]]; echo $?  # 输出：0（原条件不成立，取反后成立）

# [ ] 中使用逻辑或
[ $x -eq 2 -o $name = "Tom" ]; echo $?  # 输出：0（一个条件为真，整体为真）
# [ ] 中逻辑或分组（需转义）
[ \( $x -eq 2 \) -o \( $name = "Tom" \) ]; echo $?  # 输出：0

# [[ ]] 中使用逻辑或
[[ $x -eq 2 || $name = "Tom" ]]; echo $?  # 输出：0

# 复杂逻辑组合（逻辑与、或、非结合）
[[ $x -eq 1 && ( $name = "Tom" || $name = "Jerry" ) ]]; echo $?  # 输出：0
[ \( $x -eq 1 -a -n $name \) -o \( $x -eq 0 \) ]; echo $?  # 输出：0

# 命令聚合演示（|| 表示前一条失败才执行后一条）
(( $x == 2 )) || echo "x不等于2"  # 输出：x不等于2（前一条条件为假，执行后一条）

3.3 条件测试常见错误规避

• 忘记在 、\[\[ 后，、]] 前留空格（最常见错误）；

• 中使用通配符、&&、||、<、>（不支持，会报错）；

• 字符串比较时，变量未加双引号（当变量为空时，会导致语法错误）；

• (( )) 中进行字符串比较（不支持，仅支持整数运算和比较）。

四、流程控制语句（基于条件测试）

流程控制语句用于根据条件测试结果，执行不同的命令块，核心包括 if 系列语句和 case 语句。

4.1 if 系列语句

if 语句分为单分支（if）、双分支（if/else）、多分支（if/elif/else）三种，核心是"根据条件执行对应命令块"。

（1）单分支 if 结构（if）

核心作用：仅当条件为真（退出状态0）时，执行指定命令块；条件为假时，不执行任何操作，适合"满足条件才执行"的场景。

# 语法格式
if  expression
then
    command1
    command2
    ...
fi

• expression 是条件测试表达式（如 $x -eq 1 、\[ $name = Tom ]、((x > 5))），必须符合条件测试的格式要求；

• then 可与 if 同行（需用分号分隔），格式为：if expression; then，更简洁，是实际开发中常用写法；

• fi 是 if 语句的结束标记，不可省略，否则脚本会报错；

• 命令块内的命令需缩进（通常4个空格），虽不影响执行，但可提升脚本可读性。

执行流程如下

实操案例

# 案例1：判断当前用户是否为root（单分支，满足条件执行提示）
if [ $USER = "root" ]
then
    echo "当前用户是root，具备管理员权限"
fi

# 案例2：简化写法（then与if同行）
num=15
if ((num > 10)); then echo "数字大于10"; fi  # 条件为真，输出提示

# 案例3：条件为假，不执行命令块
file="/tmp/nonexistent.txt"
if [ -f $file ]
then
    echo "文件存在，开始读取内容"
fi  # 文件不存在，无任何输出

（2）双分支 if 结构（if/else）

核心作用：双向选择，条件为真时执行一组命令，条件为假时执行另一组命令，无论条件是否满足，都会执行一个命令块，交互性更强，适合"二选一"场景。

# 语法格式
if  expression1
then
    command1  # expression1为真时执行
    ...
else
    command2  # expression1为假时执行
    ...
fi

• else 后面无需跟任何条件表达式，直接衔接命令块；

• else 与 then、fi 的缩进保持一致，确保脚本结构清晰；

• expression1 通常是前文讲解的条件测试（整数比较、字符串测试、文件测试等），确保条件判断准确。

执行流程如下：

说明：双向选择，无论条件是否满足，都会执行一个命令块，交互性更强。

实操案例

# 案例1：判断文件是否存在，存在则读取，不存在则创建
test_file="/tmp/test_if.txt"
if [ -f $test_file ]
then
    echo "文件已存在，内容如下："
    cat $test_file  # 读取文件内容
else
    echo "文件不存在，正在创建文件..."
    touch $test_file  # 创建文件
    echo "测试文件内容" > $test_file  # 写入内容
fi

# 案例2：判断整数大小，二选一提示
score=85
if ((score >= 60))
then
    echo "成绩合格，继续加油！"
else
    echo "成绩不合格，需要补考！"
fi

# 清理测试文件
rm -f /tmp/test_if.txt

（3）多分支 if 结构（if/elif/else）

核心作用：多向选择，当有多个条件需要判断时，依次检查每个条件，满足第一个条件后执行对应命令块，后续条件不再判断；所有条件都不满足时，执行else命令块，适合"多选一"场景。

# 语法格式
if  expr1  # 条件1
then
    commands1  # 条件1为真时执行
elif  expr2  # 条件1为假，条件2为真
then
    commands2  # 条件2为真时执行
...  # 可多个elif
else
    commands4  # 所有条件都为假时执行
fi

• elif 是"else if"的缩写，可根据需求添加多个（无数量限制），每个elif后面必须跟条件表达式和then；

• 执行顺序：从第一个if条件开始判断，一旦某个条件为真，执行对应命令块后，直接跳出整个if系列语句，后续的elif和else不再执行；

• else 是可选的，若省略，当所有条件都为假时，整个if语句不执行任何操作；

• 条件表达式的优先级：可通过括号（\[ ]、(( )) 中直接用括号， 中需转义）调整条件判断顺序，避免逻辑错误；

• 常见误区：elif 后面不能写 else，且每个then、elif、else 对应的命令块需缩进，保持结构统一。

实操案例

# 案例：根据成绩划分等级（多分支判断）
score=78
if ((score >= 90))
then
    echo "成绩等级：优秀"
elif ((score >= 80))
then
    echo "成绩等级：良好"
elif ((score >= 60))
then
    echo "成绩等级：合格"
else
    echo "成绩等级：不合格"
fi  # 输出：成绩等级：合格

# 案例2：判断文件类型（结合文件测试）
file_path="/etc/passwd"
if [ -d $file_path ]
then
    echo "$file_path 是目录"
elif [ -f $file_path ]
then
    echo "$file_path 是普通文件"
elif [ -L $file_path ]
then
    echo "$file_path 是链接文件"
else
    echo "$file_path 是其他类型文件"
fi  # 输出：/etc/passwd 是普通文件

4.2 case 语句

case 语句用于"多值匹配"，当一个变量有多个可能的值，且每个值对应不同的命令块时，比 if/elif/else 更简洁、可读性更强，适合"变量多值匹配"场景（如菜单选择、参数匹配等）。

（1）语法格式

case  expr  in  # expr为待匹配的表达式，in不能省略
    pattern1)  # 若expr与pattern1匹配（pattern可含通配符、|）
        commands1  # 执行命令块1
        ;;  # 结束当前匹配，跳出case（双分号不可省略）
    pattern2)  # 若expr与pattern2匹配
        commands2  # 执行命令块2
        ;;
    ...  # 可多个匹配模式
    *)  # 缺省模式，所有pattern都不匹配时执行（可省略）
        commands  # 执行缺省命令块
        ;;
esac  # case语句必须以esac结束（esac是case的反向拼写）

执行流程如下

（2）case 语句核心说明

• 匹配顺序：按pattern的顺序依次匹配，一旦匹配成功，执行对应命令块后立即跳出case（不会继续匹配后续pattern）；

• pattern 支持通配符（如 ?、*、\[\]）和"|"（表示"或"，如 pattern1|pattern2 表示匹配pattern1或pattern2）；

• 双分号（;;）必须放在每个命令块的最后，可独占一行，也可跟在最后一条命令后；

• *) 是缺省模式，类似于if语句中的else，可省略（省略后，无匹配pattern时不执行任何命令）。

实操案例

# 案例1：简单菜单选择（精确匹配）
echo "请选择操作（1-3）："
echo "1. 查看当前目录"
echo "2. 创建文件"
echo "3. 退出"
read choice  # 读取用户输入的选择

case $choice in
    1)
        echo "当前目录内容如下："
        ls -l
        ;;
    2)
        echo "请输入要创建的文件名："
        read filename
        touch $filename
        echo "文件 $filename 创建成功"
        ;;
    3)
        echo "正在退出..."
        exit 0  # 正常退出脚本
        ;;
    *)
        echo "输入错误，请输入1-3之间的数字"
        ;;
esac

# 案例2：通配符+多值匹配
name="Tom"
case $name in
    Tom|Jerry)  # 多值匹配，匹配Tom或Jerry
        echo "欢迎 $name！"
        ;;
    Li?)  # 通配符匹配，以Li开头，后面跟1个字符（如LiLe、LiNa）
        echo "你好，$name！"
        ;;
    *)
        echo "未知用户：$name"
        ;;
esac  # 输出：欢迎 Tom！

# 案例3：结合变量，匹配文件后缀
file="test.sh"
case $file in
    *.sh)  # 匹配所有.sh后缀的文件（脚本文件）
        echo "$file 是Shell脚本文件"
        ;;
    *.txt)  # 匹配所有.txt后缀的文件（文本文件）
        echo "$file 是文本文件"
        ;;
    *.log)  # 匹配所有.log后缀的文件（日志文件）
        echo "$file 是日志文件"
        ;;
    *)
        echo "$file 是未知类型文件"
        ;;
esac  # 输出：test.sh 是Shell脚本文件

五、总结

本文围绕Bash变量与运算符展开，核心要点如下：

1. Bash变量本质是字符串，纯数字可视为整型，支持数组操作，下标从0开始；

2. 算术运算有4种方式：算术扩展（\[ \]、(( ))）、let命令、expr命令，其中$(( )) 最常用；

3. 条件测试是逻辑判断的核心，有3种格式，支持整数、字符串、文件、逻辑4类测试；

4. 流程控制语句（if系列、case）基于条件测试，根据不同条件执行对应命令块，适配不同场景。

实操中需重点注意语法格式（如空格、转义、结束符），避免常见错误，多练习案例可快速掌握。