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

4小时速通shell外加100例

article 2025/3/24 17:56:12

🔥 Shell 基础——从入门到精通 🚀

🌱 第一章：Shell，简单说！

👶 什么是Shell？它到底能做什么？这章让你快速了解Shell的强大之处！

👶 什么是Shell？它到底能做什么？

1. Shell 是什么？

简单来说，Shell 是一个命令解释器，它是用户与操作系统之间的桥梁。你输入命令，Shell 负责解析并告诉 Linux 内核去执行。这就像一个“翻译官”，帮你和计算机交流！

2. Shell 能做什么？

🔥 Shell 不仅仅是个命令行工具，它还能做很多事，比如：

运行命令：执行 ls、pwd、cd 等基本操作。
批量处理任务：写一个脚本，自动完成文件备份、日志清理等重复工作！
自动化运维：定时执行任务、监控服务器状态，运维工程师的最爱！
编写交互式工具：写一个 Shell 脚本，让它和用户对话，创建简易菜单系统！
数据处理：批量修改文件、提取数据、格式化文本，Shell 统统搞定！

3. 为什么要学 Shell？

✅ 提高效率：写个脚本让重复任务一键完成，省时又省力！
✅ 无 GUI 限制：在服务器上没图形界面？Shell 照样让你掌控全局！
✅ 通吃各大 Linux 发行版：学会 Shell，无论是 Ubuntu、CentOS 还是 Mac，都能通用！
✅ 运维 & 开发必备：无论是 DevOps、测试工程师，还是嵌入式开发，都离不开 Shell！

4. 一个 Shell 命令的执行流程

你在终端里输入一个命令（比如 ls -l），它的执行流程是这样的：
1️⃣ 你按下 Enter，Shell 读取你的输入。
2️⃣ Shell 解析命令，把 ls -l 拆解成 ls（命令）+ -l（选项）。
3️⃣ Shell 让 Linux 内核去执行这个命令。
4️⃣ 执行结果返回给 Shell，最终显示在终端上。

💡 一句话总结：Shell 让你用“命令+脚本”掌控整个 Linux 世界！

🐚 第二章：Shell 解释器

🤔 Linux 提供的Shell解析器有哪些？Bash、Zsh、Fish，它们有何区别？这章带你一探究竟！

在 Linux 中，Shell 解析器（Shell Interpreter） 负责解析和执行你的命令。不同的 Shell 提供不同的功能和体验。最常见的几种 Shell 有：

1️⃣ Bash（Bourne Again Shell）—— 默认之王 👑

📌 特点：
✅ Linux 发行版默认 Shell（几乎所有系统都有它）
✅ 兼容传统 Bourne Shell (sh)，增强了功能
✅ 强大的 脚本功能，支持 if 语句、循环、函数等
✅ 支持 命令补全 和 历史命令（Ctrl + R 快速搜索命令）
✅ 社区庞大，几乎所有 Shell 教程都基于 Bash

📌 适用场景：
🔹 适合写 Shell 脚本、运维自动化、服务器管理

🎯 适合 Shell 初学者，入门必学！

2️⃣ Zsh（Z Shell）—— 终端增强神器 🚀

📌 特点：
✅ 更强大的自动补全（命令、文件名、Git 分支，统统补全！）
✅ 强大的自定义能力，支持 Oh My Zsh 插件管理系统
✅ 更酷的高亮显示（语法高亮、命令错误提示）
✅ 更好用的历史记录（支持模糊搜索和分目录记录）
✅ 兼容 Bash，大部分 Bash 脚本可以直接运行

📌 适用场景：
🔹 适合开发者、Linux 高级用户、命令行重度使用者

🎯 喜欢个性化终端的用户，Zsh 是不二之选！

3️⃣ Fish（Friendly Interactive Shell）—— 终端中的“智能 AI” 🤖

📌 特点：
✅ 开箱即用，默认自带语法高亮、自动补全等功能
✅ 更人性化的语法，不需要写 $VAR，直接 echo $var 即可
✅ 自动建议命令（输入几个字符，它就推荐你要的命令）
✅ 异步补全，比 Zsh 还要快！
✅ 与 Bash、Zsh 不完全兼容，写脚本时需要注意

📌 适用场景：
🔹 适合不想折腾配置、喜欢现代化体验的终端用户

🎯 适合喜欢简洁、智能交互的人，Fish 让终端更友好！

4️⃣ 其他 Shell 解析器（不常用但值得了解）

🔹 sh（Bourne Shell）：最早的 UNIX Shell，轻量但功能有限
🔹 Ksh（Korn Shell）：比 sh 强，支持更多编程特性，但没 Bash 流行
🔹 Tcsh（TENEX C Shell）：类似 C 语言风格的 Shell，适合 C 语言开发者

5️⃣ Bash、Zsh、Fish 对比总结 🏆

特性	Bash 🏆（经典）	Zsh 🚀（可定制）	Fish 🎣（现代智能）
默认 Shell	✅（大多数 Linux）	❌（需安装）	❌（需安装）
自动补全	✅（基础补全）	🔥（更智能）	🚀（最强，自动建议）
语法高亮	❌（无）	✅（支持）	✅（开箱即用）
配置难度	⭐⭐（默认可用）	⭐⭐⭐（需 `Oh My Zsh`）	⭐（开箱即用）
脚本兼容性	✅（100% 兼容 `sh`）	✅（兼容 `sh`）	❌（与 `sh` 语法不同）
插件系统	❌（无）	✅（`Oh My Zsh` 插件丰富）	❌（原生无插件）
适合人群	初学者 & 脚本编写	进阶用户 & 个性化终端	现代体验 & 轻松上手

🔥 哪个 Shell 最适合你？

💻 服务器运维 / Shell 编程？ ➡️ 选择 Bash（最广泛支持，脚本兼容性最好）
🎨 终端增强、个性化定制？ ➡️ 选择 Zsh（插件强大，开发者最爱）
🤖 现代化、智能化、即装即用？ ➡️ 选择 Fish（语法简洁，补全最强）

💡 总结一句话： 如果你是新手，从 Bash 开始；如果你喜欢折腾、追求效率，试试 Zsh；如果你希望终端更智能，Fish 是不错的选择！

📝 第三章：Shell 脚本入门

3.1 脚本格式

在你开始编写 Shell 脚本之前，了解 脚本的基本格式 是必须的！只有这样，你才能写出规范且高效的代码。

