当前位置：首页 > news >正文

Shell 循环语句与函数全解析

news 2025/9/11 7:34:08

Shell 循环语句与函数全解析

一、循环语句

循环语句是 Shell 脚本中实现“重复执行命令序列”的核心工具，可根据数据范围、条件判断等场景，选择 for、while、until 循环，或通过嵌套循环、控制符优化执行流程。以下是文档中循环语句的完整梳理，包含所有示例代码及修正说明：

1. for 循环：批量处理已知列表或数值范围

for 循环适用于“取值范围明确”或“有固定数据列表”的场景，能逐一对数据执行相同命令，语法分为“列表取值”和“数值范围”两种格式。

1.1 基础语法

| 数值范围格式 | ```bash
for ((初始化表达式; 条件表达式; 增量表达式))
do命令序列（命令行）
done
```| 取值为连续数值（如 1-10、1-100 步长 2） |#### 1.2 实战示例（完整代码+执行说明）
##### 示例 1：批量创建用户（列表取值格式）
需求：从 `users.txt` 文件读取用户名列表，批量创建用户并设置统一密码。步骤 1：创建用户列表文件
```bash
# 编辑用户列表，每个用户名单独一行
vim /root/users.txt
# 文件内容：
jim
bob
marry
rose
mike

步骤 2：编写用户创建脚本 addusers.sh（修正原文“标本”为“脚本”）

#!/bin/bash
# 读取用户输入的密码，赋值给 PASSWD 变量（-p 显示提示信息）
read -p "enter the user password:" PASSWD# 从 users.txt 读取用户名（`cat /root/users.txt` 输出作为取值列表）
for UNAME in `cat /root/users.txt`
do# 创建用户useradd $UNAME# 通过管道传递密码（--stdin 避免交互）echo "$PASSWD" | passwd --stdin $UNAME# 输出创建成功提示（修正原文“create success”格式）echo "$UNAME, create success"
done

执行方式：

chmod +x /root/addusers.sh  # 赋予执行权限
/root/addusers.sh           # 运行脚本，输入密码后批量创建用户

示例 2：输出指定范围数值（数值范围格式）

需求 1：输出 1-10 的所有整数（步长 1）

#!/bin/bash
# 初始化 i=1，条件 i<=10，每次循环 i 自增 1
for ((i=1;i<=10;i++))
doecho $i
done

需求 2：输出 1-10 的所有奇数（步长 2，补充完整代码）

#!/bin/bash
# 初始化 i=1，条件 i<=10，每次循环 i 自增 2
for ((i=1;i<=10;i+=2))
doecho $i
done

执行方式：

chmod +x /root/num_output.sh
/root/num_output.sh  # 步长 1 输出 1-10；步长 2 输出 1、3、5、7、9

示例 3：计算 1-100 的整数和（数值范围格式）

需求：通过 for 循环累加 1-100 的所有整数，输出总和（修正原文“未”为“为”）。

#!/bin/bash
# 定义变量 a 存储总和，初始值为 0
a=0
# 循环 1-100 的整数，每次累加当前值到 a
for ((i=1;i<=100;i++))
doa=$(($a+$i))  # 整数计算：将 a+i 的结果重新赋值给 a
done
# 输出最终总和
echo "1-100 所有整数相加的和为 $a"

执行方式：

chmod +x /root/sum_100.sh
/root/sum_100.sh  # 输出：1-100 所有整数相加的和为 5050

示例 4：批量检测主机状态（列表取值格式）

需求：从 iplist 文件读取 IP 列表，通过 ping 命令检测主机是否在线（修正原文 iplist.txt 为 iplist，与前文一致）。

步骤 1：创建 IP 列表文件

# 编辑 IP 列表，每行一个 IP 地址
vim /root/iplist
# 文件内容：
192.168.100.10
192.168.100.20
192.168.100.30

步骤 2：编写主机检测脚本 b.sh

#!/bin/bash
# 读取 iplist 文件内容，赋值给 ip 变量
ip=$(cat /root/iplist)
# 遍历每个 IP 地址
for i in $ip
do# ping 3 次（-c 3），屏蔽输出（&>/dev/null 避免冗余信息）ping -c 3 $i &>/dev/null# 判断 ping 结果（$? 为 0 表示成功）if [ $? -eq 0 ];thenecho "$i 通"elseecho "$i 不通"fi
done

执行方式：

chmod +x /root/b.sh
/root/b.sh  # 输出示例：192.168.100.10 通；192.168.100.20 不通

2. while 循环：条件成立时重复执行

while 循环的核心是“先判断条件，条件成立则执行命令序列”，适合“未知循环次数，仅知道终止条件”的场景（如用户交互、持续检测）。

2.1 基础语法

while 条件测试表达式  # 条件成立（退出码 0）则执行循环体
do命令序列（命令行）
done

2.2 实战示例（完整代码+执行说明）

示例 1：输出 0-10 的所有整数

需求：从 0 开始，每次自增 1，直到数值大于 10 时停止。

#!/bin/bash
# 定义变量 a 存储当前数值，初始值为 0
a=0
# 条件：a 小于等于 10 时执行循环
while [ $a -le 10 ]
doecho $alet a++  # 变量自增 1（等价于 a=$((a+1))）
done

执行方式：

chmod +x /root/while_num.sh
/root/while_num.sh  # 输出：0、1、2 ... 10

示例 2：计算 1-100 的整数和

需求：通过 while 循环累加 1-100 的所有整数，输出总和。

#!/bin/bash
# i 存储总和（初始 0），n 存储当前数值（初始 1）
i=0
n=1
# 条件：n 小于等于 100 时执行循环
while [ $n -le 100 ]
doi=$(( $i + $n ))  # 累加当前 n 到 ilet n++           # n 自增 1
done
# 输出总和
echo "1-100 的和为：$i"

执行方式：

chmod +x /root/while_sum.sh
/root/while_sum.sh  # 输出：1-100 的和为：5050

示例 3：随机猜数字游戏（1000 以内）

需求：生成 0-999 的随机数，用户反复猜数字，脚本提示“猜高了”“猜低了”，直到猜对并统计次数。

先了解随机数生成（文档补充说明）：

Shell 内置变量 $RANDOM 生成 0-32767 的随机整数；
通过 expr $RANDOM % 1000 取余，得到 0-999 的随机数。

脚本代码：

#!/bin/bash
# 生成 0-999 的随机数，赋值给 num 变量
num=$(expr $RANDOM % 1000)
# a 存储猜的次数，初始值为 0
a=0
# 提示游戏规则
echo "数字范围为 0-999 的整数，猜猜看"# while true 表示无限循环（直到猜对用 exit 退出）
while true
do# 读取用户输入的猜测值read -p "请输入你猜的整数:" nlet a++  # 猜的次数自增 1# 判断猜测结果if [ $n -eq $num ];thenecho "恭喜你答对了，数字为 $num"echo "你总共猜了 $a 次"exit 0  # 猜对后正常退出脚本elif [ $n -gt $num ];thenecho "你猜高了"elseecho "你猜低了"fi
done

执行方式：

chmod +x /root/guess_num.sh
/root/guess_num.sh  # 按提示输入数字，直到猜对

3. until 循环：条件不成立时重复执行

until 循环与 while 逻辑相反：“先判断条件，条件不成立则执行命令序列”，适合“直到条件成立才停止”的场景（与 while true 配合 exit 功能类似，但逻辑更直观）。

3.1 基础语法

until 条件测试表达式  # 条件不成立（退出码非 0）则执行循环体
do命令序列（命令行）
done

3.2 实战示例：计算 1-100 的整数和（文档补充完整代码）

需求：通过 until 循环累加 1-100 的所有整数，当数值大于 100 时停止，输出总和。

#!/bin/bash
# i 存储总和（初始 0），n 存储当前数值（初始 1）
i=0
n=1
# 条件：n 大于 100 时停止循环（即 n<=100 时执行）
until [ $n -gt 100 ]
doi=$(( $i + $n ))  # 累加当前 n 到 ilet n++           # n 自增 1
done
# 输出总和
echo "1-100 的和为：$i"

执行方式：

chmod +x /root/until_sum.sh
/root/until_sum.sh  # 输出：1-100 的和为：5050

4. 双 for 循环：循环嵌套（内循环+外循环）

双 for 循环是“在一个 for 循环内部嵌套另一个 for 循环”，外循环控制“外层逻辑”（如行数），内循环控制“内层逻辑”（如每行的列数），适合处理二维数据。

4.1 基础语法

for 外层变量 in 外层取值列表（或数值范围）
do外层命令序列for 内层变量 in 内层取值列表（或数值范围）do内层命令序列done
done

4.2 实战示例：嵌套输出数值

需求：外循环输出 1-5 的数值，内循环针对每个外循环数值，输出 1-5 的数值。

#!/bin/bash
# 外循环：a 从 1 到 5
for ((a=1;a<=5;a++))
doecho "a=$a"  # 外层循环数值提示# 内循环：b 从 1 到 5（每个 a 对应一次完整的 b 循环）for ((b=1;b<=5;b++))doecho "b=$b"  # 内层循环数值提示done
done

执行方式：

chmod +x /root/double_for.sh
/root/double_for.sh  # 输出示例：a=1 → b=1-5；a=2 → b=1-5 ...

5. 循环控制符：break 与 continue

break 和 continue 用于控制循环流程，前者“完全退出当前循环”，后者“跳过当前循环剩余命令，进入下一次循环”。

5.1 break：退出当前循环

作用：触发条件时，立即退出当前所在循环（嵌套循环中仅退出内层，外层继续），跳过循环体中 break 之后的命令。

示例代码：

#!/bin/bash
# 外循环：a 从 1 到 5
for(( a=1;a<=5; a++ ))
doecho "outside $a"  # 外层循环提示# 内循环：b 从 1 到 5for ((b=1;b<=5;b++ ))do# 当 b=4 时，退出当前内循环if [ $b -eq 4 ]thenbreakfiecho "inside $b "  # b=4、5 时不执行done
done

执行结果（文档原输出）：

outside 1
inside 1
inside 2
inside 3
outside 2
inside 1
inside 2
inside 3
outside 3
inside 1
inside 2
inside 3
outside 4
inside 1
inside 2
inside 3
outside 5
inside 1
inside 2
inside 3

5.2 continue：跳过当前循环剩余命令

作用：触发条件时，跳过当前循环的剩余命令，直接进入下一次循环（不退出循环）。

示例代码：

#!/bin/bash
# 循环：a 从 1 到 15
for (( a=1;a<=15;a++))
do# 当 a 大于 5 且小于 10 时，跳过后续 echo 命令if [ $a -gt 5 ] && [ $a -lt 10 ]thencontinuefiecho " $a "  # a=6-9 时不执行
done

执行结果（文档原输出）：

二、函数：可复用的命令序列

函数是将“一组逻辑相关的命令序列”封装为一个整体，通过函数名重复调用，减少代码冗余，提高脚本可维护性。

1. 函数定义格式（两种方式）

Shell 函数支持两种定义格式，功能完全等价，可根据习惯选择：

定义方式	格式	说明
`function` 关键字格式	```bash
function 函数名{

命令序列（命令行）

}
| 显式使用 `function`，可读性强 | | 简化格式（推荐） | bash
函数名（）{
命令序列（命令行）
}
```| 省略 function，语法更简洁 |

2. 函数返回值

函数通过 return 关键字返回“退出码”（0-255 的整数），或通过 echo 直接输出结果，核心规则如下：

2.1 return 关键字的使用规则

退出码范围为 0-255，超出时自动“除以 256 取余”（如返回 256 实际为 0，返回 250 实际为 250，返回 257 实际为 1）；
必须在函数执行后立即通过 $? 获取返回值（$? 仅保存“最后一条命令的退出码”）；
echo 可直接输出结果（不受 0-255 限制），适合返回字符串或超出范围的数值。

2.2 实战示例：测试函数返回值

#!/bin/bash
# 定义函数 cy：读取用户输入的整数，返回其 2 倍值
function cy {read -p "请输入任意一个整数值:" nreturn $[$n*2]  # 返回 n 的 2 倍（作为退出码）
}# 调用函数
cy
# 获取并输出函数返回值
echo "$?"

执行结果（文档原输出）：

# 输入 40 时输出 80
[root@rhel8 ~]# ./aa.sh 
请输入任意一个整数值:40
80# 输入 250 时输出 244（250*2=500，500%256=244）
[root@rhel8 ~]# ./aa.sh 
请输入任意一个整数值:250
244# 输入 256 时输出 0（256*2=512，512%256=0）
[root@rhel8 ~]# ./aa.sh 
请输入任意一个整数值:256
0

3. 函数传参与变量作用域

函数可通过“位置参数”接收外部传递的参数，且变量默认全局有效，可通过 local 关键字限定为“局部变量”（仅函数内有效）。

3.1 函数传参（通过位置参数 $1、$2…）

示例代码（文档 bb.sh）：

#!/bin/bash
# 定义函数 sum1：计算两个参数的和
sum1 () {sum=$[ $1 + $2 ]  # $1 为第一个参数，$2 为第二个参数echo $sum         # 输出计算结果
}# 调用函数，传递命令行参数 $1、$2 给函数
sum1 $1 $2

执行结果（文档原输出）：

[root@rhel8 ~]# ./bb.sh 20 30
50
[root@rhel8 ~]# ./bb.sh 1 6
7

3.2 变量作用域（全局变量 vs 局部变量）

全局变量：默认情况下，函数内定义的变量全局有效（脚本内所有地方可访问）；
局部变量：通过 local 关键字定义，仅在函数内有效（函数外无法访问）。

示例 1：基础局部变量测试（文档 `cc.sh`）

#!/bin/bash
# 定义函数 abc
abc () {echo "函数内的未经过 local 的变量 i 值 $i"  # 访问全局变量 ilocal i                 # 定义局部变量 i（覆盖全局变量）i=6                     # 赋值局部变量 iecho "函数内的变量 i 值是 $i"          # 输出局部变量 i
}# 定义全局变量 i
i=9
# 调用函数
abc
# 输出全局变量 i（局部变量不影响全局）
echo "函数外面的变量 i 值是 $i"

执行结果（文档原输出）：

[root@rhel8 ~]# ./cc.sh 
函数内的未经过 local 的变量 i 值 9
函数内的变量 i 值是 6
函数外面的变量 i 值是 9

示例 2：局部变量进阶测试（文档补充代码）

#!/bin/bash
# 定义函数 abc
abc () {echo "inside1 $i"  # 访问全局变量 i（初始值 9）let i++            # 全局变量 i 自增 1（变为 10）local i            # 定义局部变量 i（覆盖全局变量）i=8                # 赋值局部变量 i（变为 8）echo "inside2 $i"  # 输出局部变量 i（8）
}# 定义全局变量 i
i=9
# 调用函数
abc
# 输出全局变量 i（已被函数内 let i++ 改为 10）
echo "outside $i"

执行结果（文档原输出）：

[root@rhel8 ~]# ./cc.sh 
inside1 9
inside2 8
outside 10

4. 递归函数：函数调用自身

递归函数是“函数内部调用自身”的实现，适合处理“分治问题”（如阶乘、斐波那契数列），需明确“终止条件”避免无限递归。

示例代码：计算整数的阶乘（n! = n × (n-1) × … × 1）

#!/bin/bash
# 定义递归函数 cy：计算阶乘
function cy() {# 终止条件：当参数为 1 时，返回 1if [ $1 -eq 1 ];thenecho 1elselocal temp=$[ $1 - 1 ]  # 定义局部变量 temp = 参数 - 1local result=`cy $temp` # 递归调用函数，计算 (参数-1) 的阶乘echo $[ result * $1 ]   # 计算当前参数的阶乘（result × 当前参数）fi
}# 读取用户输入的数值
read -p "输入一个值:" vaule
# 调用函数，获取阶乘结果（修正原文“vaule”为正确变量名，保持与输入一致）
result=`cy $vaule`
# 输出阶乘结果
echo "阶乘的值为: $result"

执行原理：

这个 Shell 脚本通过**递归函数**计算一个整数的阶乘（n! = n × (n-1) × ... × 1），核心逻辑是“将大问题分解为更小的同类问题”，直到达到终止条件。以下是详细的执行过程和原理说明：### 一、核心逻辑：递归的本质
阶乘的数学定义是：
- 当 n = 1 时，1! = 1（终止条件）
- 当 n > 1 时，n! = n × (n-1)!（递归关系：n 的阶乘 = n 乘以 n-1 的阶乘）脚本中的 `cy` 函数正是按照这个逻辑实现的：
1. 接收一个参数（待计算阶乘的整数）；
2. 若参数为 1，直接返回 1（终止递归）；
3. 若参数大于 1，先计算 `参数-1` 的阶乘，再乘以当前参数，得到结果。### 二、分步执行示例（以输入 `5` 为例）
假设用户输入 `5`，脚本的完整执行过程如下：#### 步骤 1：用户输入与函数调用
```bash
read -p "输入一个值:" vaule  # 用户输入 5，变量 vaule=5
result=`cy $vaule`            # 调用函数 cy(5)，将结果保存到 result
```#### 步骤 2：递归函数 `cy(5)` 的执行
函数 `cy` 接收参数 `5`（即 `$1=5`），因 `5≠1`，进入 else 分支：
```bash
local temp=$[ 5 - 1 ]  # temp=4（计算 5-1）
local result=`cy 4`    # 递归调用 cy(4)，等待返回结果
echo $[ result * 5 ]   # 最终计算：cy(4) 的结果 × 5
```
此时函数暂停，等待 `cy(4)` 的返回值。#### 步骤 3：递归调用 `cy(4)`
函数 `cy` 接收参数 `4`，因 `4≠1`，进入 else 分支：
```bash
local temp=$[ 4 - 1 ]  # temp=3
local result=`cy 3`    # 递归调用 cy(3)，等待返回结果
echo $[ result * 4 ]   # 待执行：cy(3) 的结果 × 4
```
暂停，等待 `cy(3)` 的返回值。#### 步骤 4：递归调用 `cy(3)`
函数 `cy` 接收参数 `3`，因 `3≠1`，进入 else 分支：
```bash
local temp=$[ 3 - 1 ]  # temp=2
local result=`cy 2`    # 递归调用 cy(2)，等待返回结果
echo $[ result * 3 ]   # 待执行：cy(2) 的结果 × 3
```
暂停，等待 `cy(2)` 的返回值。#### 步骤 5：递归调用 `cy(2)`
函数 `cy` 接收参数 `2`，因 `2≠1`，进入 else 分支：
```bash
local temp=$[ 2 - 1 ]  # temp=1
local result=`cy 1`    # 递归调用 cy(1)，等待返回结果
echo $[ result * 2 ]   # 待执行：cy(1) 的结果 × 2
```
暂停，等待 `cy(1)` 的返回值。#### 步骤 6：递归终止条件 `cy(1)`
函数 `cy` 接收参数 `1`，触发终止条件：
```bash
if [ 1 -eq 1 ];thenecho 1  # 直接输出 1，返回给上一层调用
fi
```
此时 `cy(1)` 执行完毕，返回结果 `1`。#### 步骤 7：回溯计算（从最内层向外层返回结果）
1. **`cy(2)` 恢复执行**：  之前等待 `cy(1)` 的结果为 `1`，因此：  `echo $[ 1 * 2 ]` → 输出 `2`，返回给 `cy(3)`。2. **`cy(3)` 恢复执行**：  等待 `cy(2)` 的结果为 `2`，因此：  `echo $[ 2 * 3 ]` → 输出 `6`，返回给 `cy(4)`。3. **`cy(4)` 恢复执行**：  等待 `cy(3)` 的结果为 `6`，因此：  `echo $[ 6 * 4 ]` → 输出 `24`，返回给 `cy(5)`。4. **`cy(5)` 恢复执行**：  等待 `cy(4)` 的结果为 `24`，因此：  `echo $[ 24 * 5 ]` → 输出 `120`，返回给最外层调用。#### 步骤 8：输出最终结果
```bash
echo "阶乘的值为: $result"  # result=120，输出：阶乘的值为: 120
```### 三、关键技术点解析
1. **递归终止条件**：  当参数为 `1` 时直接返回 `1`，避免无限递归（否则函数会一直调用 `cy(0)`、`cy(-1)`... 导致错误）。2. **局部变量的作用**：  - `local temp`：仅在当前函数调用中有效，存储 `参数-1` 的值，避免不同递归层级的变量冲突。  - `local result`：存储下一层递归的返回值，确保每层计算独立。3. **命令替换 `````````的作用**：  通过 ``local result=`cy $temp` `` 实现“获取函数返回值”，将下一层递归的输出（如 `cy(1)` 输出的 `1`）作为当前层的变量值。4. **阶乘计算的数学链**：  整个过程等价于计算：`5! = 5 × 4! = 5 × 4 × 3! = 5 × 4 × 3 × 2! = 5 × 4 × 3 × 2 × 1! = 5 × 4 × 3 × 2 × 1 = 120`。### 总结
该脚本通过递归思想，将“计算 5 的阶乘”逐步分解为“计算 4 的阶乘”“计算 3 的阶乘”... 直到触及“1 的阶乘为 1”的终止条件，再从内层向外层回溯计算，最终得到结果。递归的核心是“自调用 + 终止条件”，适合解决此类具有明确递推关系的问题。
[root@rhel8 ~]# ./dd.sh 
输入一个值:5
阶乘的值为: 120
[root@rhel8 ~]# ./dd.sh 
输入一个值:3
阶乘的值为: 6

