Shell脚本编程基础与高级技巧全解析

1. Shell脚本编程基础回顾

在开始深入探讨Shell脚本编程的高级主题之前，让我们先快速回顾一下基础知识。Shell脚本本质上是一个包含一系列命令的文本文件，它能够自动化执行重复性的系统任务。想象一下，你每天都需要执行一组相同的命令来完成工作，手动输入不仅耗时还容易出错，而将这些命令写入一个脚本文件后，只需运行这个脚本就能一次性完成所有操作。

Shell脚本的第一行通常以#!/bin/bash开头，这被称为shebang或hashbang。它告诉系统应该使用哪个解释器来执行这个脚本。虽然扩展名.sh常用于标识Shell脚本，但实际上这并不是强制要求，Linux系统会根据文件内容而非扩展名来判断文件类型。

创建和运行一个简单脚本的基本步骤：

1. 使用文本编辑器（如vim、nano等）创建新文件
2. 添加shebang行和脚本内容
3. 保存文件（例如myscript.sh）
4. 赋予文件执行权限：chmod +x myscript.sh
5. 运行脚本：./myscript.sh

注意：直接运行脚本时（如./script.sh），必须确保文件有执行权限且路径正确。如果只输入script.sh，系统会在PATH环境变量指定的目录中查找该脚本，而当前目录通常不在PATH中。

2. Shell脚本中的变量与参数处理

2.1 变量定义与使用

Shell中的变量定义非常简单，不需要声明类型，直接赋值即可。变量名区分大小写，按照惯例通常使用大写字母表示常量，小写字母表示变量：

bash复制#!/bin/bash
NAME="John Doe"
AGE=30
echo "My name is $NAME and I am $AGE years old."

变量引用时需要在变量名前加$符号。如果变量名可能与其他字符混淆，可以用${}明确界定：

bash复制FILE="document"
echo "The file is ${FILE}_backup.txt"  # 明确表示FILE是变量名

2.2 特殊变量与参数传递

Shell提供了一些特殊变量用于处理脚本参数和环境信息：

• $0：脚本名称
• $1到$9：第1到第9个参数
• $#：参数个数
• $*和$@：所有参数
• $?：上一个命令的退出状态
• $$：当前脚本的进程ID

示例脚本展示参数处理：

bash复制#!/bin/bash
echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "Total arguments: $#"
echo "All arguments: $@"

运行这个脚本并传递参数：./args.sh hello world，输出将是：

code复制Script name: ./args.sh
First argument: hello
Second argument: world
Total arguments: 2
All arguments: hello world

2.3 数组操作

Shell支持一维数组，数组元素用空格分隔：

bash复制# 定义数组
FRUITS=("Apple" "Banana" "Orange")

# 访问元素
echo "First fruit: ${FRUITS[0]}"

# 获取所有元素
echo "All fruits: ${FRUITS[@]}"

# 获取数组长度
echo "Number of fruits: ${#FRUITS[@]}"

# 遍历数组
for fruit in "${FRUITS[@]}"; do
    echo "I like $fruit"
done

3. 流程控制与条件判断

3.1 if条件语句

Shell脚本中的条件判断使用if语句，基本语法如下：

bash复制if [ condition ]; then
    # commands
elif [ another_condition ]; then
    # commands
else
    # commands
fi

条件测试使用[ ]或[[ ]]（后者是bash扩展，功能更强大）。常用比较运算符：

• 数值比较：-eq（等于）、-ne（不等于）、-gt（大于）、-lt（小于）
• 字符串比较：=（等于）、!=（不等于）、-z（空字符串）
• 文件测试：-e（存在）、-f（是普通文件）、-d（是目录）

示例：

bash复制#!/bin/bash
read -p "Enter a number: " NUM

if [ $NUM -gt 100 ]; then
    echo "Number is greater than 100"
elif [ $NUM -eq 100 ]; then
    echo "Number is exactly 100"
else
    echo "Number is less than 100"
fi

3.2 case语句

对于多条件分支，case语句比多个if-elif更清晰：

bash复制#!/bin/bash
read -p "Enter your choice (start|stop|restart): " OPTION

case $OPTION in
    start)
        echo "Starting service..."
        # 启动服务的命令
        ;;
    stop)
        echo "Stopping service..."
        # 停止服务的命令
        ;;
    restart)
        echo "Restarting service..."
        # 重启服务的命令
        ;;
    *)
        echo "Invalid option!"
        exit 1
        ;;