📜 Shell 脚本的基础格式：

Shebang（解释器声明）：
在脚本的第一行，通常会写一行 shebang，告诉操作系统这个脚本需要由哪个解释器来执行。
示例：
```
#!/bin/bash
```
脚本文件的权限：
默认情况下，创建的脚本文件是不可执行的，你需要用 chmod 命令修改文件权限，使其可以执行。
```
chmod +x script.sh
```
注释：
使用 # 来添加注释，注释在脚本中非常重要，能帮助自己和他人理解代码。
示例：
```
# 这是一个注释
```
命令和语句：
Shell 脚本中的命令可以是任何你在命令行中常用的命令，命令之间用换行或分号（;）分隔。
示例：
```
echo "Hello, World!"  # 打印一行文字
```

📌 小提示：编写脚本时最好保持文件格式的简洁和规范，避免不必要的复杂性！脚本的可读性也是非常重要的！

3.2 第一个 Shell 脚本：Hello, World!

经典的“Hello, World!”程序，帮助你感受一下编写 Shell 脚本的乐趣！🎉

步骤：

使用任何文本编辑器创建一个新的 Shell 脚本文件，命名为 hello_world.sh。
添加 Shebang，告诉系统使用 Bash 解析器来运行该脚本：
```
#!/bin/bash
```
在脚本中添加 echo 命令，输出 “Hello, World!”：
```
echo "Hello, World!"
```
保存并关闭文件。
修改文件权限，使其可执行：
```
chmod +x hello_world.sh
```
运行脚本，看看结果：
```
./hello_world.sh
```

🎉 输出结果：

恭喜你，成功编写了你的第一个 Shell 脚本！💡

3.3 第二个 Shell 脚本：多命令处理

在一个 Shell 脚本中执行多个命令是非常常见的应用场景，让我们通过一个例子来实践！

任务：
编写一个脚本，执行多个命令：打印当前日期、列出当前目录下的文件，并显示当前系统的磁盘空间。

步骤：

创建一个新的脚本文件，命名为 multi_command.sh。

编写脚本内容，依次执行多个命令：

#!/bin/bash
# 打印当前日期
echo "当前日期："
date

# 列出当前目录的文件
echo "当前目录的文件："
ls -l

# 显示磁盘空间使用情况
echo "磁盘空间使用情况："
df -h

保存文件并关闭。
修改文件权限：
```
chmod +x multi_command.sh
```
运行脚本，查看输出结果：
```
./multi_command.sh
```

🎯 输出结果：

🎉 解释：

date：显示当前日期和时间。
ls -l：列出当前目录下的文件信息。
df -h：查看磁盘空间使用情况，单位为人类可读格式（GB、MB等）。

通过这个例子，你可以看到如何在一个脚本中处理多个命令，Shell 脚本的强大之处就在于能够将一系列命令组合在一起，完成更复杂的任务。🔥

继续保持学习热情！💪 你已经开始掌握 Shell 脚本的基础，接下来的内容将带你更深入地了解变量、条件判断和流程控制等高级功能！🚀

💰 第四章：Shell 中的变量

4.1 系统（环境）变量

在 Linux 中，系统变量（或称为环境变量）是预定义的变量，它们存储了操作系统的一些关键信息，如用户信息、路径设置等。这些变量影响着系统和 Shell 脚本的行为。

对了，如果你想要一个变量的值就要用$变量名才可以

常见的系统变量：（系统环境变量/etc/profile，用户环境变量【用户家目录下.bashrc中】）

$PATH：存储了所有可执行文件的搜索路径。你可以把自定义的路径添加到 $PATH 中，让系统知道去哪里找你的命令！
示例：

echo $PATH
#啰嗦两句（以下内容不要复制）
--------------------------
系统变量其实就看成一个快链接：
本质上就是将一些执行文件的位置目录放到一个叫path的变量里
如果要执行一个可执行文件就在path里找
看看里面的目录中有没有同名的可执行文件
有就执行。
格式
PATH=目录:目录：【……用冒号隔开】
这样就可以使用systemctl start xxx这样的命令了。

$HOME：表示当前用户的主目录。
示例：
```
echo $HOME
```
$USER：当前登录用户的用户名。
示例：
```
echo $USER
```
$PWD：当前工作目录（Print Working Directory）。
示例：
```
echo $PWD
```
$SHELL：当前使用的 Shell 类型。
示例：
```
echo $SHELL
```

📌 小提示：可以通过 printenv 查看所有环境变量的内容，或使用 export 来设置新的环境变量。

我们应该怎么看所有变量？env和set

env：主要用于临时设置环境变量并运行命令。它不会修改当前 shell 的环境，只在命令执行时有效。（env 变量名=xxx 命令：那么表示这个命令用到的对应变量为xxx）

set：用来显示或设置当前 shell 会话中的变量。它修改的变量会一直存在，直到你关闭 shell。

unset 变量名会让这个自定义的变量消失，小心我unset你。

4.2 自定义变量

Shell 允许你自己定义变量，用于存储数据，提升脚本的灵活性！（作用于在本shell）

定义变量的基本语法：

定义变量：VARIABLE_NAME="value"
撤销变量：unset VARIABLE_NAME
只读变量：readonly 变量名  这个不可以用unset删除
我们说了，自定义变量只可以在本shell中用
这里要重新说一下运行.sh的三种方式
. xx.sh在本shell中运行脚本
-------------
./xx.sh使用的是 指定的解释器运行（比如#!/bin/bash）
解释器名  xx.sh和./一样，不够就不是使用（比如#!/bin/bash）指定
而是直接指定
---------------
所以除了. xx.sh以外都有shell产生，那么原来的自定义变量就用不了了
这个时候，export 变量名 就可以将变量扩展到由本shell产生的新shell中

注意：

变量名不能包含空格。
赋值时等号两边不能有空格。

示例：

name="Alice"
echo $name  # 输出 Alice

修改和使用变量：

修改变量值时，直接重新赋值即可：
```
name="Bob"
echo $name  # 输出 Bob
```

📌 小技巧：

如果想要在字符串中嵌入变量，可以用双引号：
```
echo "Hello, $name"  # 输出 Hello, Bob
```

4.3 特殊变量 $n

在 Shell 脚本中，$n 代表脚本接收的命令行参数。n 是一个数字，表示参数的位置。