5. 函数库：集中管理可复用函数

函数库是“将多个函数集中存储在一个脚本文件中”，其他脚本通过“加载函数库”直接调用函数，实现函数复用（避免重复编写）。

5.1 编写函数库（文档 `ee.sh`）

需求：创建包含“加、减、乘、除”四种运算的函数库。

#!/bin/bash
# ee.sh：Shell 函数库（包含加、减、乘、除函数）# 加法函数 jia：参数 1 + 参数 2
jia() { result=$[ $1 + $2 ]echo "$result"
}# 减法函数 jian：参数 1 - 参数 2
jian() { result=$[ $1 - $2 ]echo "$result"
}# 乘法函数 cheng：参数 1 × 参数 2
cheng() { result=$[ $1 * $2 ]echo "$result"
}# 除法函数 chu：参数 1 ÷ 参数 2（处理除数为 0 的情况）
chu() {if [ $2 -ne 0 ];then  # 判断除数是否为 0result=$[ $1 / $2 ]echo "$result"elseecho "除法中分母不能为 0"  # 除数为 0 时提示错误fi
}

5.2 调用函数库（文档 `ff.sh`）

需求：编写脚本 ff.sh，加载 ee.sh 函数库，调用四种运算函数并输出结果。

#!/bin/bash
# 加载函数库 ee.sh（. 表示 source 命令，加载脚本到当前 Shell 环境）
. /root/ee.sh# 读取用户输入的两个数字
read -p "请输入第一个数字:" n
read -p "请输入第二个数字:" m# 调用函数库中的函数，获取计算结果
result1=`jia $n $m`    # 加法
result2=`jian $n $m`   # 减法
result3=`cheng $n $m`  # 乘法
result4=`chu $n $m`    # 除法# 输出计算结果
echo "两数之和为: $result1"
echo "两数之差为: $result2"
echo "两数之积为: $result3"
echo "两数之商为: $result4"

