2.1 Shell 脚本入门

预计阅读时间：20 分钟

前置知识

• 1.9：重定向与管道 重定向与管道：理解 stdin/stdout/stderr、| 管道、>/>> 重定向、$? 退出码——这些是 Shell 脚本的基础构建块
• 1.6：文件查看与文本编辑 文件查看与文本编辑：熟悉 nano/vim 基本操作，用于编写和编辑脚本文件

学习目标

学完本章后，你将能够：

• 编写并执行第一个 Bash 脚本，理解 shebang（#!/bin/bash）的作用
• 使用变量（定义、引用、默认值、特殊变量）存储和操作数据
• 使用 if/case 条件分支实现逻辑判断
• 使用 for/while/until 循环处理批量任务
• 定义和调用函数，理解局部变量与全局变量的区别
• 使用 set -euo pipefail 严格模式编写健壮的脚本
• 使用 trap 处理信号和清理临时文件

知识关联

• 前置知识：1.9：重定向与管道 重定向与管道（$? 退出码、&&/|| 条件链）；1.6：文件查看与文本编辑 文件查看与文本编辑（vim 编辑脚本）
• 后续影响：2.8：Shell 脚本进阶 Shell 脚本进阶（数组、trap、进程替换、flock）；4.19：Shell 实战案例集 Shell 实战案例集（生产级脚本）
• 配套技术：2.10：正则表达式 正则表达式（在脚本中用 =~ 做模式匹配）；3.15：Cron 定时任务 Cron 定时任务（用 cron/systemd timer 调度脚本）
• 在整个体系中的位置：Shell 脚本是 Linux 自动化的基石——从简单的文件批处理到复杂的运维流程，都离不开脚本。掌握脚本能力是从"会用命令"到"自动化运维"的分水岭

核心知识

• Shell 脚本（Shell Script）——将一系列命令写入文件，由 Shell 解释执行。相当于"命令的批处理文件"
• Shebang（#!）——脚本第一行 #!/bin/bash，告诉系统用哪个解释器执行此脚本
• 变量（Variable）——存储数据的容器，分为局部变量、环境变量、特殊变量
• 条件判断（Conditional）——if/case 根据条件执行不同分支
• 循环（Loop）——for/while/until 重复执行一段代码
• 函数（Function）——将一段代码封装为可复用的模块
• 退出码（Exit Code）——脚本执行完毕返回给调用者的状态码，0=成功，非0=失败
• 严格模式（Strict Mode）——set -euo pipefail 让脚本在遇到错误时立即终止，避免"静默失败"

原理讲解

1. 第一个 Shell 脚本——shebang 与执行方式

Shell 脚本本质上就是一个包含命令的文本文件，交给 Shell 逐行解释执行。创建脚本的第一步是写好 shebang 行：

#!/bin/bash
# 第一个脚本：hello.sh
echo "Hello, Linux!"

echo "当前用户: $(whoami)"
echo "当前时间: $(date)"

Shebang（#!）：脚本第一行。它以 # 开头（所以是"注释"），但含义特殊——告诉内核"用哪个解释器来执行这个文件"。#!/bin/bash 表示用 Bash，#!/bin/sh 表示用 POSIX sh，#!/usr/bin/env python3 表示用 PATH 中的 python3。

执行脚本的三种方式：

# 方式 1：给执行权限后直接执行（推荐）
chmod +x hello.sh
./hello.sh

# 方式 2：用解释器显式执行（不需要执行权限）
bash hello.sh

# 方式 3：在当前 Shell 中执行（脚本中的变量/函数会留在当前 Shell）
source hello.sh        # 等价于 . hello.sh

三种方式的区别：方式 1 和 2 都在子进程中执行脚本——脚本里定义的变量、cd 等不会影响当前 Shell；方式 3 在当前 Shell 中执行，适合加载配置。

2. 变量定义与引用

# 定义（等号两边绝对不能有空格！）
name="Alice"
age=25

# 引用（加 $ 前缀）
echo "$name"              # 双引号内变量会展开
echo '$name'              # 单引号内原样输出

# 花括号明确边界
echo "${name}Smith"       # 输出 AliceSmith
echo "$nameSmith"         # 输出空（nameSmith 未定义）

变量名的规则：只能由字母、数字、下划线组成，且不能以数字开头。引用时加 $ 前缀；字符串拼接场景用 ${var} 花括号明确边界。

3. 变量默认值与替换

# ${var:-default}  —— 变量未设置或为空时使用默认值
echo "${DB_HOST:-localhost}"

# ${var:=default}  —— 同上，但同时将默认值赋给变量
: "${DB_HOST:=localhost}"

# ${var:+value}    —— 变量已设置时使用 value，否则为空
echo "${DEBUG:+Debug mode is ON}"