示例：
假设你执行了这个脚本：

./script.sh arg1 arg2 arg3

你可以在脚本中使用：

$1：表示第一个参数 arg1
$2：表示第二个参数 arg2
$3：表示第三个参数 arg3

示例脚本：

#!/bin/bash
echo "第一个参数是：$1"
echo "第二个参数是：$2"
echo "第三个参数是：$3"

📌 小提示：这些变量可以用于命令行传递参数，使脚本能够更加灵活！

4.4 特殊变量 $#

$# 表示 传递给脚本的参数个数，即脚本接收到的命令行参数的数量。这个变量可以帮助你判断用户是否输入了足够的参数。

示例：

#!/bin/bash
echo "你传递了 $# 个参数"

执行：

./script.sh arg1 arg2

输出：

你传递了 2 个参数

📌 小提示：用 $# 进行条件判断，确保脚本能根据不同的输入数量做出响应！

*4.5 特殊变量 $** 和 $@

这两个变量都表示 所有传递给脚本的参数，但它们有一些微妙的区别。

$*：把所有参数当作一个整体处理，传递的所有参数被连接成一个字符串。
示例：
```
#!/bin/bash
echo "所有参数（\$*）: $*"
```
$@：与 $* 类似，也代表所有参数，但它将每个参数视为独立的元素，这对于迭代参数时非常有用。
示例：
```
#!/bin/bash
echo "所有参数（\$@）:"
for arg in "$@"; do
  echo "$arg"
done
```

区别示例：

./script.sh arg1 arg2 "arg 3"

$* 输出：
```
arg1 arg2 arg 3
```
$@ 输出：
```
arg1
arg2
arg 3
```

📌 小技巧：当你需要在脚本中传递多个参数，并且每个参数中有空格时，使用 $@ 可以更精确地处理每个参数！

4.6 特殊变量 $?

$? 用于获取 上一个命令的退出状态。它返回一个数字，表示上一个命令执行的结果：

0：表示命令成功执行。
非 0 值：表示命令执行失败。

示例：

#!/bin/bash
echo "执行 ls 命令..."
ls
echo "上一个命令的退出状态是：$?"

输出：

执行 ls 命令...
文件1  文件2  文件3
上一个命令的退出状态是：0

如果上一个命令执行失败，例如文件不存在，$? 会返回一个非零值，表示失败。

📌 小提示：通过判断 $?，你可以根据命令是否成功执行来控制脚本的流程，进行错误处理！

**位置变量**（Position Parameters）是指在 Shell 脚本中，通过命令行传递给脚本的参数。它们通常用于在脚本中引用用户传递的输入。

### 1. **位置变量的基本概念**
位置变量就是以 `$1`, `$2`, `$3` 等形式表示的变量，表示传递给脚本或命令的参数。例如：

```bash
#!/bin/bash
# 示例脚本：position.sh
echo "第一个参数是：$1"
echo "第二个参数是：$2"
echo "第三个参数是：$3"
```

如果你在命令行中运行：

```bash
bash position.sh apple banana cherry
```

脚本输出会是：

```
第一个参数是：apple
第二个参数是：banana
第三个参数是：cherry
```

### 2. **常用的特殊位置变量**
除了 `$1`、`$2`、`$3` 这些位置参数，Shell 中还有一些特殊的、非常有用的 **位置变量**：

- **`$0`**：脚本的名字（调用脚本时使用的命令名）。
  - 例如，`$0` 在脚本中会返回脚本的文件名。
  
  ```bash
  echo "脚本名是：$0"
  ```

- **`$#`**：传递给脚本的参数个数（不包括脚本名）。
  - 例如，如果你传递了 3 个参数给脚本，`$#` 会返回 `3`。

  ```bash
  echo "参数个数是：$#"
  ```

- **`$*`**：所有参数（将所有参数合并成一个单一的字符串，参数之间用空格分隔）。
  - 例如，如果传递了 `apple`, `banana`, `cherry`，`$*` 会返回 `apple banana cherry`。

  ```bash
  echo "所有参数：$*"
  ```

- **`$@`**：与 `$*` 类似，但是 `$@` 在脚本中被引用时会保持每个参数的独立性，尤其在引号内时有区别。
  - 例如，当 `$@` 在双引号内时，它会将每个参数作为独立的字符串处理。

  ```bash
  echo "所有参数：$@"
  ```

  如果你传递了多个参数，`"$@"` 会将每个参数当作独立的字符串处理，尤其适合在循环中使用。

- **`$$`**：当前脚本的进程 ID（PID）。
  - 例如，使用 `$$` 可以获得当前脚本进程的 ID。
  
  ```bash
  echo "当前进程 ID：$$"
  ```

- **`$?`**：上一个命令的退出状态（返回值）。如果上一条命令成功执行，`$?` 的值为 `0`，否则为非零值。

  ```bash
  ls non_existing_file
  echo "上一条命令的退出状态：$?"
  ```

- **`$-`**：当前 shell 的选项状态。
  - 例如，如果你想查看当前 shell 是否在 `interactive` 模式下，可以用 `$-`。

### 3. **如何使用位置变量**

你可以通过传递位置参数来向脚本或命令传递信息。例如，假设你有一个脚本 `greet.sh`：

```bash
#!/bin/bash
echo "Hello, $1!"
```

然后运行：

```bash
bash greet.sh Alice
```

输出：

```
Hello, Alice!
```

### 4. **在脚本中处理多个参数**

你可以在脚本中通过循环处理所有传入的参数。例如，如果你想打印所有传入的参数，可以使用 `$@`：

```bash
#!/bin/bash
for arg in "$@"
do
  echo "参数是：$arg"
done
```

运行：

```bash
bash greet.sh Alice Bob Charlie
```

输出：

```
参数是：Alice
参数是：Bob
参数是：Charlie
```

### 5. **总结**
- **位置变量** 用于脚本中传递和引用命令行参数。
- `$1`, `$2`, `$3` ... 表示传入的参数，`$0` 表示脚本名。
- `$#` 获取参数个数，`$*` 和 `$@` 用于引用所有参数（稍有不同）。
- `$?` 获取上一个命令的退出状态，`$$` 获取当前脚本的进程 ID。

通过掌握这些 Shell 中的变量，你将能够更加灵活和高效地编写脚本，提升你的自动化能力！🚀💡