esac

3.3 循环结构

Shell脚本支持多种循环结构：

for循环：

bash复制# 遍历列表
for i in 1 2 3 4 5; do
    echo "Number: $i"
done

# C语言风格
for ((i=1; i<=5; i++)); do
    echo "Count: $i"
done

# 遍历文件
for file in *.txt; do
    echo "Processing $file"
done

while循环：

bash复制# 基本while循环
COUNT=1
while [ $COUNT -le 5 ]; do
    echo "Count: $COUNT"
    COUNT=$((COUNT + 1))
done

# 读取文件行
while read LINE; do
    echo "Line: $LINE"
done < input.txt

until循环（与while相反，条件为假时执行）：

bash复制COUNT=1
until [ $COUNT -gt 5 ]; do
    echo "Count: $COUNT"
    COUNT=$((COUNT + 1))
done

4. 函数与代码重用

4.1 定义和调用函数

Shell脚本中的函数定义有两种形式：

bash复制# 形式1
function_name() {
    # 函数体
}

# 形式2
function function_name {
    # 函数体
}

函数示例：

bash复制#!/bin/bash

# 定义函数
greet() {
    local name=$1  # local表示局部变量
    echo "Hello, $name!"
}

# 调用函数
greet "Alice"
greet "Bob"

4.2 函数参数与返回值

函数可以接受参数，通过位置参数$1、$2等访问。函数返回值通过return语句指定（0表示成功，非0表示失败），或者通过输出返回值：

bash复制#!/bin/bash

# 计算两个数的和
add() {
    local sum=$(( $1 + $2 ))
    echo $sum  # 通过echo返回值
}

# 调用函数并捕获返回值
result=$(add 5 3)
echo "The sum is: $result"

# 检查函数执行状态
check_file() {
    if [ -f "$1" ]; then
        return 0  # 文件存在
    else
        return 1  # 文件不存在
    fi
}

check_file "/etc/passwd"
if [ $? -eq 0 ]; then
    echo "File exists"
else
    echo "File does not exist"
fi

4.3 作用域与局部变量

默认情况下，Shell函数中定义的变量是全局的。使用local关键字可以创建局部变量：

bash复制#!/bin/bash

test_scope() {
    local var1="local"  # 局部变量
    var2="global"       # 全局变量
}

test_scope
echo "var1: $var1"  # 输出空，因为var1是局部变量
echo "var2: $var2"  # 输出"global"

5. 输入输出重定向与管道

5.1 基本重定向

Shell提供了强大的I/O重定向功能：

• >：覆盖输出到文件
• >>：追加输出到文件
• <：从文件读取输入
• 2>：重定向错误输出
• &>：重定向标准输出和错误输出

示例：

bash复制# 将命令输出保存到文件
ls -l > file_list.txt

# 追加输出到文件
date >> log.txt

# 从文件读取输入
wc -l < input.txt

# 重定向错误输出
command_not_found 2> error.log

# 丢弃输出
noisy_command > /dev/null

5.2 管道操作

管道（|）将一个命令的输出作为另一个命令的输入：

bash复制# 统计当前目录下文件数量
ls | wc -l

# 查找包含特定文本的文件
grep "error" *.log | sort | uniq -c

# 复杂管道示例
ps aux | grep "httpd" | awk '{print $2}' | xargs kill -9

5.3 Here Document

Here Document是一种特殊的重定向方式，用于向命令传递多行输入：

bash复制# 基本语法
command << DELIMITER
input line 1
input line 2
...
DELIMITER

# 实际示例：向邮件发送内容
mail -s "Subject" user@example.com << EOF
Hello,

This is the content of the email.

Regards,
EOF

6. 实用技巧与最佳实践

6.1 调试技巧

调试Shell脚本的几种方法：

1. 使用-x选项运行脚本，显示执行的每一行命令：

   bash复制bash -x script.sh
   

2. 在脚本中设置调试选项：

   bash复制#!/bin/bash
   set -x  # 开启调试
   # 脚本内容
   set +x  # 关闭调试
   

3. 使用-e选项使脚本在遇到错误时立即退出：

   bash复制#!/bin/bash
   set -e  # 遇到错误立即退出
   