# ${var:?message}  —— 变量未设置时报错退出
: "${CONFIG_FILE:?CONFIG_FILE is required}"

# 常见用法：脚本参数带默认值
BACKUP_DIR="${1:-/backup}"
RETENTION="${2:-30}"

默认值替换是脚本最常用的健壮性技巧——让脚本在没有参数或环境变量时也能安全运行。

4. 特殊变量全集

5. 命令替换

# $(command) —— 推荐，可嵌套
now=$(date +%Y%m%d)
files=$(ls /var/log | wc -l)
parent=$(dirname $(realpath "$0"))

# 旧式反引号写法，不可嵌套，不推荐
# now=`date +%Y%m%d`  # 用 $() 替代

6. 条件判断（if/case）

[ ] vs [[ ]]

# [ ] 是 POSIX 标准命令（test 的别名），兼容所有 Shell
# [[ ]] 是 Bash 关键字，功能更强、更安全（推荐在 Bash 脚本中使用）

# [[ ]] 的优势：
# 1. 不需要引号保护空变量
[[ -z $var ]]              # 即使 $var 为空也不会语法错误
[ -z "$var" ]              # [ ] 必须加引号

# 2. 支持 && 和 || 逻辑运算
[[ -f $file && -r $file ]]

# 3. 支持 =~ 正则匹配
[[ $email =~ ^[a-z]+@[a-z]+.[a-z]+$ ]]

# 4. 支持词法排序比较
[[ "apple" < "banana" ]]

条件测试大全

if / elif / else

#!/bin/bash
read -p "输入数字: " num

if [[ $num -gt 10 ]]; then
    echo "大于10"
elif [[ $num -eq 10 ]]; then
    echo "等于10"
else
    echo "小于10"
fi

# 一行写法
[[ -f config.ini ]] && echo "配置文件存在" || echo "配置文件缺失"

case 多分支匹配

#!/bin/bash
read -p "输入动作 (start|stop|restart|status): " action

case $action in
    start|boot)
        echo "启动服务..."
        ;;
    stop|shutdown)
        echo "停止服务..."
        ;;
    restart|reload)
        echo "重启服务..."
        ;;
    status)
        echo "服务状态: 运行中"
        ;;
    *)
        echo "用法: $0 {start|stop|restart|status}"
        exit 1
        ;;
esac

7. 算术运算

# (( )) 算术运算（仅整数）
a=10; b=3
echo $((a + b))           # 13
echo $((a / b))           # 3（整数除法）
echo $((a % b))           # 1（取余）
((a++))                   # 自增
((a += 5))                # 复合赋值

# 浮点数运算用 bc 或 awk
echo "scale=2; 10/3" | bc
awk "BEGIN {printf \"%.2f\", 10/3}"

8. 循环（for/while/until）

for 循环

# 遍历列表
for fruit in apple banana orange; do
    echo "$fruit"
done

# 花括号展开
for i in {1..10}; do echo "$i"; done
for i in {10..1..2}; do echo "$i"; done  # 步长为2

# C 风格
for ((i=0; i<10; i++)); do
    echo "$i"
done

# 遍历通配符（比解析 ls 输出更安全）
for file in *.txt; do
    [[ -f "$file" ]] || continue
    echo "处理: $file"
done

# 遍历命令输出（用 while read 更安全）
find . -name "*.log" -print0 | while IFS= read -r -d '' file; do
    echo "$file"
done

while / until 循环

# while —— 条件为真时循环
count=1
while [[ $count -le 5 ]]; do
    echo "计数: $count"
    ((count++))
done

# until —— 条件为假时循环（直到条件为真）
count=1
until [[ $count -gt 5 ]]; do
    echo "计数: $count"
    ((count++))
done

# 逐行读取文件（最安全的读文件方式）
while IFS= read -r line || [[ -n "$line" ]]; do
    echo "行内容: $line"
done < file.txt

# 无限循环
while true; do
    check_status
    sleep 60
done

循环控制：break / continue

# break N  —— 跳出 N 层循环（默认 1 层）
for i in {1..5}; do
    for j in {1..5}; do
        if [[ $j -eq 3 ]]; then
            break 2      # 跳出两层循环
        fi
    done
done

# continue —— 跳过当前迭代，继续下一次
for file in *; do
    [[ -d "$file" ]] && continue  # 跳过目录
    echo "处理文件: $file"
done

9. 函数

函数定义与调用

# 定义（两种写法等价）
function greet { ... }
greet() { ... }              # 推荐，POSIX 兼容

# 调用（不需要括号）
greet "Alice"
result=$(add 3 5)            # 通过命令替换获取输出

# 函数内变量默认是全局的！
myfunc() {
    name="Bob"               # 全局变量！
}
myfunc
echo "$name"                 # 输出 Bob

函数参数与局部变量