➕ 第五章：Shell 运算符

5.1 基本语法

在 Shell 脚本 中，运算符用于处理不同类型的数据。我们可以用运算符执行数学计算、逻辑判断、字符串比较等操作。运算符可以大大增强脚本的功能，帮助我们完成自动化任务。

1. 数学运算符

Shell 提供了基本的数学运算符，能够进行加、减、乘、除等常见运算。

常用运算符：

加法：+
减法：-
乘法：*
除法：/
取余：%

在 `$(( ))` 或者`$[]`中进行计算

Shell 允许在 $(( ))或者$[] 中进行数学计算，这是常用的语法方式。注意：在 $(( )) 或者$[]中没有空格。

例子：

a=10
b=5
result=$((a + b))  # 加法
echo $result  # 输出 15

result=$((a - b))  # 减法
echo $result  # 输出 5

result=$((a * b))  # 乘法
echo $result  # 输出 50

result=$((a / b))  # 除法
echo $result  # 输出 2

result=$((a % b))  # 取余
echo $result  # 输出 0

特殊注意：

乘法运算符 * 是有特殊意义的，因此在表达式中使用时要小心。比如，* 在命令行中是一个通配符。为了避免歧义，必须使用 $(( )) 或者$[]来执行运算。

还有这个方式就是使用expr方式，这个方式每一个数字符号都要有空格，用\*表示乘法
expr 用空格的表达式
比如：expr 10 / 2
一般使用变量=expr 10 / 2的方式
如果要直接用就是echo $（expr 10 / 2）这种样子

2. 比较运算符

比较运算符用于比较数值或字符串，通常用于条件判断中。

数值比较：

-eq：等于
-ne：不等于
-lt：小于
-le：小于或等于
-gt：大于
-ge：大于或等于

数值比较例子：

a=5
b=10

if [[ $a -lt $b ]]; then
  echo "$a 小于 $b"  # 输出：5 小于 10
fi

if [[ $a -eq 5 ]]; then
  echo "$a 等于 5"  # 输出：5 等于 5
fi

字符串比较：

=：等于
!=：不等于
<：字典顺序小于（注意：< 需要在双引号中）
>：字典顺序大于（注意：> 需要在双引号中）

字符串比较例子：

str1="apple"
str2="banana"

if [[ $str1 < $str2 ]]; then
  echo "$str1 小于 $str2"  # 输出：apple 小于 banana
fi

if [[ $str1 == "apple" ]]; then
  echo "$str1 等于 apple"  # 输出：apple 等于 apple
fi

注意：

== 用于检查字符串是否相等。
< 和 > 是字典顺序的比较，判断字母的顺序。

3. 逻辑运算符

逻辑运算符用于组合多个条件，常见的有 AND（与）、OR（或）和 NOT（非）运算。

&&：与运算符，左边和右边的条件都为真时，执行接下来的命令。
||：或运算符，左边和右边的条件中只要有一个为真，就执行接下来的命令。
!：非运算符，取反，即条件为真时返回假，条件为假时返回真。

逻辑运算例子：

a=5
b=10
c=20

# AND 运算
if [[ $a -lt $b && $b -lt $c ]]; then
  echo "条件成立：$a 小于 $b 且 $b 小于 $c"  # 输出：条件成立：5 小于 10 且 10 小于 20
fi

# OR 运算
if [[ $a -gt $b || $b -lt $c ]]; then
  echo "条件成立：$a 大于 $b 或 $b 小于 $c"  # 输出：条件成立：5 大于 10 或 10 小于 20
fi

# NOT 运算
if [[ ! $a -gt $b ]]; then
  echo "$a 不大于 $b"  # 输出：5 不大于 10
fi

5.2 案例操作

下面我们将结合实际的例子，通过 数学运算 和 逻辑运算，让你更好地理解这些运算符。

案例一：计算矩形面积

任务：编写一个脚本，输入矩形的长和宽，计算矩形的面积，并判断面积是否大于100。

步骤：

输入矩形的长和宽。
计算面积，面积 = 长 * 宽。
判断面积是否大于100，输出结果。

脚本：

#!/bin/bash

# 输入长和宽
echo "请输入矩形的长："
read length
echo "请输入矩形的宽："
read width

# 计算面积
area=$((length * width))

# 判断面积
if [[ $area -gt 100 ]]; then
  echo "矩形的面积是 $area，面积大于100！"
else
  echo "矩形的面积是 $area，面积小于或等于100。"
fi

执行：

请输入矩形的长：
10
请输入矩形的宽：
12
矩形的面积是 120，面积大于100！

案例二：范围检查

任务：输入一个数字，判断该数字是否在 10 和 50 之间，输出相应的提示。

步骤：

输入一个数字。
判断该数字是否在 10 和 50 之间（包括 10 和 50）。
使用逻辑运算符组合条件。

脚本：

#!/bin/bash

# 输入数字
echo "请输入一个数字："
read number

# 判断数字是否在 10 和 50 之间
if [[ $number -ge 10 && $number -le 50 ]]; then
  echo "数字 $number 在 10 和 50 之间！"
else
  echo "数字 $number 不在 10 和 50 之间！"
fi

执行：

请输入一个数字：
25
数字 25 在 10 和 50 之间！

案例三：字符串比较

任务：输入两个字符串，比较它们是否相同。

步骤：

输入两个字符串。
使用字符串比较运算符判断两个字符串是否相同。

脚本：

#!/bin/bash

# 输入两个字符串
echo "请输入第一个字符串："
read str1
echo "请输入第二个字符串："
read str2

# 判断两个字符串是否相同
if [[ $str1 == $str2 ]]; then
  echo "匹配！"
else
  echo "不匹配！"
fi

执行：

请输入第一个字符串：
hello
请输入第二个字符串：
hello
匹配！

✅ 第六章：条件判断（注意[两边有空格]）

6.1 基本语法

在 Shell 脚本 中，条件判断是让脚本根据不同情况执行不同操作的关键。通过 if 语句，我们可以让脚本根据不同的条件做出判断，并执行相应的操作。

基本的 if 语法：

if [ condition ]; then
    # 如果 condition 为真，执行的命令
fi

带 `else` 的 if 语句：

如果条件不成立，可以使用 else 来执行其他命令。

if [ condition ]; then
    # 如果 condition 为真，执行的命令