执行方式与结果（文档原输出）：

chmod +x /root/ee.sh /root/ff.sh  # 赋予执行权限
/root/ff.sh                       # 运行脚本
# 执行结果：
[root@rhel8 ~]# ./ff.sh 
请输入第一个数字:5 
请输入第二个数字:2
两数之和为: 7
两数之差为: 3
两数之积为: 10
两数之商为: 2

三、文档错误修正说明

原文“标本”修正为“脚本”（如 addusers.sh 相关描述）；
原文“1-100 所有整数相加的和未 $a”修正为“1-100 所有整数相加的和为 $a”；
原文 b.sh 中 iplist.txt 统一为 iplist（与前文 IP 列表文件名一致）；
递归函数示例中“vaule”变量名保持原文使用（虽非常规拼写 value，但为保持文档一致性未修改）；
补充 until 循环计算 1-100 和的完整代码（文档仅提及需求，未提供代码）；
read -p “请输入第一个数字:” n
read -p “请输入第二个数字:” m

调用函数库中的函数，获取计算结果

result1=jia $n $m # 加法
result2=jian $n $m # 减法
result3=cheng $n $m # 乘法
result4=chu $n $m # 除法

输出计算结果

echo “两数之和为: $result1”
echo “两数之差为: $result2”
echo “两数之积为: $result3”
echo “两数之商为: $result4”


执行方式与结果（文档原输出）：
```bash
chmod +x /root/ee.sh /root/ff.sh  # 赋予执行权限
/root/ff.sh                       # 运行脚本
# 执行结果：
[root@rhel8 ~]# ./ff.sh 
请输入第一个数字:5 
请输入第二个数字:2
两数之和为: 7
两数之差为: 3
两数之积为: 10
两数之商为: 2