greet() {
    local name="$1"          # local 声明局部变量
    local age="${2:-18}"     # 第二个参数带默认值
    echo "Hello, $name ($age)"
}
greet "Alice" 25

# 函数内访问脚本参数需要传递
main() {
    local script_arg="$1"
    echo "Script arg: $script_arg"
}
main "$@"                    # 将脚本参数传给函数

函数返回值

# return 返回退出码（0-255 整数）
is_even() {
    (( $1 % 2 == 0 )) && return 0 || return 1
}
if is_even 4; then echo "偶数"; fi

# echo 返回任意数据（通过命令替换获取）
get_timestamp() {
    date +%Y%m%d_%H%M%S
}
ts=$(get_timestamp)

10. 输入输出——read、here-document 与 here-string

here-document 和 here-string 的基本语法在 1.9：重定向与管道 已讲过（<< 与 <<<），这里重点看它们在脚本中的典型用法：

Here Document（脚本中生成配置文件）

# 基本用法
cat << EOF > config.ini
[server]
host = localhost
port = 8080
EOF

# 带缩进（<<- 忽略前导 Tab）
cat <<- EOF
    这行前面有 Tab
EOF

# 禁止变量展开（分隔符加引号）
cat << 'EOF'
$HOME 不会被展开
EOF

read —— 读取用户输入

# 基本读取
read -p "输入用户名: " username

# 静默输入（密码）
read -sp "输入密码: " password; echo

# 带超时（秒）
read -t 5 -p "5秒内输入: " answer

# 限制字符数
read -n 1 -p "按任意键继续..."

# 读取到数组
read -a arr <<< "one two three"

11. 信号处理（trap）

#!/bin/bash

# 定义清理函数
cleanup() {
    echo "清理临时文件..."
    rm -f /tmp/mytmp_$$
    echo "退出。"
}

# 注册信号处理器
trap cleanup EXIT            # 脚本退出时执行
trap 'echo "被中断!"; exit 1' INT TERM  # Ctrl+C 或 kill 时

# 查看当前 trap 设置
trap -p

# 移除 trap
trap - EXIT

为什么需要 trap？脚本被 Ctrl+C 中断、或执行出错退出时，临时文件会残留在系统里。把清理动作注册到 EXIT 上，无论脚本怎么退出（正常结束、被信号中断、set -e 触发退出）都会执行清理。

12. 安全陷阱与最佳实践

#!/bin/bash

# 1. 严格模式（放在脚本开头）
set -euo pipefail
# -e: 任何命令失败立即退出
# -u: 使用未定义变量报错
# -o pipefail: 管道中任一命令失败则整体失败

# 2. 变量加引号（防止空格分词和通配符展开）
file="my document.txt"
rm "$file"                   # 正确
# rm $file                   # 错误！会删除 my 和 document.txt

# 3. 使用 [[ ]] 而非 [ ]（Bash 脚本中）
if [[ -f "$file" && -r "$file" ]]; then ...

# 4. 路径用双引号包裹
cd "$HOME" || exit 1

# 5. 临时文件安全创建
tmpfile=$(mktemp) || exit 1
trap 'rm -f "$tmpfile"' EXIT

# 6. 检查命令是否存在
if ! command -v jq &> /dev/null; then
    echo "请安装 jq: sudo apt install jq"
    exit 1
fi

# 7. 脚本目录定位（处理符号链接）
SCRIPT_DIR=$(cd "$(dirname "$(readlink -f "$0")")" && pwd)
cd "$SCRIPT_DIR" || exit 1

13. 子 Shell 与进程管理

# ( ) 创建子 Shell —— 不影响当前环境
(cd /tmp && ls)             # cd 只在子 Shell 中生效
echo "$PWD"                 # 仍然是原目录

# { } 在当前 Shell 中执行命令组
{ cd /tmp && ls; }
echo "$PWD"                 # /tmp

# 后台执行与等待
long_task1 &
long_task2 &
wait                         # 等待所有后台任务完成

# 检查后台任务退出状态
long_task &
pid=$!
wait $pid
echo "Exit code: $?"

示例代码

下面是一个完整的实战示例——日志备份脚本。它用到了本章的大部分知识点：变量、默认值、条件判断、循环、函数、严格模式和 trap：

#!/bin/bash
# 示例：backup_logs.sh —— 备份指定目录下的日志并清理过期备份
set -euo pipefail

# ---- 配置（支持命令行参数覆盖默认值）----
SRC_DIR="${1:-/var/log}"
BACKUP_DIR="${2:-$HOME/log-backups}"
KEEP_DAYS="${3:-7}"

# ---- 函数 ----
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
}

# ---- 主流程 ----
# 1. 检查源目录
if [[ ! -d "$SRC_DIR" ]]; then
    echo "错误: 源目录 $SRC_DIR 不存在" >&2
    exit 1
fi