else
    # 如果 condition 为假，执行的命令
fi

带 `elif` 的 if 语句：

如果有多个条件需要判断，可以使用 elif 来添加更多的条件。

if [ condition1 ]; then
    # 如果 condition1 为真，执行的命令
elif [ condition2 ]; then
    # 如果 condition2 为真，执行的命令
else
    # 如果所有条件都不成立，执行的命令
fi

注意：

方括号 [ ] 之间的空格是必须的，不能省略。
使用 [[ ]] 更加灵活，可以进行字符串比较等复杂操作，推荐使用。

例子：

a=5
b=10

if [ $a -lt $b ]; then
    echo "$a 小于 $b"  # 输出：5 小于 10
else
    echo "$a 大于等于 $b"
fi

6.2 常用判断条件

Shell 提供了丰富的判断条件，用于在不同情况下进行判断，常见的包括：逻辑运算、文件判断、字符串比较等。

1. 逻辑运算

在判断语句中，我们可以使用逻辑运算符来组合多个条件。

&&：与运算符（AND），两个条件都为真时，整个条件成立。
||：或运算符（OR），只要有一个条件为真，整个条件成立。
!：非运算符（NOT），取反。

示例：

a=5
b=10
c=20

# AND 运算
if [ $a -lt $b ] && [ $b -lt $c ]; then
    echo "条件成立：$a 小于 $b 且 $b 小于 $c"  # 输出：条件成立：5 小于 10 且 10 小于 20
fi

# OR 运算
if [ $a -gt $b ] || [ $b -lt $c ]; then
    echo "条件成立：$a 大于 $b 或 $b 小于 $c"  # 输出：条件成立：5 大于 10 或 10 小于 20
fi

# NOT 运算
if ! [ $a -gt $b ]; then
    echo "$a 不大于 $b"  # 输出：5 不大于 10
fi

2. 文件判断

Shell 提供了多种文件测试操作符，用于判断文件的类型或属性。常见的文件测试运算符有：

-e：文件是否存在
-f：是否是普通文件
-d：是否是目录
-r：是否可读
-w：是否可写
-x：是否可执行
-s：文件是否为空

示例：

file="myfile.txt"

# 判断文件是否存在
if [ -e $file ]; then
    echo "$file 存在"
else
    echo "$file 不存在"
fi

# 判断是否为普通文件
if [ -f $file ]; then
    echo "$file 是一个普通文件"
else
    echo "$file 不是一个普通文件"
fi

# 判断是否为目录
if [ -d $file ]; then
    echo "$file 是一个目录"
else
    echo "$file 不是一个目录"
fi

3. 字符串比较

Shell 也允许对字符串进行比较。常见的字符串比较操作符如下：

=：判断两个字符串是否相等
!=：判断两个字符串是否不相等
<：判断一个字符串是否按字典顺序小于另一个字符串
>：判断一个字符串是否按字典顺序大于另一个字符串

示例：

str1="apple"
str2="banana"

if [ "$str1" = "$str2" ]; then
    echo "$str1 和 $str2 相等"
else
    echo "$str1 和 $str2 不相等"  # 输出：apple 和 banana 不相等
fi

# 字典顺序比较
if [ "$str1" \< "$str2" ]; then
    echo "$str1 小于 $str2"  # 输出：apple 小于 banana
fi

4. 数值比较

对于数字比较，我们使用数值比较运算符（参考前一章）。

-eq：等于
-ne：不等于
-lt：小于
-le：小于或等于
-gt：大于
-ge：大于或等于

示例：

a=5
b=10

if [ $a -lt $b ]; then
    echo "$a 小于 $b"  # 输出：5 小于 10
fi

6.3 案例实操

现在我们通过一些实际的案例来深入理解 条件判断 在 Shell 脚本中的应用。

案例一：判断数字的范围

任务：编写一个脚本，输入一个数字，判断它是否在 1 到 100 之间。

脚本：

#!/bin/bash

echo "请输入一个数字："
read number

if [ $number -ge 1 ] && [ $number -le 100 ]; then
    echo "$number 在 1 到 100 之间"
else
    echo "$number 不在 1 到 100 之间"
fi

执行：

请输入一个数字：
50
50 在 1 到 100 之间

案例二：文件存在性检查

任务：编写一个脚本，判断某个文件是否存在，且是否为可执行文件。

脚本：

#!/bin/bash

echo "请输入文件名："
read filename

if [ -e "$filename" ]; then
    if [ -x "$filename" ]; then
        echo "$filename 存在并且是可执行文件"
    else
        echo "$filename 存在，但不是可执行文件"
    fi
else
    echo "$filename 不存在"
fi

执行：

请输入文件名：
test.sh
test.sh 存在并且是可执行文件

案例三：登录脚本

任务：编写一个脚本，检查用户是否以 root 权限登录，如果是，则输出“欢迎，管理员！”。

脚本：

#!/bin/bash

if [ "$(whoami)" = "root" ]; then
    echo "欢迎，管理员！"
else
    echo "你不是 root 用户，无法执行此操作。"
fi

执行：

$ ./check_user.sh
欢迎，管理员！

🔁 第七章：流程控制（重点）

7.1 if 判断

条件判断是流程控制的基础。在 Shell 中，if 语句用来根据不同的条件执行不同的操作。通过合理的条件判断，可以让你的脚本具备决策能力，判断条件后执行相应操作。

基本语法：

if [ condition ]; then
    # 执行的命令
fi

扩展：配合 else、elif 等，可以实现多层次的条件判断。

示例：

#!/bin/bash

echo "请输入一个数字："
read number

if [ $number -gt 100 ]; then
    echo "数字大于 100"
elif [ $number -eq 100 ]; then
    echo "数字等于 100"
else
    echo "数字小于 100"
fi

通过 if 判断语句，你可以控制脚本的执行流程，按需决定执行哪个部分的代码。🌟

7.2 case 语句

在复杂的条件判断中，case 语句是一种更优雅的选择，特别是在需要根据多个可能的值来执行不同操作时，case 能有效避免层层嵌套的 if。

基本语法：

case $variable in
    pattern1)
        # 执行命令1
        ;;
    pattern2)
        # 执行命令2
        ;;
    *)
        # 默认命令
        ;;
esac

示例：

#!/bin/bash

echo "请输入星期数（1-7）："
read day

