Shell脚本函数与数组实战技巧

1. Shell 函数与数组实战指南

作为一名长期与Linux打交道的运维工程师，我深刻体会到Shell脚本中函数和数组的重要性。它们就像是工具箱里的瑞士军刀，能让你的脚本从简单的命令堆砌变成真正的自动化利器。今天我就来分享一些实战中积累的经验，帮助大家掌握这两个核心特性。

在开始之前，我们先明确一点：Shell脚本中的函数和数组虽然概念简单，但要用好它们需要理解一些独特的"Shell哲学"。比如，Shell函数没有其他语言那么严格的参数检查，数组也不像Python那样灵活，但正是这些特性让Shell在系统管理领域保持着不可替代的地位。

2. Shell函数深度解析

2.1 函数定义的艺术

Shell函数的定义看似简单，但里面有不少门道。先看两种标准定义方式：

bash复制# 方式1：简洁风格
function_name() {
    commands
    [return value]
}

# 方式2：显式声明
function function_name {
    commands
}

在实际工作中，我更推荐第一种方式，原因有三：

1. 兼容性更好，所有主流Shell都支持
2. 更符合POSIX标准
3. 代码看起来更简洁

注意：虽然function关键字在某些情况下可以让代码更易读，但在Bash中其实没有实际区别。在Zsh中，使用function关键字会让函数体内的$0行为有所不同，这是需要注意的细节。

2.2 参数传递的实战技巧

Shell函数的参数传递看似简单，但有些细节容易踩坑：

bash复制#!/bin/bash
process_files() {
    local source_dir=$1
    local dest_dir=$2
    local file_pattern=${3:-*.log}  # 默认值技巧
    
    # 检查目录存在性
    [[ -d "$source_dir" ]] || { echo "源目录不存在"; return 1; }
    [[ -d "$dest_dir" ]] || mkdir -p "$dest_dir"
    
    # 处理文件
    for file in "$source_dir"/$file_pattern; do
        [ -f "$file" ] || continue  # 跳过非文件项
        cp "$file" "$dest_dir"
    done
}

# 调用示例
process_files "/var/log" "/tmp/log_backup" "*.gz"

这里有几个关键点：

1. 使用local声明局部变量是必须的，否则会污染全局命名空间
2. ${3:-*.log}提供了默认参数值，这是Shell特有的参数处理技巧
3. 使用[[ ]]代替[ ]进行条件判断，功能更强大且更安全
4. 在循环中处理文件时总是用引号包裹变量，防止空格导致的解析问题

2.3 返回值的高级用法

Shell函数只能返回0-255的整数值，这看起来是个限制，但实际上我们可以用多种方式传递结果：

bash复制#!/bin/bash
# 方式1：通过echo输出结果
get_system_info() {
    local os_name=$(uname -s)
    local os_version=$(uname -r)
    echo "$os_name $os_version"  # 返回字符串
}

# 调用并捕获输出
system_info=$(get_system_info)
echo "系统信息: $system_info"