# 2. 创建备份目录（mkdir -p 幂等）
mkdir -p "$BACKUP_DIR"

# 3. 循环压缩 .log 文件
count=0
for file in "$SRC_DIR"/*.log; do
    [[ -f "$file" ]] || continue
    base=$(basename "$file" .log)
    tar czf "$BACKUP_DIR/${base}_$(date +%Y%m%d).tar.gz" -C "$SRC_DIR" "$(basename "$file")"
    ((count++))
done
log "备份完成: $count 个文件 → $BACKUP_DIR"

# 4. 清理过期备份
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +$KEEP_DAYS -delete
log "已清理 $KEEP_DAYS 天前的备份"

# 运行方式：
# ./backup_logs.sh /var/log ~/log-backups 7
# 输出示例：
# [2026-08-01 10:00:05] 备份完成: 3 个文件 → /home/alice/log-backups
# [2026-08-01 10:00:06] 已清理 7 天前的备份

独立练习：

# 练习 1：创建并运行你的第一个脚本
nano hello.sh
# 写入：#!/bin/bash
#      echo "你好，$(whoami)！今天的学习目标是什么？"
chmod +x hello.sh
./hello.sh

# 练习 2：位置参数
# 写一个 add.sh：# echo "第一个参数: $1，第二个参数: $2，参数总数: $#"
./add.sh apple banana

# 练习 3：for 循环批量改扩展名（先备份再改）
mkdir -p /tmp/demo && cd /tmp/demo
touch a.txt b.txt c.txt
for f in *.txt; do
    mv "$f" "${f%.txt}.bak"
done
ls            # a.bak b.bak c.bak

# 练习 4：综合——系统健康检查（free/df/uptime + 条件判断）
# if [[ $(free -m | awk '/Mem:/{print $7}') -lt 500 ]]; then
#     echo "警告：可用内存不足 500MB"
# fi

真实踩坑案例

# 错误写法
for file in $(ls /tmp); do
    rm $file          # 如果文件名含空格，$file 会被拆成多个参数
done

# 正确写法
for file in /tmp/*; do
    [[ -f "$file" ]] && rm "$file"   # 双引号保护空格
done

#!/bin/bash
set -e

# 期望：grep 找不到匹配时脚本退出
grep "not_exist" /etc/passwd | wc -l
echo "这行仍然会执行！"

#!/bin/bash
TMPFILE=/tmp/myapp_$$.tmp
trap "rm -f $TMPFILE" EXIT    # 错误：$TMPFILE 在定义 trap 时就被展开了

# 正确写法：用单引号延迟展开
trap 'rm -f "$TMPFILE"' EXIT

常见错误

最佳实践

练习题

1. （概念）shebang 的作用是什么？#!/bin/bash 和 #!/bin/sh 有什么区别？
2. （概念）$@ 和 $* 的区别是什么？为什么推荐使用 "$@"？
3. （实操）写一个脚本 count_files.sh，接受一个目录路径作为参数，输出该目录下的文件数量（不含子目录）。提示：ls "$1" | wc -l 或 find "$1" -maxdepth 1 -type f | wc -l。
4. （实操）写一个 for 循环脚本，把当前目录下所有 .txt 文件重命名为 .bak。要求文件名含空格时也能正确处理。
5. （实操）写一个带 set -euo pipefail 的备份脚本：接受目录参数，用 tar 打包到 ~/backups/（目录不存在则创建），完成后输出备份文件名，并用 trap 保证失败时输出错误提示。
6. （探究 🔍）在脚本开头加一行 set -x 运行，观察输出与不加的区别。理解 set -x（调试）和 set -e（严格模式）的配合使用。也可以安装 shellcheck 检查你之前写的脚本。
7. （探究 🔍）研究 source script.sh 和 ./script.sh 的执行差异（提示：$0 的值、变量是否留在当前 Shell）。在什么场景下你会故意用 source？

学习检查点

学完本章后，请检验自己是否掌握以下内容：

本章总结

Shell 脚本是 Linux 自动化的基石。本章从编写第一个 Bash 脚本开始，逐步讲解了变量（定义、引用、默认值、特殊变量）、条件判断（if/case）、循环（for/while/until）、函数、信号处理（trap）以及严格模式（set -euo pipefail）。掌握这些基础后，你就能将日常的命令行操作转化为可复用、可调度的自动化脚本。

编写健壮脚本的关键原则：① 始终使用 set -euo pipefail 严格模式；② 变量一律加双引号 "$var"；③ 用 [[ ]] 替代 [ ]；④ 用 trap 清理临时文件；⑤ 用 local 声明函数内局部变量。

速查表

下一步：进入 2.8：Shell 脚本进阶「Shell 脚本进阶」，学习数组、关联数组、进程替换、flock 加锁等高级技巧。

延伸阅读