case $day in
    1)
        echo "星期一"
        ;;
    2)
        echo "星期二"
        ;;
    3)
        echo "星期三"
        ;;
    4)
        echo "星期四"
        ;;
    5)
        echo "星期五"
        ;;
    6)
        echo "星期六"
        ;;
    7)
        echo "星期天"
        ;;
    *)
        echo "输入无效，请输入1-7之间的数字！"
        ;;
esac

优点：

简洁：当条件非常多时，case 语句比多个 if-else 更清晰。
易维护：逻辑分明，修改某个分支时，不会影响到其他条件。

7.3 for 循环

for 循环是用于重复执行某个命令或一系列命令的强大工具。当你需要让脚本执行一段固定次数的操作时，for 循环是非常理想的选择。

基本语法：

for variable in value1 value2 value3
do
    # 执行的命令
done

示例：输出 1 到 5 的数字

#!/bin/bash

for i in {1..5}
do
    echo "数字：$i"
done

输出：

数字：1
数字：2
数字：3
数字：4
数字：5

经典应用：批量处理文件

for file in *.txt
do
    echo "处理文件：$file"
done

通过 for 循环，你可以轻松地进行批量操作，提高效率！🎯

7.4 while 循环

while 循环根据给定的条件重复执行一段代码，直到条件不再满足。这种循环特别适合当你不知道循环的次数，而是依赖于某个条件来决定是否继续执行。

基本语法：

while [ condition ]
do
    # 执行的命令
done

示例：让用户输入一个数字，直到输入的数字是 10 为止。

#!/bin/bash

echo "请输入数字："

while true
do
    read number
    if [ $number -eq 10 ]; then
        echo "输入正确！"
        break
    else
        echo "数字不正确，请重新输入："
    fi
done

输出：

请输入数字：
5
数字不正确，请重新输入：
7
数字不正确，请重新输入：
10
输入正确！

应用：等待文件出现

while [ ! -f /path/to/file ]
do
    echo "文件还没出现，等待中..."
    sleep 2
done
echo "文件出现！"

while 循环特别适合用在不确定执行次数的情况下，直到特定条件满足为止。

7.5 基本语法（二）

除了常见的简单循环结构，Shell 还支持更为复杂的循环结构，可以让我们更灵活地编写高效的脚本。

1. `for` 循环的进阶应用

# 使用 C 风格的 for 循环
for ((i=0; i<5; i++))
do
    echo "i 的值是：$i"
done

2. 无限循环与退出

使用 while true 或 for 循环配合 break，可以让程序在特定条件下终止。

while true
do
    echo "这是一个无限循环"
    break  # 一旦满足条件，跳出循环
done

3. 使用 `continue` 跳过当前循环

在某些情况下，我们不想执行循环中的某部分命令，可以使用 continue 来跳过当前循环。

for i in {1..5}
do
    if [ $i -eq 3 ]; then
        continue  # 跳过 i=3 时的代码
    fi
    echo "当前数字：$i"
done

输出：

当前数字：1
当前数字：2
当前数字：4
当前数字：5

🎤 第八章：read —— 交互式Shell脚本

8.1 基本语法

read 命令是 Shell 中一个非常实用的工具，它能够让脚本接收用户输入，使得脚本变得更具交互性。在交互式脚本中，read 命令常常用来从用户获取数据并据此执行不同的操作。通过使用 read，你的脚本能够理解用户的需求，并做出相应反应。

基本语法：

read variable_name

示例：读取用户输入并存储到变量中

#!/bin/bash

echo "请输入你的名字："
read name
echo "你好，$name！"

解释：

脚本会在执行到 read 命令时暂停，等待用户输入。
用户输入的内容会被存储到 name 变量中。
之后，脚本会输出用户输入的名字。

输出：

请输入你的名字：
张三
你好，张三！

8.2 案例实操

在实际应用中，read 不仅仅是一个简单的输入命令，它可以实现更加复杂的交互，帮助创建更具动态感的脚本。以下是几个常见的用法，带你一起打造更有趣、更智能的交互式脚本！

1. 输入多个变量

通过在同一行中使用多个变量，你可以让用户一次性输入多个值，read 会把这些值分别赋给不同的变量。

示例：输入姓名和年龄

#!/bin/bash

echo "请输入你的名字和年龄（用空格分开）："
read name age
echo "你好，$name！你今年 $age 岁。"

输出：

请输入你的名字和年龄（用空格分开）：
张三 25
你好，张三！你今年 25 岁。

2. 隐藏输入内容

read 还可以通过 -s 选项来隐藏用户输入内容，这在需要输入密码等敏感信息时非常有用。

示例：输入密码

#!/bin/bash

echo "请输入密码："
read -s password
echo "密码已输入完毕！"

输出：

请输入密码：
密码已输入完毕！

在这里，密码输入时不会显示在终端上，这为用户提供了更好的隐私保护。

3. 设置默认值

你可以为 read 提供默认值，如果用户不输入任何内容，默认值将会被使用。这可以让脚本更加灵活，并避免因缺少输入而出错。

示例：使用默认值

#!/bin/bash

echo "请输入你的年龄（默认18岁）："
read age
age=${age:-18}  # 如果用户没输入，使用默认值 18
echo "你输入的年龄是：$age"

输出：

请输入你的年龄（默认18岁）：
25
你输入的年龄是：25

如果用户没有输入年龄，则会默认使用 18 作为年龄。

4. 输入验证

通过结合条件判断，你可以验证用户的输入是否合法，确保脚本按预期执行。

示例：验证输入的数字

#!/bin/bash

echo "请输入一个数字："
read number

if [[ ! "$number" =~ ^[0-9]+$ ]]; then
    echo "输入无效，请输入一个数字！"
else
    echo "你输入的数字是：$number"
fi

输出：

请输入一个数字：
abc
输入无效，请输入一个数字！

通过正则表达式的配合，确保用户输入的是一个有效的数字。

🛠 第九章：函数 —— 代码复用的艺术！

9.1 系统函数

在 Shell 编程中，函数是一种非常强大的工具，能够帮助我们将代码逻辑封装成可重用的模块。除了自定义函数，Shell 还提供了很多内置的系统函数，帮助我们快速实现常见的操作。

常见的Shell内置系统函数：

echo：输出文本到终端。
```
echo "Hello, World!"
```
exit：退出脚本并返回指定的退出状态。
```
exit 0  # 正常退出
```
read：从用户获取输入，之前已经介绍过。