# 方式2：通过全局变量返回多个值
parse_url() {
    declare -n result=$1  # 使用nameref引用传递
    local url=$2
    
    result[protocol]=${url%%://*}
    result[domain]=${url#*://}
    result[domain]=${result[domain]%%/*}
}

# 调用示例
declare -A url_parts
parse_url url_parts "https://example.com/path"
echo "协议: ${url_parts[protocol]}"
echo "域名: ${url_parts[domain]}"

这种技巧在处理复杂数据时特别有用，特别是结合关联数组（Bash 4.0+）可以实现类似返回对象的效果。

3. Shell数组全面掌握

3.1 数组的创建与初始化

Shell数组的创建方式多样，每种都有适用场景：

bash复制# 基本数组
files=("file1.txt" "file2.txt" "file3.txt")

# 从命令输出创建
processes=($(ps -ef | awk '{print $2}'))

# 关联数组（Bash 4.0+）
declare -A config
config["host"]="example.com"
config["port"]="8080"

# 稀疏数组（不连续索引）
sparse[0]="zero"
sparse[5]="five"

关联数组是Bash 4.0引入的强大特性，特别适合处理配置信息：

bash复制#!/bin/bash
declare -A server
server["host"]="db.example.com"
server["port"]="3306"
server["user"]="admin"
server["pass"]="secret"

connect_db() {
    mysql -h "${server[host]}" \
          -P "${server[port]}" \
          -u "${server[user]}" \
          -p"${server[pass]}" \
          "$@"
}

3.2 数组操作的高级技巧

数组切片是日常工作中经常用到的功能：

bash复制#!/bin/bash
# 数组切片示例
items=("one" "two" "three" "four" "five")

# 获取子数组（索引1到3）
echo "${items[@]:1:3}"  # 输出: two three four

# 数组拼接
first=("A" "B")
second=("C" "D")
combined=("${first[@]}" "${second[@]}")
echo "${combined[@]}"  # 输出: A B C D

# 数组过滤
numbers=(1 2 3 4 5 6)
even_numbers=($(for n in "${numbers[@]}"; do 
    [ $((n % 2)) -eq 0 ] && echo "$n"; 
done))
echo "${even_numbers[@]}"  # 输出: 2 4 6

3.3 数组与函数的结合

数组作为函数参数和返回值使用时有些特殊技巧：

bash复制#!/bin/bash
# 传递数组给函数
process_items() {
    local -n arr=$1  # nameref
    local prefix=$2
    
    for i in "${!arr[@]}"; do
        arr[$i]="${prefix}${arr[$i]}"
    done
}

# 调用示例
colors=("red" "green" "blue")
process_items colors "dark-"
echo "${colors[@]}"  # 输出: dark-red dark-green dark-blue

# 从函数返回数组
create_users() {
    local count=$1
    local users=()
    
    for ((i=1; i<=count; i++)); do
        users+=("user$i")
    done
    
    echo "${users[@]}"
}

# 捕获返回的数组
user_array=($(create_users 3))
echo "${user_array[@]}"  # 输出: user1 user2 user3

4. 调试技巧与最佳实践

4.1 系统化的调试方法

调试Shell脚本需要一套系统的方法论：

bash复制#!/bin/bash
# 调试模式开关
DEBUG=${DEBUG:-false}

# 调试日志函数
debug() {
    $DEBUG || return
    echo "[DEBUG] $(date '+%Y-%m-%d %H:%M:%S') $@" >&2
}

# 严格模式
set -euo pipefail
IFS=$'\n\t'

# 示例函数
process_data() {
    local input=$1
    debug "开始处理数据: $input"
    
    # 模拟处理
    local output=${input^^}
    sleep 1
    
    debug "处理完成: $output"
    echo "$output"
}

# 主流程
main() {
    debug "脚本启动"
    local result=$(process_data "test")
    echo "最终结果: $result"
}

# 根据DEBUG变量决定是否开启xtrace
if $DEBUG; then
    set -x
    main
    set +x
else
    main
fi

这套方法结合了多种技术：

1. 可控制的调试输出
2. 严格模式（set -euo pipefail）
3. 条件性的xtrace调试
4. 时间戳日志

4.2 常见陷阱与解决方案

Shell编程中有一些经典陷阱需要特别注意：

陷阱1：未引用的变量扩展

bash复制# 错误示范
for file in $(ls *.txt); do
    rm $file
done

# 正确做法
for file in *.txt; do
    [[ -f "$file" ]] && rm "$file"
done

陷阱2：管道中的变量修改不生效

bash复制# 错误示范
count=0
find . -name "*.txt" | while read file; do
    ((count++))
done
echo "找到 $count 个文件"  # 输出0

# 解决方案1：使用进程替换
while read file; do
    ((count++))
done < <(find . -name "*.txt")

# 解决方案2：使用临时文件
find . -name "*.txt" > tmpfile
while read file; do
    ((count++))
done < tmpfile

陷阱3：数组在函数间的传递

bash复制# 错误示范
modify_array() {
    local arr=("$@")
    arr+=("new")
}

my_array=("a" "b" "c")
modify_array "${my_array[@]}"
echo "${#my_array[@]}"  # 仍然是3

# 正确做法
modify_array() {
    local -n arr_ref=$1
    arr_ref+=("new")
}

my_array=("a" "b" "c")
modify_array my_array
echo "${my_array[@]}"  # a b c new

5. 综合实战案例

5.1 日志分析工具

让我们开发一个实用的日志分析工具，展示函数和数组的强大组合：

bash复制#!/bin/bash
# 日志分析工具

# 配置部分
declare -A config
config["LOG_DIR"]="/var/log/app"
config["REPORT_FILE"]="/tmp/log_report.txt"
config["ERROR_PATTERNS"]="ERROR|FAIL|CRITICAL"

# 初始化报告
init_report() {
    echo "日志分析报告 - $(date)" > "${config[REPORT_FILE]}"
    echo "=========================" >> "${config[REPORT_FILE]}"
}

# 分析单个日志文件
analyze_log() {
    local log_file=$1
    local -A stats
    
    # 收集统计信息
    stats["total_lines"]=$(wc -l < "$log_file")
    stats["error_lines"]=$(grep -cE "${config[ERROR_PATTERNS]}" "$log_file")
    stats["last_error"]=$(grep -E "${config[ERROR_PATTERNS]}" "$log_file" | tail -1)
    
    # 输出到报告
    {
        echo ""
        echo "文件: $log_file"
        echo "总行数: ${stats[total_lines]}"
        echo "错误行数: ${stats[error_lines]}"
        [[ -n "${stats[last_error]}" ]] && echo "最后错误: ${stats[last_error]}"
    } >> "${config[REPORT_FILE]}"
}

# 主函数
main() {
    init_report
    
    # 获取日志文件数组
    log_files=("${config[LOG_DIR]}"/*.log)
    if [[ ${#log_files[@]} -eq 0 ]]; then
        echo "未找到日志文件" >> "${config[REPORT_FILE]}"
        return 1
    fi
    
    # 并行处理日志文件
    for log in "${log_files[@]}"; do
        analyze_log "$log" &
    done
    wait
    
    echo "分析完成，报告位于: ${config[REPORT_FILE]}"
}

# 执行
main

这个案例展示了：

1. 使用关联数组存储配置
2. 函数间的协作
3. 数组用于文件处理
4. 简单的并行处理
5. 报告生成技巧

5.2 系统健康检查脚本

再来看一个更复杂的系统检查脚本：

bash复制#!/bin/bash
# 系统健康检查

declare -A checks
declare -A results

# 注册检查项
register_check() {
    checks["$1"]="$2"
}

# 执行检查
run_checks() {
    local check_name
    for check_name in "${!checks[@]}"; do
        echo "执行检查: $check_name"
        if eval "${checks[$check_name]}"; then
            results["$check_name"]="PASS"
        else
            results["$check_name"]="FAIL"
        fi
    done
}

# 生成报告
generate_report() {
    local status
    echo "系统健康检查报告"
    echo "生成时间: $(date)"
    echo "--------------------------------"
    
    printf "%-30s %-10s\n" "检查项" "状态"
    for check in "${!results[@]}"; do
        status="${results[$check]}"
        if [[ "$status" == "PASS" ]]; then
            printf "%-30s \e[32m%-10s\e[0m\n" "$check" "$status"
        else
            printf "%-30s \e[31m%-10s\e[0m\n" "$check" "$status"
        fi
    done
}

# 定义检查项
register_check "磁盘空间" "df -h | awk '\$5 > 80 {exit 1}'"
register_check "内存使用" "free -m | awk '/Mem:/ {exit \$3/\$2 > 0.8}'"
register_check "CPU负载" "uptime | awk '{exit \$NF > 1.0}'"
register_check "网络连接" "ping -c1 google.com &>/dev/null"

# 主流程
main() {
    run_checks
    generate_report
}

main

这个脚本展示了：

1. 使用关联数组实现检查项注册
2. 动态命令执行
3. 彩色报告输出
4. 灵活的检查定义机制

6. 性能优化技巧

Shell脚本虽然方便，但在处理大数据量时可能会遇到性能问题。以下是一些优化建议：

6.1 减少子进程创建

bash复制# 低效做法
for file in $(find . -name "*.txt"); do
    wc -l "$file"
done

# 高效做法
find . -name "*.txt" -exec wc -l {} +

6.2 使用内置字符串操作

bash复制# 低效做法
filename=$(basename "$path")
extension=$(echo "$filename" | awk -F. '{print $NF}')

# 高效做法
extension="${path##*.}"

6.3 数组与循环优化

bash复制# 低效做法
for i in {1..10000}; do
    echo "$i"
done

# 高效做法
numbers=({1..10000})
printf "%s\n" "${numbers[@]}"

6.4 并行处理技巧

bash复制# 并行处理示例
process_item() {
    local item=$1
    # 模拟耗时操作
    sleep 1
    echo "处理完成: $item"
}

# 准备数据
items=({1..10})

# 并行执行
for item in "${items[@]}"; do
    process_item "$item" &
done
wait

7. 跨Shell兼容性

不同的Shell实现(Bash、Zsh、Ksh等)对函数和数组的支持略有差异：

7.1 数组差异

bash复制# Bash/Zsh支持的方式
array=(1 2 3)
echo "${array[-1]}"  # 最后一个元素

# Ksh需要这样
set -A array 1 2 3
echo "${array[${#array[@]}-1]}"

7.2 函数差异

bash复制# Bash中$0是脚本名
function bash_func {
    echo "函数名: ${FUNCNAME[0]}"
}

# Zsh中$0是函数名
function zsh_func {
    echo "函数名: $0"
}

7.3 兼容性写法建议

bash复制#!/bin/sh
# 兼容性写法示例

# 数组模拟(适用于基本Shell)
array="1 2 3"
for item in $array; do
    echo "$item"
done

# 函数定义
func_name() {
    # 使用标准POSIX语法
}

# 参数处理使用$1 $2等

8. 现代Shell新特性

Bash 4.0+和Zsh引入了一些有用的新特性：

8.1 关联数组(Bash 4.0+)

bash复制declare -A user
user["name"]="Alice"
user["age"]=30

for key in "${!user[@]}"; do
    echo "$key: ${user[$key]}"
done

8.2 大小写转换(Bash 4.0+)

bash复制str="Hello World"
echo "${str^^}"  # 转大写
echo "${str,,}"  # 转小写

8.3 数组切片(Zsh)

bash复制# Zsh高级数组切片
array=(1 2 3 4 5 6 7 8 9)
echo "${array[2,5]}"  # 输出3 4 5 6
echo "${array[-3,-1]}"  # 输出7 8 9

9. 代码组织与模块化

对于大型Shell项目，良好的代码组织至关重要：

9.1 源文件包含

bash复制# 在main.sh中
source utils.sh
source config.sh

# utils.sh
common_function() {
    ...
}

9.2 命名空间模拟

bash复制# 使用前缀模拟命名空间
__logger_init() { ... }
__logger_log() { ... }
__logger_cleanup() { ... }

9.3 单元测试框架

bash复制# 简单测试框架示例
test_add() {
    result=$(add 2 3)
    [ "$result" -eq 5 ] || {
        echo "测试失败: add 2 3 返回 $result"
        return 1
    }
    return 0
}

# 运行所有测试
run_tests() {
    local passed=0 failed=0
    for test_func in $(declare -F | awk '/^declare -f test_/ {print $3}'); do
        if $test_func; then
            ((passed++))
        else
            ((failed++))
        fi
    done
    echo "通过: $passed, 失败: $failed"
    [ $failed -eq 0 ]
}

10. 安全注意事项

Shell脚本的安全问题常常被忽视：

10.1 输入验证

bash复制process_input() {
    local input=$1
    
    # 验证数字
    [[ "$input" =~ ^[0-9]+$ ]] || {
        echo "无效数字: $input"
        return 1
    }
    
    # 验证文件名
    [[ "$input" =~ ^[a-zA-Z0-9_.-]+$ ]] || {
        echo "无效文件名: $input"
        return 1
    }
}

10.2 安全执行外部命令

bash复制# 不安全做法
cmd="rm -rf $user_input"
eval "$cmd"

# 安全做法
case "$user_input" in
    safe_pattern)
        rm -rf "$user_input"
        ;;
    *)
        echo "拒绝执行危险操作"
        ;;
esac

10.3 权限控制

bash复制# 检查root权限
[[ $EUID -eq 0 ]] || {
    echo "需要root权限"
    exit 1
}

# 限制脚本权限
chmod 750 sensitive_script.sh

11. 调试复杂脚本

对于复杂脚本，需要更强大的调试技术：

11.1 使用Bash调试器(bashdb)

bash复制# 安装bashdb
sudo apt-get install bashdb

# 使用调试器
bashdb myscript.sh

11.2 跟踪函数调用

bash复制#!/bin/bash
# 跟踪函数调用
set -T
trap 'echo "调用: ${FUNCNAME[0]}" >&2' DEBUG

my_function() {
    echo "执行函数"
}

my_function

11.3 性能分析

bash复制# 使用time命令
time ./myscript.sh

# 使用xtrace进行性能分析
PS4='+ $EPOCHREALTIME '
set -x
# 脚本内容
set +x

12. 资源清理模式

脚本中的资源清理很重要：

12.1 使用trap处理信号

bash复制#!/bin/bash
# 临时文件
tempfile=$(mktemp)

# 清理函数
cleanup() {
    rm -f "$tempfile"
    echo "清理完成"
}

# 注册信号处理
trap cleanup EXIT INT TERM

# 脚本内容...

12.2 锁文件处理

bash复制lock_script() {
    local lockfile="/tmp/${0##*/}.lock"
    
    if (set -o noclobber; echo "$$" > "$lockfile") 2>/dev/null; then
        trap 'rm -f "$lockfile"; exit' EXIT
        return 0
    else
        echo "脚本已在运行(PID: $(cat "$lockfile"))"
        return 1
    fi
}

lock_script || exit 1

13. 交互式脚本增强

让脚本更友好：

13.1 用户输入处理

bash复制get_input() {
    local prompt=$1
    local default=$2
    local var_name=$3
    
    read -p "$prompt [$default]: " input
    eval "$var_name=\"\${input:-$default}\""
}

# 使用示例
get_input "请输入端口号" "8080" port
echo "将使用端口: $port"

13.2 颜色输出

bash复制# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m' # No Color

# 使用示例
echo -e "${RED}错误信息${NC}"
echo -e "${GREEN}成功信息${NC}"

13.3 进度显示

bash复制show_progress() {
    local current=$1
    local total=$2
    local width=50
    
    # 计算百分比
    local percent=$((current * 100 / total))
    # 计算进度条长度
    local progress=$((current * width / total))
    
    # 构建进度条
    local bar
    printf -v bar "%${progress}s" ""
    bar=${bar// /#}
    printf -v bar "%-${width}s" "$bar"
    
    printf "\r[%s] %3d%%" "$bar" "$percent"
    [ "$current" -eq "$total" ] && echo
}

# 使用示例
for i in {1..100}; do
    sleep 0.1
    show_progress "$i" 100
done

14. 脚本分发与安装

如何打包和分发你的脚本：

14.1 自包含脚本

bash复制#!/bin/bash
# 自解压脚本示例
ARCHIVE_START=$(awk '/^__ARCHIVE_BELOW__/ {print NR + 1; exit 0;}' "$0")

# 主脚本内容...

exit 0  # 重要：确保脚本主体不会执行存档内容
__ARCHIVE_BELOW__
# 这里开始是二进制数据

14.2 使用make安装

Makefile复制# Makefile示例
PREFIX ?= /usr/local

install:
    install -d $(DESTDIR)$(PREFIX)/bin
    install -m 755 myscript $(DESTDIR)$(PREFIX)/bin
    
uninstall:
    rm -f $(DESTDIR)$(PREFIX)/bin/myscript

14.3 打包为deb/rpm

bash复制# 简单deb包结构
mkdir -p myscript-1.0/usr/local/bin
cp myscript myscript-1.0/usr/local/bin/
mkdir -p myscript-1.0/DEBIAN
cat > myscript-1.0/DEBIAN/control <<EOF
Package: myscript
Version: 1.0
Section: utils
Priority: optional
Architecture: all
Maintainer: Your Name <your.email@example.com>
Description: My awesome shell script
EOF
dpkg-deb --build myscript-1.0

15. 持续集成与测试

自动化测试你的Shell脚本：

15.1 使用ShellCheck

bash复制# 安装
sudo apt-get install shellcheck

# 使用
shellcheck myscript.sh

15.2 编写测试用例

bash复制#!/bin/bash
# 测试框架示例
TEST_DIR=$(dirname "$(readlink -f "$0")")

run_test() {
    local test_name=$1
    local test_func=$2
    
    echo -n "运行测试: $test_name... "
    if $test_func; then
        echo "通过"
        return 0
    else
        echo "失败"
        return 1
    fi
}

# 测试示例
test_addition() {
    result=$(add 2 3)
    [ "$result" -eq 5 ]
}

# 运行所有测试
cd "$TEST_DIR" || exit 1
source ../math.sh  # 加载被测试脚本

run_test "加法测试" test_addition

15.3 集成到CI/CD

yaml复制# .gitlab-ci.yml示例
stages:
  - test

shellcheck:
  stage: test
  script:
    - shellcheck scripts/*.sh

unit_test:
  stage: test
  script:
    - cd tests && ./run_tests.sh

16. 性能敏感场景优化

当Shell脚本需要处理大量数据时：

16.1 避免管道滥用

bash复制# 低效做法
cat bigfile.txt | grep "pattern" | wc -l

# 高效做法
grep -c "pattern" bigfile.txt

16.2 使用awk处理文本

bash复制# Shell循环处理(慢)
while read line; do
    # 处理每行
done < file.txt

# awk处理(快)
awk '{print $1}' file.txt

16.3 内存映射文件

bash复制# 使用mmap加速文件访问(Bash 4.0+)
exec {fd}<file.txt
mapfile -t lines <&$fd
exec {fd}<&-

17. 跨平台兼容性

让脚本在不同Unix系统上工作：

17.1 工具路径处理

bash复制# 查找工具的标准路径
find_tool() {
    local tool=$1
    local path
    
    # 检查标准路径
    for dir in /bin /usr/bin /usr/local/bin; do
        if [ -x "$dir/$tool" ]; then
            echo "$dir/$tool"
            return 0
        fi
    done
    
    # 检查PATH
    path=$(command -v "$tool" 2>/dev/null)
    [ -n "$path" ] && echo "$path" && return 0
    
    echo "无法找到工具: $tool" >&2
    return 1
}

# 使用示例
AWK=$(find_tool awk) || exit 1

17.2 处理BSD/GNU工具差异

bash复制# 日期命令兼容性处理
if date --version &>/dev/null; then
    # GNU date
    get_timestamp() { date +%s; }
else
    # BSD date
    get_timestamp() { date -j -f "%a %b %d %T %Z %Y" "$(date)" "+%s"; }
fi

17.3 系统检测

bash复制detect_os() {
    case $(uname -s) in
        Linux*)     echo "linux" ;;
        Darwin*)    echo "macos" ;;
        FreeBSD*)   echo "freebsd" ;;
        *)          echo "unknown" ;;
    esac
}

OS=$(detect_os)

18. 错误处理模式

健壮的错误处理让脚本更可靠：

18.1 错误传播

bash复制# 严格模式
set -euo pipefail

# 错误处理函数
handle_error() {
    echo "错误发生在第 $1 行: $2" >&2
    exit 1
}

trap 'handle_error $LINENO "$BASH_COMMAND"' ERR

18.2 重试逻辑

bash复制# 带重试的函数执行
with_retry() {
    local max_attempts=$1
    local delay=$2
    shift 2
    local attempt=0
    
    while [ $attempt -lt $max_attempts ]; do
        if "$@"; then
            return 0
        fi
        attempt=$((attempt + 1))
        sleep "$delay"
    done
    
    echo "操作在 $max_attempts 次尝试后失败" >&2
    return 1
}

# 使用示例
with_retry 3 5 curl -fsSL https://example.com/api

18.3 日志记录

bash复制# 日志记录函数
log() {
    local level=$1
    local message=$2
    local timestamp=$(date +"%Y-%m-%d %T")
    
    echo "[$timestamp] [$level] $message" >> "$LOG_FILE"
    
    case $level in
        ERROR) echo -e "\033[0;31m$message\033[0m" >&2 ;;
        WARN)  echo -e "\033[0;33m$message\033[0m" >&2 ;;
        *)     echo "$message" ;;
    esac
}

# 使用示例
log INFO "脚本启动"
log ERROR "发生错误"

19. 高级I/O处理

提升脚本的输入输出能力：

19.1 文件描述符高级用法

bash复制# 使用额外的文件描述符
exec 3<> lockfile
flock -x 3 || {
    echo "无法获取锁"
    exit 1
}

# 主脚本内容...

# 释放锁
flock -u 3
exec 3>&-

19.2 进程替换

bash复制# 比较两个命令的输出
diff <(command1) <(command2)

# 同时处理多个流
paste <(cmd1) <(cmd2) > output.txt

19.3 网络通信

bash复制# 简单的HTTP请求
http_get() {
    local host=$1
    local path=$2
    exec 3<>/dev/tcp/$host/80
    printf "GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n" "$path" "$host" >&3
    cat <&3
    exec 3>&-
}

# 使用示例
http_get example.com "/"

20. 脚本自检与文档

让脚本更易于维护：

20.1 嵌入文档

bash复制#!/bin/bash
#: <<'DOCUMENTATION'
# 脚本名称: system_report
# 用途: 生成系统健康报告
# 参数:
#   --verbose  显示详细输出
#   --output   指定输出文件
# 示例:
#   system_report --verbose --output /tmp/report.txt
#DOCUMENTATION

# 解析帮助参数
if [[ "$1" == "--help" ]]; then
    sed -n '/^#:/,/^DOCUMENTATION$/ p' "$0" | sed '1d;$d' | cut -c3-
    exit 0
fi

20.2 参数解析框架

bash复制# 高级参数解析
parse_args() {
    while [[ $# -gt 0 ]]; do
        case $1 in
            -v|--verbose)
                VERBOSE=true
                shift
                ;;
            -o|--output)
                OUTPUT_FILE=$2
                shift 2
                ;;
            *)
                echo "未知参数: $1" >&2
                exit 1
                ;;
        esac
    done
}

# 使用示例
parse_args "$@"

20.3 版本检查

bash复制# 检查Bash版本
if ((BASH_VERSINFO[0] < 4)); then
    echo "需要Bash 4.0或更高版本" >&2
    exit 1
fi

# 检查依赖工具
check_deps() {
    local deps=("jq" "curl" "awk")
    local missing=()
    
    for dep in "${deps[@]}"; do
        if ! command -v "$dep" &>/dev/null; then
            missing+=("$dep")
        fi
    done
    
    if [[ ${#missing[@]} -gt 0 ]]; then
        echo "缺少依赖: ${missing[*]}" >&2
        return 1
    fi
    return 0
}

21. 脚本国际化

支持多语言的脚本：

21.1 多语言支持框架

bash复制#!/bin/bash
# 设置语言
LANG=${LANG:-en_US.UTF-8}

# 翻译函数
translate() {
    local msgid=$1
    case $LANG in
        zh_CN*)
            case "$msgid" in
                "Hello") echo "你好" ;;
                "Goodbye") echo "再见" ;;
                *) echo "$msgid" ;;
            esac
            ;;
        *)
            echo "$msgid"
            ;;
    esac
}

# 使用示例
echo "$(translate "Hello"), $(translate "World")"

21.2 日期时间本地化

bash复制# 根据语言环境格式化日期
localized_date() {
    case $LANG in
        zh_CN*)
            date "+%Y年%m月%d日 %H时%M分"
            ;;
        en_US*)
            date "+%B %d, %Y %I:%M %p"
            ;;
        *)
            date -R
            ;;
    esac
}

21.3 数字格式化

bash复制# 本地化数字格式
format_number() {
    local number=$1
    case $LANG in
        zh_CN*)
            echo "$number" | awk '{printf "%\047d\n", $0}'
            ;;
        en_US*)
            echo "$number" | sed ':a;s/\B[0-9]\{3\}\>/,&/;ta'
            ;;
        *)
            echo "$number"
            ;;
    esac
}

# 使用示例
format_number 1234567  # 输出1,234,567或1'234'567

22. 脚本性能监控

监控脚本自身的性能：

22.1 执行时间统计

bash复制# 脚本执行时间跟踪
start_time=$(date +%s.%N)

# 主脚本内容...

end_time=$(date +%s.%N)
elapsed=$(printf "%.2f" $(echo "$end_time - $start_time" | bc))
echo "脚本执行时间: ${elapsed}秒"

22.2 内存使用监控