4. 使用-v选项打印脚本内容：

   bash复制bash -v script.sh
   

6.2 错误处理

良好的错误处理可以使脚本更健壮：

bash复制#!/bin/bash

# 检查命令是否存在
if ! command -v some_command &> /dev/null; then
    echo "Error: some_command is not installed"
    exit 1
fi

# 检查文件是否存在
if [ ! -f "important_file.txt" ]; then
    echo "Error: important_file.txt not found" >&2
    exit 1
fi

# 捕获信号
cleanup() {
    echo "Cleaning up..."
    # 清理临时文件等
    exit 1
}

trap cleanup SIGINT SIGTERM

# 主脚本逻辑
echo "Running main script..."

6.3 性能优化

提高Shell脚本性能的几个技巧：

1. 减少子shell创建：使用$(...)或反引号会创建子shell，影响性能。在循环中尤其明显。

2. 避免不必要的管道：每个管道都会创建新进程。例如：

   bash复制# 不好
   cat file.txt | grep "pattern"
   
   # 更好
   grep "pattern" file.txt
   

3. 使用内置命令而非外部命令：Shell内置命令比外部命令更快。例如：

   bash复制# 使用shell内置的字符串操作
   ${var#pattern}  # 替代sed或awk
   

4. 批量处理而非逐行处理：对于大文件，逐行处理很慢。考虑使用awk等工具批量处理。

6.4 安全考虑

编写安全的Shell脚本需要注意：

1. 引用变量防止路径名扩展和单词分割：

   bash复制# 不安全
   rm -rf $DIRECTORY/*
   
   # 安全
   rm -rf "$DIRECTORY"/*
   

2. 验证用户输入：

   bash复制read -p "Enter filename: " filename
   if [[ "$filename" =~ [^a-zA-Z0-9._-] ]]; then
       echo "Invalid filename"
       exit 1
   fi
   

3. 使用set -u检查未定义变量：

   bash复制#!/bin/bash
   set -u  # 使用未定义变量时报错
   

4. 避免将密码等敏感信息硬编码在脚本中。

7. 实际应用案例

7.1 日志分析脚本

以下脚本分析Apache访问日志，统计访问量最高的IP地址：

bash复制#!/bin/bash

# 检查参数
if [ $# -ne 1 ]; then
    echo "Usage: $0 <access_log_file>"
    exit 1
fi

LOG_FILE=$1

# 检查文件是否存在
if [ ! -f "$LOG_FILE" ]; then
    echo "Error: $LOG_FILE does not exist"
    exit 1
fi

# 统计IP访问量
echo "Top 10 IP addresses by access count:"
awk '{print $1}' "$LOG_FILE" | sort | uniq -c | sort -nr | head -10

# 统计HTTP状态码
echo -e "\nHTTP status code distribution:"
awk '{print $9}' "$LOG_FILE" | sort | uniq -c | sort -nr

# 统计最常访问的URL
echo -e "\nTop 10 requested URLs:"
awk '{print $7}' "$LOG_FILE" | sort | uniq -c | sort -nr | head -10

7.2 系统监控脚本

以下脚本监控系统资源使用情况并生成报告：

bash复制#!/bin/bash

# 定义输出文件
REPORT_FILE="system_report_$(date +%Y%m%d_%H%M%S).txt"

# 生成报告头部
echo "System Monitoring Report" > "$REPORT_FILE"
echo "Generated at: $(date)" >> "$REPORT_FILE"
echo "=================================" >> "$REPORT_FILE"

# CPU使用情况
echo -e "\nCPU Usage:" >> "$REPORT_FILE"
top -bn1 | grep "Cpu(s)" >> "$REPORT_FILE"

# 内存使用情况
echo -e "\nMemory Usage:" >> "$REPORT_FILE"
free -h >> "$REPORT_FILE"

# 磁盘空间
echo -e "\nDisk Space:" >> "$REPORT_FILE"
df -h >> "$REPORT_FILE"

# 活跃进程
echo -e "\nTop 5 Processes by CPU Usage:" >> "$REPORT_FILE"
ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%cpu | head -6 >> "$REPORT_FILE"

echo -e "\nReport generated and saved to $REPORT_FILE"

7.3 备份脚本

以下脚本实现目录的增量备份：

bash复制#!/bin/bash

# 配置变量
SOURCE_DIR="/path/to/source"
BACKUP_DIR="/path/to/backup"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
LOG_FILE="$BACKUP_DIR/backup_$TIMESTAMP.log"

# 检查源目录
if [ ! -d "$SOURCE_DIR" ]; then
    echo "Error: Source directory $SOURCE_DIR does not exist" | tee -a "$LOG_FILE"
    exit 1
fi

# 创建备份目录
mkdir -p "$BACKUP_DIR" || {
    echo "Error: Failed to create backup directory $BACKUP_DIR" | tee -a "$LOG_FILE"
    exit 1
}

# 执行rsync备份
echo "Starting backup at $(date)" | tee -a "$LOG_FILE"
rsync -avz --delete --log-file="$LOG_FILE" "$SOURCE_DIR/" "$BACKUP_DIR/latest/"

# 创建时间戳备份
cp -al "$BACKUP_DIR/latest" "$BACKUP_DIR/backup_$TIMESTAMP"

echo "Backup completed at $(date)" | tee -a "$LOG_FILE"
echo "Backup log: $LOG_FILE"

8. 高级主题与扩展

8.1 正则表达式与文本处理

Shell脚本中常用的文本处理工具：

grep - 文本搜索：

bash复制# 基本搜索
grep "pattern" file.txt

# 递归搜索
grep -r "pattern" /path/to/dir

# 显示行号
grep -n "pattern" file.txt

# 反向匹配
grep -v "pattern" file.txt

# 使用扩展正则表达式
grep -E "pattern1|pattern2" file.txt

sed - 流编辑器：

bash复制# 替换文本
sed 's/old/new/g' file.txt

# 删除行
sed '/pattern/d' file.txt

# 原地编辑（加-i选项）
sed -i 's/old/new/g' file.txt

# 多命令执行
sed -e 's/foo/bar/g' -e '/baz/d' file.txt

awk - 强大的文本处理工具：

bash复制# 打印特定列
awk '{print $1, $3}' file.txt

# 条件处理
awk '$3 > 100 {print $1, $2}' data.txt

# 计算统计
awk '{sum += $1} END {print sum}' numbers.txt

# 使用分隔符
awk -F':' '{print $1, $6}' /etc/passwd

8.2 进程管理与作业控制

Shell脚本中的进程控制：

后台运行：

bash复制# 启动后台进程
long_running_command &

# 查看后台作业
jobs

# 将后台作业调回前台
fg %1

# 继续在后台运行
bg %1

信号处理：

bash复制#!/bin/bash

# 定义信号处理函数
cleanup() {
    echo "Received signal, cleaning up..."
    # 清理代码
    exit 1
}

# 捕获信号
trap cleanup SIGINT SIGTERM

# 主脚本
echo "Running..."
sleep 60

超时控制：

bash复制# 使用timeout命令（GNU coreutils）
timeout 10s slow_command

# 如果没有timeout命令，可以这样实现
( slow_command ) & pid=$!
( sleep 10 && kill $pid ) 2>/dev/null & killer=$!
wait $pid 2>/dev/null && kill $killer

8.3 网络操作

Shell脚本中的网络相关操作：

检查网络连接：

bash复制# 检查端口是否开放
if nc -z example.com 80; then
    echo "Port 80 is open"
else
    echo "Port 80 is closed"
fi

# 检查HTTP响应
if curl -s -o /dev/null -w "%{http_code}" http://example.com | grep -q "200"; then
    echo "Website is up"
else
    echo "Website is down"
fi

下载文件：

bash复制# 使用wget
wget http://example.com/file.zip

# 使用curl
curl -O http://example.com/file.zip

# 断点续传
wget -c http://example.com/bigfile.iso

简单的HTTP服务器：

bash复制# Python 3
python3 -m http.server 8000

# 使用netcat（临时）
while true; do nc -l -p 8000 < index.html; done

8.4 国际化与本地化

使脚本支持多语言：

bash复制#!/bin/bash

# 设置语言环境
export LANG=en_US.UTF-8

# 根据语言显示不同消息
case $LANG in
    en_US*)
        MSG_HELLO="Hello"
        MSG_GOODBYE="Goodbye"
        ;;
    es_ES*)
        MSG_HELLO="Hola"
        MSG_GOODBYE="Adiós"
        ;;
    *)
        MSG_HELLO="Hello"
        MSG_GOODBYE="Goodbye"
        ;;
esac

echo "$MSG_HELLO, $USER!"
# ...
echo "$MSG_GOODBYE"

9. Shell脚本测试与质量保证

9.1 静态分析工具

使用工具检查Shell脚本语法和潜在问题：

shellcheck - Shell脚本静态分析工具：

bash复制# 安装
sudo apt install shellcheck  # Debian/Ubuntu
sudo yum install shellcheck  # CentOS/RHEL

# 使用
shellcheck script.sh

shfmt - Shell脚本格式化工具：

bash复制# 安装
go install mvdan.cc/sh/v3/cmd/shfmt@latest

# 格式化脚本
shfmt -i 4 -w script.sh  # 使用4空格缩进

9.2 单元测试

使用Shell测试框架进行单元测试：

bats - Bash自动化测试系统：

bash复制# 示例测试文件
#!/usr/bin/env bats

@test "addition using bc" {
    result="$(echo 2+2 | bc)"
    [ "$result" -eq 4 ]
}

@test "check file existence" {
    run ls /etc/passwd
    [ "$status" -eq 0 ]
}

shunit2 - 另一个Shell单元测试框架：

bash复制#!/bin/sh

testAddition() {
    result=`expr 2 + 2`
    assertEquals "2+2 should be 4" 4 "$result"
}

. /path/to/shunit2

9.3 性能测试

测量脚本执行时间和资源使用：

bash复制# 测量执行时间
time ./script.sh

# 详细性能分析
/usr/bin/time -v ./script.sh

# 使用strace跟踪系统调用
strace -c ./script.sh

10. 与其他语言的集成

10.1 调用Python代码

在Shell脚本中嵌入Python：

bash复制#!/bin/bash

# 使用here document嵌入Python代码
python3 << END
import sys
print("Python version:", sys.version)
END

# 将Python输出捕获到Shell变量
PYTHON_OUTPUT=$(python3 -c "import os; print(os.uname())")
echo "Python says: $PYTHON_OUTPUT"

# 传递Shell变量给Python
NAME="Alice"
AGE=30
python3 -c "name='$NAME'; age=$AGE; print(f'{name} is {age} years old')"

10.2 调用Perl代码

类似地调用Perl：

bash复制#!/bin/bash

# 嵌入Perl代码
perl <<'END_PERL'
    print "Hello from Perl!\n";
    my $sum = 2 + 2;
    print "2 + 2 = $sum\n";
END_PERL

# 捕获Perl输出
PERL_OUTPUT=$(perl -e 'print join(", ", @INC)')
echo "Perl include paths: $PERL_OUTPUT"

10.3 调用AWK进行复杂处理

AWK特别适合处理结构化文本：

bash复制#!/bin/bash

# 处理CSV文件
awk -F',' '
BEGIN {
    print "Processing CSV file"
    total=0
}
NR > 1 {  # 跳过标题行
    printf "Name: %-15s Age: %2d\n", $1, $2
    total += $2
}
END {
    print "---------------------"
    printf "Average age: %.1f\n", total/(NR-1)
}' data.csv

11. 跨平台兼容性

11.1 识别操作系统

编写跨平台Shell脚本的第一步是识别操作系统：

bash复制#!/bin/bash

# 检测操作系统
case "$(uname -s)" in
    Linux*)     OS=Linux;;
    Darwin*)    OS=Mac;;
    CYGWIN*)    OS=Cygwin;;
    MINGW*)     OS=MinGw;;
    *)          OS="UNKNOWN:${unameOut}"
esac

echo "Running on $OS"

# 根据操作系统执行不同命令
if [ "$OS" = "Linux" ]; then
    # Linux特定命令
    sudo apt update
elif [ "$OS" = "Mac" ]; then
    # Mac特定命令
    brew update
else
    echo "Unsupported operating system"
    exit 1
fi

11.2 处理路径差异

不同系统的路径分隔符和表示方法不同：

bash复制#!/bin/bash

# 处理路径分隔符
if [ "$OS" = "Windows" ]; then
    PATH_SEP="\\"
else
    PATH_SEP="/"
fi

# 构建路径
CONFIG_DIR="config${PATH_SEP}settings"
LOG_FILE="logs${PATH_SEP}app.log"

echo "Config directory: $CONFIG_DIR"
echo "Log file: $LOG_FILE"

11.3 兼容性工具

使用兼容性工具和命令替代方案：

bash复制#!/bin/bash

# 获取当前脚本目录（兼容各种系统）
SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)

# 兼容性date命令
if date --version &>/dev/null; then
    # GNU date
    TIMESTAMP=$(date +%Y-%m-%d)
else
    # BSD date
    TIMESTAMP=$(date -j +%Y-%m-%d)
fi

# 兼容性sed命令
if sed --version &>/dev/null; then
    # GNU sed
    sed -i 's/old/new/g' file.txt
else
    # BSD sed
    sed -i '' 's/old/new/g' file.txt
fi

12. Shell脚本的模块化与组织

12.1 源文件包含

将常用功能分离到单独文件中：

utils.sh:

bash复制#!/bin/bash

# 定义工具函数
log() {
    local level=$1
    local message=$2
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $message"
}

check_dependency() {
    if ! command -v $1 &> /dev/null; then
        log "ERROR" "Command $1 is required but not found"
        exit 1
    fi
}

主脚本中引用：

bash复制#!/bin/bash

# 包含工具文件
source utils.sh

# 使用工具函数
log "INFO" "Starting script execution"
check_dependency "curl"

12.2 函数库

创建更复杂的函数库：

lib/string.sh:

bash复制#!/bin/bash

string_trim() {
    local str="$1"
    echo "$str" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//'
}

string_contains() {
    local str="$1"
    local substr="$2"
    [[ "$str" == *"$substr"* ]]
}

string_split() {
    local str="$1"
    local delimiter="$2"
    IFS="$delimiter" read -ra array <<< "$str"
    echo "${array[@]}"
}

12.3 配置文件

使用配置文件管理设置：

config.cfg:

bash复制# 应用配置
APP_NAME="My Application"
APP_VERSION="1.0.0"

# 路径配置
LOG_DIR="/var/log/myapp"
DATA_DIR="/var/lib/myapp"

# 网络配置
API_URL="https://api.example.com"
TIMEOUT=30

主脚本中加载配置：

bash复制#!/bin/bash

# 加载配置文件
source config.cfg

# 使用配置
echo "Starting $APP_NAME version $APP_VERSION"
mkdir -p "$LOG_DIR"
curl --max-time "$TIMEOUT" "$API_URL"

13. 自动化与定时任务

13.1 使用cron定时执行

cron是Linux系统自带的定时任务工具：

bash复制# 编辑当前用户的crontab
crontab -e

# 示例crontab条目
# 每分钟执行一次脚本
* * * * * /path/to/script.sh

# 每天凌晨3点执行
0 3 * * * /path/to/nightly_backup.sh

# 每周一上午9点执行
0 9 * * 1 /path/to/weekly_report.sh

# 每月1号中午12点执行
0 12 1 * * /path/to/monthly_cleanup.sh

13.2 系统d服务

对于需要作为服务运行的脚本：

/etc/systemd/system/myservice.service:

ini复制[Unit]
Description=My Custom Service
After=network.target

[Service]
ExecStart=/path/to/myscript.sh
Restart=always
User=myuser
Group=mygroup
Environment=PATH=/usr/bin:/usr/local/bin
Environment=NODE_ENV=production
WorkingDirectory=/path/to

[Install]
WantedBy=multi-user.target

管理服务：

bash复制# 重载systemd配置
sudo systemctl daemon-reload

# 启用服务
sudo systemctl enable myservice

# 启动服务
sudo systemctl start myservice

# 查看状态
sudo systemctl status myservice

# 查看日志
journalctl -u myservice -f

13.3 文件监控与触发

使用inotifywait监控文件变化并触发脚本：

bash复制#!/bin/bash

# 监控目录并处理新文件
MONITOR_DIR="/path/to/watch"

# 安装inotify-tools（如果未安装）
if ! command -v inotifywait &>/dev/null; then
    echo "Installing inotify-tools..."
    sudo apt install inotify-tools  # Debian/Ubuntu
    # 或 sudo yum install inotify-tools  # CentOS/RHEL
fi

# 开始监控
inotifywait -m -r -e create,move,modify --format '%w%f' "$MONITOR_DIR" |
while read FILE; do
    echo "Detected change in $FILE"
    # 处理文件
    /path/to/process_file.sh "$FILE"
done

14. 图形界面与用户交互

14.1 对话框工具

使用dialog或whiptail创建文本界面：

bash复制#!/bin/bash

# 检查dialog是否安装
if ! command -v dialog &>/dev/null; then
    echo "Installing dialog..."
    sudo apt install dialog  # Debian/Ubuntu
    # 或 sudo yum install dialog  # CentOS/RHEL
fi

# 消息对话框
dialog --title "Message" --msgbox "Hello, this is a message box." 10 30

# 输入对话框
dialog --title "Input" --inputbox "Enter your name:" 10 30 2> /tmp/input.txt
NAME=$(cat /tmp/input.txt)

# 菜单选择
dialog --title "Menu" --menu "Choose an option:" 15 30 4 \
    1 "Option 1" \
    2 "Option 2" \
    3 "Option 3" 2> /tmp/menu.txt
CHOICE=$(cat /tmp/menu.txt)

# 显示结果
echo "You entered: $NAME"
echo "You chose: $CHOICE"

14.2 Zenity (GNOME)

在GNOME桌面环境中使用zenity：

bash复制#!/bin/bash

# 消息对话框
zenity --info --title="Message" --text="Hello, this is a message box."

# 输入对话框
NAME=$(zenity --entry --title="Input" --text="Enter your name:")

# 文件选择
FILE=$(zenity --file-selection --title="Select a file")

# 进度条
(
    echo "10" ; sleep 1
    echo "20" ; sleep 1
    echo "30" ; sleep 1
    echo "40" ; sleep 1
    echo "50" ; sleep 1
) | zenity --progress --title="Progress" --text="Processing..." --percentage=0

# 显示结果
echo "Name: $NAME"
echo "File: $FILE"

14.3 终端颜色与格式

增强终端输出的可读性：

bash复制#!/bin/bash

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 使用颜色
echo -e "${RED}Error: Something went wrong${NC}"
echo -e "${GREEN}Success: Operation completed${NC}"
echo -e "${YELLOW}Warning: This might not work${NC}"
echo -e "${BLUE}Info: Processing data${NC}"

# 文本样式
BOLD='\033[1m'
UNDERLINE='\033[4m'
echo -e "${BOLD}This is bold text${NC}"
echo -e "${UNDERLINE}This is underlined${NC}"

# 进度条
progress_bar() {
    local duration=${1}
    local bar_length=50
    local sleep_interval=$(echo "scale=5; $duration/$bar_length" | bc)
    
    echo -n "["
    for ((i=0; i<bar_length; i++)); do
        echo -n "#"
        sleep $sleep_interval
    done
    echo "]"
}

echo "Starting process..."
progress_bar 5
echo "Process completed"

15. 性能敏感场景优化

15.1 减少子shell创建

子shell创建是Shell脚本中的主要性能瓶颈之一：

bash复制# 不好的做法：在循环中创建多个子shell
for i in {1..1000}; do
    count=$(wc -l < file.txt)  # 每次循环都创建子shell
done

# 更好的做法：预先计算
total_lines=$(wc -l < file.txt)
for i in {1..1000}; do
    count=$total_lines  # 直接使用预先计算的值
done

# 使用shell内置字符串操作替代外部命令
# 不好
filename=$(basename "$fullpath")
extension=$(echo "$filename" | cut -d'.' -f2)

# 更好
filename=${fullpath##*/}
extension=${filename##*.}

15.2 批量处理数据

避免逐行处理大文件：

bash复制# 不好的做法：逐行读取大文件
while read line; do
    process_line "$line"
done < large_file.txt

# 更好的做法：使用awk等工具批量处理
awk '{ process($0) }' large_file.txt

# 或者将数据读入数组
mapfile -t lines < large_file.txt
for line in "${lines[@]}"; do
    process_line "$line"
done

15.3 使用更快的替代命令

了解命令的性能特点：

bash复制# 测试命令执行时间
time grep "pattern" large_file.txt
time awk "/pattern/" large_file.txt

# 字符串连接
# 慢
result=""
for i in {1..1000}; do
    result="$result$i"
done

# 快（使用数组和IFS）
parts=()
for i in {1..1000}; do
    parts+=("$i")
done
IFS=; result="${parts[*]}"

# 数学运算
#