test：用于评估条件表达式，返回真或假。

if test -f "file.txt"; then
    echo "文件存在"
fi

printf：格式化输出文本，比 echo 更灵活。
```
printf "Name: %s, Age: %d\n" "Alice" 25
```
sleep：让脚本暂停执行一段时间。
```
sleep 5  # 暂停5秒
```
date：显示当前日期和时间，支持格式化。
```
date "+%Y-%m-%d %H:%M:%S"
```

如何调用系统函数：

Shell 内置的系统函数直接可以在脚本中使用，无需额外导入或定义。例如，echo、exit、printf 等都可以在任何地方调用。

9.2 自定义函数

自定义函数使得我们能够将一段逻辑封装起来，避免代码重复。它们不仅可以提高代码的可读性，还能有效提高代码的复用性。Shell 函数可以接收参数并返回值，极大地提高了脚本的灵活性和功能性。

自定义函数的基本语法：

function function_name {
    # 函数内容
}

或

function_name() {
    # 函数内容
}

定义一个简单的函数：

#!/bin/bash

greet() {
    echo "Hello, $1!"  # $1 是传入的第一个参数
}

greet "Alice"  # 调用 greet 函数并传入 "Alice" 作为参数

输出：

Hello, Alice!

函数返回值：

Shell 函数可以通过 return 语句返回一个状态码，返回值是一个整数，通常用来表示函数的执行结果（0 表示成功，非 0 表示失败）。

#!/bin/bash

add() {
    local sum=$(( $1 + $2 ))
    return $sum
}

add 5 3
result=$?
echo "The sum is: $result"

输出：

The sum is: 8

在这个例子中，add 函数计算两个数字的和，并通过 return 返回该值。然而，return 只能返回整数，因此如果你想返回浮点数或者更复杂的结果，可以考虑通过命令输出的方式来实现。

函数中的局部变量：

在 Shell 脚本中，默认的变量是全局的。如果你希望函数内部的变量不影响外部，可以使用 local 来声明局部变量。

#!/bin/bash

add() {
    local sum=$(( $1 + $2 ))
    echo $sum
}

result=$(add 5 3)
echo "The sum is: $result"

输出：

The sum is: 8

在这个例子中，sum 是一个局部变量，只在 add 函数内部有效。它不会影响函数外部的变量。

递归函数：

Shell 支持递归函数调用，即函数调用自己。这在处理某些问题时（如计算阶乘、斐波那契数列等）非常有用。

#!/bin/bash

factorial() {
    if [ $1 -le 1 ]; then
        echo 1
    else
        local result=$(($(factorial $(($1 - 1))) * $1))
        echo $result
    fi
}

result=$(factorial 5)
echo "5! = $result"

输出：

5! = 120

⚙️ 第十章：Shell工具（重点）

10.1 cut — 轻松剪切文本内容

cut 是一个非常简单但强大的工具，主要用于从文本文件中提取指定字段或者字符。它特别适合用于处理列式数据，像 CSV 文件 或 日志文件，非常高效。

基本语法：

cut -d '分隔符' -f '字段' 文件

-d：指定字段分隔符，默认为制表符（Tab），可以设置为逗号、空格等。
-f：指定字段，字段从 1 开始。例如，-f 1 表示提取第一列，-f 1,3 表示提取第一列和第三列。
-c：按照字符位置提取，而不是按照字段分割。

常见使用场景：

提取字段（基于分隔符）：假设有一个以逗号分隔的文件 data.csv：
```
Alice,30,Engineer
Bob,25,Artist
Charlie,35,Doctor
```
提取第二列（年龄）：
```
cut -d ',' -f 2 data.csv
```
输出：
```
30
25
35
```
提取指定字符：假设有一个文件 text.txt：
```
abcdefghijklmnopqrstuvwxyz
```
提取第1到第5个字符：
```
cut -c 1-5 text.txt
```
输出：
```
abcde
```

提取多个字段：假设有一个文件 info.txt：

name age city
Alice 30 Beijing
Bob 25 Shanghai
Charlie 35 Shenzhen

提取 name 和 age 列：

cut -d ' ' -f 1,2 info.txt

输出：

name age
Alice 30
Bob 25
Charlie 35

10.2 sed — 文本流编辑神器

sed 是一个流编辑器，允许我们对文件或标准输入流中的文本进行编辑、替换、删除、插入等操作。它非常适合批量处理文件内容，可以替代手动编辑的繁琐操作。

基本语法：

sed '操作' 文件

操作包括替换、删除、插入等。

常用操作：

替换文本： s/old/new/ 用于替换文本中的字符串，第一个 old 为匹配的字符串，new 为替换后的字符串。

替换第一处匹配：
```
sed 's/apple/orange/' file.txt
```
替换所有匹配项：
```
sed 's/apple/orange/g' file.txt
```
替换时区分大小写：
```
sed 's/apple/orange/I' file.txt
```
删除行：删除文件中的指定行。例如，删除第2行：
```
sed '2d' file.txt
```
删除包含特定模式的行：
```
sed '/pattern/d' file.txt
```
插入文本：在文件的第3行前插入文本：
```
sed '3i This is new text' file.txt
```
替换文件内容并保存：使用 -i 选项直接修改文件（原地替换）：
```
sed -i 's/apple/orange/g' file.txt
```

示例：批量替换

假设文件 file.txt 内容如下：

apple pie
banana pie
apple tart

要将所有的 apple 替换成 orange，可以使用：

sed 's/apple/orange/g' file.txt

输出：

orange pie
banana pie
orange tart

10.3 awk — 处理结构化文本的利器

awk 是一个强大的文本处理工具，它专门用于处理格式化文本，尤其适合表格数据的处理。它支持正则表达式、条件判断、循环等操作，非常适合进行复杂的数据处理。

基本语法：

awk '{操作}' 文件

{} 中的部分是操作，可以是打印、计算、条件判断等。

常见操作：

打印字段：打印文件中的第一列和第二列（字段由空格分隔）：
```
awk '{print $1, $2}' file.txt
```
按分隔符提取字段：如果文件使用逗号作为分隔符，可以使用 -F 选项指定字段分隔符：
```
awk -F ',' '{print $1, $2}' file.csv
```
条件筛选：只打印年龄大于25的人：
```
awk '$2 > 25 {print $1, $2}' file.txt
```
计算总和：计算文件中所有数字的和：
```
awk '{sum+=$1} END {print sum}' file.txt
```
多重条件筛选：假设文件格式是 name age city，你想筛选出年龄大于25且城市为Beijing的人：
```
awk '$2 > 25 && $3 == "Beijing" {print $1, $2, $3}' file.txt
```

示例：处理CSV文件

假设 people.csv 内容如下：

Alice,30,Engineer
Bob,25,Artist
Charlie,35,Doctor

要提取姓名和年龄（以逗号分隔）：

awk -F ',' '{print $1, $2}' people.csv

输出：

Alice 30
Bob 25
Charlie 35

10.4 sort — 让数据排序不再是难题

sort 用于排序文本文件中的内容，支持多种排序规则，包括字母顺序、数字顺序和日期顺序。

基本语法：

sort [选项] 文件

默认按字母顺序排序。

常见选项：

按字母排序：默认情况下，sort 按字母顺序对文件进行排序：
```
sort file.txt
```
按数字排序：如果文件内容是数字，可以使用 -n 选项按数字顺序排序：
```
sort -n file.txt
```
倒序排序：使用 -r 选项进行反向排序：
```
sort -r file.txt
```
按特定列排序：假设 data.txt 文件内容如下：
```
Alice 30
Bob 25
Charlie 35
```
要根据第二列（年龄）进行排序：
```
sort -k 2 -n data.txt
```
输出：
```
Bob 25
Alice 30
Charlie 35
```

示例：按数字排序

假设 numbers.txt 包含以下内容：

按数字顺序排序：

sort -n numbers.txt

输出：

📜 Shell一百例 —— 从小白到大佬！

🎯 100个Shell实战案例，让你边学边练！
✅ 文件操作（批量改名、自动备份、日志管理）
✅ 网络管理（IP检测、端口扫描、自动化运维）
✅ 系统监控（CPU/内存使用情况、磁盘空间监测）
✅ 数据处理（文本过滤、日志分析、自动化爬取）
✅ 娱乐编程（自动生成表情包、随机密码生成器）

📌 🚀 每天练1个，三个月后你就是Shell高手！

这样章节层次更清晰，看起来更舒服了！🔥😎 有需要调整的地方随时告诉我！🚀

查看全文

http://www.kler.cn/a/596614.html

Linux笔记---文件系统软件部分

构音障碍（Dysarthria）研究全景总结（1996–2024）

在Windows和Linux系统上的Docker环境中使用的镜像是否相同

常考计算机操作系统面试习题（二）（中）

C语言-排序

WSL 导入完整系统包教程

3-22 vector的使用详解---STL C++

xss跨站之原理分类及攻击手法

初级：数组与字符串面试题深度剖析

分布式账本技术在 Web3 数据保护中的应用与实践

基于deepseek的智能语音客服【第四讲】封装milvus数据库连接池封装

HC-05与HC-06蓝牙配对零基础教程以及openmv识别及远程传输项目的概述

常考计算机操作系统面试习题（三下）

FFmpeg + ‌Qt‌ 简单视频播放器代码

通过SSH隧道与跳板机实现本地端口映射访问服务器文件

【Qt】常用控件

SQL注入（SQL Injection）攻击原理与防御措施

（c语言）网络编程之UDP认识与并发服务器实现

40岁重启人生学Python，用煎饼摊理解函数，用快递盒认识变量

python3使用lxml解析xml时踩坑记录

🔥 Shell 基础——从入门到精通 🚀

🌱 第一章：Shell，简单说！

👶 什么是Shell？它到底能做什么？

1. Shell 是什么？

2. Shell 能做什么？

3. 为什么要学 Shell？

4. 一个 Shell 命令的执行流程

🐚 第二章：Shell 解释器

1️⃣ Bash（Bourne Again Shell）—— 默认之王 👑

2️⃣ Zsh（Z Shell）—— 终端增强神器 🚀

3️⃣ Fish（Friendly Interactive Shell）—— 终端中的“智能 AI” 🤖

4️⃣ 其他 Shell 解析器（不常用但值得了解）

5️⃣ Bash、Zsh、Fish 对比总结 🏆

🔥 哪个 Shell 最适合你？

📝 第三章：Shell 脚本入门

3.1 脚本格式

3.2 第一个 Shell 脚本：Hello, World!

3.3 第二个 Shell 脚本：多命令处理

💰 第四章：Shell 中的变量

4.1 系统（环境）变量

4.2 自定义变量

4.3 特殊变量 $n

4.4 特殊变量 $#

4.5 特殊变量 $* 和 $@

4.6 特殊变量 $?

➕ 第五章：Shell 运算符

5.1 基本语法

1. 数学运算符

在 $(( )) 或者$[]中进行计算

特殊注意：

2. 比较运算符

数值比较：

字符串比较：

3. 逻辑运算符

5.2 案例操作

案例一：计算矩形面积

案例二：范围检查

案例三：字符串比较

✅ 第六章：条件判断（注意[两边有空格]）

6.1 基本语法

基本的 if 语法：

带 else 的 if 语句：

带 elif 的 if 语句：

注意：

例子：

6.2 常用判断条件

1. 逻辑运算

2. 文件判断

3. 字符串比较

4. 数值比较

6.3 案例实操

案例一：判断数字的范围

案例二：文件存在性检查

案例三：登录脚本

🔁 第七章：流程控制（重点）

7.1 if 判断

基本语法：

7.2 case 语句

基本语法：

7.3 for 循环

基本语法：

经典应用：批量处理文件

7.4 while 循环

基本语法：

应用：等待文件出现

7.5 基本语法（二）

1. for 循环的进阶应用

2. 无限循环与退出

3. 使用 continue 跳过当前循环

🎤 第八章：read —— 交互式Shell脚本

8.1 基本语法

基本语法：

8.2 案例实操

1. 输入多个变量

2. 隐藏输入内容

3. 设置默认值

4. 输入验证

🛠 第九章：函数 —— 代码复用的艺术！

9.1 系统函数

常见的Shell内置系统函数：

*4.5 特殊变量 $** 和 $@

在 `$(( ))` 或者`$[]`中进行计算

带 `else` 的 if 语句：

带 `elif` 的 if 语句：

1. `for` 循环的进阶应用

3. 使用 `continue` 跳过当前循环