Bash中的脚本与代码重构 - 摩柯技术社区

Bash 脚本基础

脚本结构与基本语法

Bash 脚本是一系列按顺序执行的 Bash 命令集合。一个简单的 Bash 脚本通常以 #!/bin/bash 开头，这一行被称为 shebang，它告诉系统使用 /bin/bash 来解释执行脚本中的命令。

例如，以下是一个简单的 Bash 脚本，用于输出 “Hello, World!”：

#!/bin/bash
echo "Hello, World!"

在这个脚本中，echo 是一个常用的命令，用于在标准输出上打印文本。

变量

在 Bash 脚本中，变量是非常重要的概念。变量可以存储各种类型的数据，如字符串、数字等。定义变量的语法很简单，例如：

name="John"
age=30

在引用变量时，需要在变量名前加上 $ 符号。例如：

echo "My name is $name and I am $age years old."

此外，Bash 还支持一些特殊变量，例如 $0 表示脚本本身的名称，$1、$2 等表示传递给脚本的参数。例如，创建一个名为 test.sh 的脚本：

#!/bin/bash
echo "The script name is $0"
echo "The first argument is $1"
echo "The second argument is $2"

然后在命令行中执行 ./test.sh apple banana，输出将是：

The script name is./test.sh
The first argument is apple
The second argument is banana

条件语句

条件语句允许根据不同的条件执行不同的代码块。Bash 中最常用的条件语句是 if - then - else 结构。例如：

#!/bin/bash
num=10
if [ $num -gt 5 ]; then
    echo "The number is greater than 5"
else
    echo "The number is less than or equal to 5"
fi

在这个例子中，[ $num -gt 5 ] 是一个条件测试，-gt 表示 “大于”。如果条件为真，则执行 then 后面的语句块；否则执行 else 后面的语句块。

if - then - else 结构还可以扩展为 if - elif - else 结构，用于处理多个条件。例如：

#!/bin/bash
score=75
if [ $score -ge 90 ]; then
    echo "Grade: A"
elif [ $score -ge 80 ]; then
    echo "Grade: B"
elif [ $score -ge 70 ]; then
    echo "Grade: C"
else
    echo "Grade: D"
fi

这里，-ge 表示 “大于或等于”。脚本根据 score 的值输出相应的等级。

循环语句

Bash 支持多种循环语句，如 for 循环、while 循环和 until 循环。

for 循环通常用于遍历一个列表或范围。例如，以下脚本输出 1 到 5 的数字：

#!/bin/bash
for i in 1 2 3 4 5; do
    echo $i
done

也可以使用 {1..5} 这种更简洁的方式来表示范围：

#!/bin/bash
for i in {1..5}; do
    echo $i
done

while 循环在条件为真时持续执行代码块。例如，以下脚本在 num 小于 5 时不断增加 num 并输出：

#!/bin/bash
num=1
while [ $num -lt 5 ]; do
    echo $num
    num=$((num + 1))
done

这里，$((num + 1)) 是一种算术运算的方式，用于增加 num 的值。

until 循环与 while 循环相反，它在条件为假时持续执行代码块。例如：

#!/bin/bash
num=1
until [ $num -gt 5 ]; do
    echo $num
    num=$((num + 1))
done

代码重构的重要性

代码可读性的提升

随着脚本功能的增加，代码可能会变得越来越复杂和混乱。例如，一个最初简单的文件处理脚本，随着需求的增加，可能会包含大量重复的文件操作代码，并且逻辑也变得不清晰。重构可以将这些重复代码提取出来，使用函数进行封装，使代码结构更加清晰。

假设我们有一个脚本，用于在多个目录中查找特定文件并复制到另一个目录。最初的代码可能如下：

#!/bin/bash
find /dir1 -name "*.txt" -exec cp {} /destination \;
find /dir2 -name "*.txt" -exec cp {} /destination \;
find /dir3 -name "*.txt" -exec cp {} /destination \;

这样的代码虽然可以工作，但存在重复代码。通过重构，我们可以创建一个函数来处理文件查找和复制操作：

#!/bin/bash
find_and_copy() {
    local dir=$1
    find $dir -name "*.txt" -exec cp {} /destination \;
}

find_and_copy /dir1
find_and_copy /dir2
find_and_copy /dir3

通过这种方式，代码的可读性大大提高，并且如果需要修改文件查找或复制的逻辑，只需要在函数中修改一次即可。

可维护性增强

当脚本需要修改或添加新功能时，可维护性就显得尤为重要。重构后的代码结构清晰，更容易理解和修改。例如，在上述文件处理脚本中，如果需要添加一个新的目录进行文件查找，在重构前需要复制粘贴一行 find 命令并修改目录名；而在重构后，只需要调用一次 find_and_copy 函数并传入新的目录名即可。

另外，在重构过程中，可以添加注释来解释代码的功能和逻辑。例如：

#!/bin/bash
# 函数：在指定目录中查找并复制.txt 文件到目标目录
find_and_copy() {
    local dir=$1
    # 使用 find 命令查找文件并复制
    find $dir -name "*.txt" -exec cp {} /destination \;
}

find_and_copy /dir1
find_and_copy /dir2
find_and_copy /dir3

这样，即使过了很长时间，其他开发人员（甚至是自己）也能快速理解代码的功能和修改要点。

提高代码复用性

代码复用是软件开发中的一个重要原则。通过重构，可以将一些通用的功能提取出来，形成可复用的代码块。例如，在多个脚本中可能都需要进行文件备份操作。我们可以将文件备份功能封装成一个函数，然后在不同的脚本中调用这个函数。

以下是一个简单的文件备份函数：

backup_file() {
    local source=$1
    local destination=$2
    cp $source $destination
    echo "File $source backed up to $destination"
}

在其他脚本中，可以这样调用这个函数：

#!/bin/bash
backup_file /path/to/file.txt /backup/directory

通过这种方式，不仅减少了代码的重复，还提高了开发效率。如果文件备份的逻辑需要修改，只需要在 backup_file 函数中修改一次，所有调用该函数的地方都会受到影响。

重构的常见方法

函数提取

函数提取是重构中最常用的方法之一。如前面提到的文件处理脚本，将重复的文件查找和复制操作提取成函数。一般步骤如下：

识别重复代码：仔细检查脚本，找出重复出现的代码块。这些代码块可能具有相同的功能，但在不同的地方重复出现。
定义函数：为重复代码块定义一个函数。函数名应具有描述性，能够清晰地表达函数的功能。例如，对于文件查找和复制操作，可以定义函数 find_and_copy。
参数化函数：将函数中可能变化的部分作为参数传递给函数。例如，在 find_and_copy 函数中，将查找的目录作为参数传递，这样函数可以适用于不同的目录。
替换重复代码：在脚本中找到重复的代码块，用函数调用替换它们。

下面再看一个更复杂的例子。假设我们有一个脚本，用于处理不同类型文件的统计信息：

#!/bin/bash
# 统计.txt 文件行数
find /dir1 -name "*.txt" -exec wc -l {} \; > txt_count.txt
# 统计.csv 文件行数
find /dir1 -name "*.csv" -exec wc -l {} \; > csv_count.txt
# 统计.txt 文件单词数
find /dir1 -name "*.txt" -exec wc -w {} \; > txt_word_count.txt
# 统计.csv 文件单词数
find /dir1 -name "*.csv" -exec wc -w {} \; > csv_word_count.txt

通过函数提取进行重构：

#!/bin/bash
# 统计文件行数并输出到指定文件
count_lines() {
    local file_type=$1
    local output_file=$2
    find /dir1 -name "*.$file_type" -exec wc -l {} \; > $output_file
}

# 统计文件单词数并输出到指定文件
count_words() {
    local file_type=$1
    local output_file=$2
    find /dir1 -name "*.$file_type" -exec wc -w {} \; > $output_file
}

count_lines txt txt_count.txt
count_lines csv csv_count.txt
count_words txt txt_word_count.txt
count_words csv csv_word_count.txt

变量替换

有时候，脚本中可能会出现一些硬编码的值，这些值在不同的地方使用。通过变量替换，可以将这些硬编码的值替换为变量，提高代码的灵活性。

例如，有一个脚本用于在指定目录中查找特定文件：

#!/bin/bash
find /home/user/Documents -name "report.txt"

如果这个目录经常需要修改，我们可以将目录路径定义为变量：

#!/bin/bash
target_dir="/home/user/Documents"
find $target_dir -name "report.txt"

这样，如果需要修改查找目录，只需要修改变量 target_dir 的值即可，而不需要在整个脚本中查找并修改所有使用该目录的地方。

条件逻辑简化

复杂的条件逻辑可能会使代码难以理解和维护。可以通过简化条件逻辑来重构代码。

例如，有一个脚本根据用户输入执行不同的操作：

#!/bin/bash
read -p "Enter a number (1 for action1, 2 for action2, 3 for action3): " num
if [ $num -eq 1 ]; then
    echo "Performing action1"
    # 执行 action1 的代码
elif [ $num -eq 2 ]; then
    echo "Performing action2"
    # 执行 action2 的代码
elif [ $num -eq 3 ]; then
    echo "Performing action3"
    # 执行 action3 的代码
else
    echo "Invalid input"
fi

可以使用 case - esac 结构来简化条件逻辑：

#!/bin/bash
read -p "Enter a number (1 for action1, 2 for action2, 3 for action3): " num
case $num in
    1)
        echo "Performing action1"
        # 执行 action1 的代码
        ;;
    2)
        echo "Performing action2"
        # 执行 action2 的代码
        ;;
    3)
        echo "Performing action3"
        # 执行 action3 的代码
        ;;
    *)
        echo "Invalid input"
        ;;
esac

case - esac 结构使条件逻辑更加清晰，特别是当有多个条件需要处理时。

循环优化

在脚本中，循环的性能和可读性也很重要。有时候，循环可能会包含不必要的操作或可以通过更高效的方式实现。

例如，有一个脚本用于计算 1 到 100 的和：

#!/bin/bash
sum=0
for i in {1..100}; do
    sum=$((sum + i))
    echo "Current sum: $sum"
done
echo "Final sum: $sum"

在这个脚本中，每次循环都输出当前的和，这在计算较大范围的和时可能会影响性能。如果不需要实时输出当前和，可以将输出移到循环外部：

#!/bin/bash
sum=0
for i in {1..100}; do
    sum=$((sum + i))
done
echo "Final sum: $sum"

另外，对于一些简单的数值计算，也可以使用更高效的方式。例如，计算 1 到 100 的和可以使用公式 n * (n + 1) / 2：

#!/bin/bash
n=100
sum=$((n * (n + 1) / 2))
echo "Final sum: $sum"

这样不仅提高了计算效率，还使代码更加简洁。

重构实践案例

案例背景

假设我们有一个用于管理服务器日志的脚本。该脚本最初是为了满足简单的日志清理需求而编写的，但随着服务器使用时间的增长和业务的发展，日志管理的需求变得更加复杂。最初的脚本如下：

#!/bin/bash
# 删除超过 30 天的日志文件
find /var/log -type f -name "*.log" -mtime +30 -delete

# 压缩一周内的日志文件
find /var/log -type f -name "*.log" -mtime -7 -exec gzip {} \;

# 将特定服务的日志文件移动到备份目录
find /var/log -type f -name "service1.log" -exec mv {} /backup/service1 \;
find /var/log -type f -name "service2.log" -exec mv {} /backup/service2 \;

第一次重构：函数提取

识别重复代码：脚本中有多个 find 命令，虽然功能不同，但可以将 find 命令的基本操作提取出来。
定义函数：

#!/bin/bash
# 执行 find 命令并对匹配文件执行指定操作
find_and_act() {
    local dir=$1
    local file_type=$2
    local time_criteria=$3
    local action=$4
    find $dir -type f -name "*.$file_type" $time_criteria -exec $action {} \;
}

# 删除超过 30 天的日志文件
find_and_act /var/log log -mtime +30 delete

# 压缩一周内的日志文件
find_and_act /var/log log -mtime -7 gzip

# 将特定服务的日志文件移动到备份目录
find_and_act /var/log service1.log -exec mv {} /backup/service1 \;
find_and_act /var/log service2.log -exec mv {} /backup/service2 \;

通过这次重构，代码的结构更加清晰，并且如果需要修改 find 命令的一些通用参数，只需要在 find_and_act 函数中修改即可。

第二次重构：变量替换

识别硬编码值：脚本中日志目录 /var/log 和备份目录 /backup 是硬编码的。
定义变量：

#!/bin/bash
log_dir="/var/log"
backup_dir="/backup"

# 执行 find 命令并对匹配文件执行指定操作
find_and_act() {
    local dir=$1
    local file_type=$2
    local time_criteria=$3
    local action=$4
    find $dir -type f -name "*.$file_type" $time_criteria -exec $action {} \;
}

# 删除超过 30 天的日志文件
find_and_act $log_dir log -mtime +30 delete

# 压缩一周内的日志文件
find_and_act $log_dir log -mtime -7 gzip

# 将特定服务的日志文件移动到备份目录
find_and_act $log_dir service1.log -exec mv {} $backup_dir/service1 \;
find_and_act $log_dir service2.log -exec mv {} $backup_dir/service2 \;

这样，如果服务器的日志目录或备份目录发生变化，只需要修改变量的值即可。

第三次重构：条件逻辑与循环优化

假设现在需求增加，需要处理更多服务的日志文件，并且根据文件的创建时间和文件大小进行不同的操作。例如，如果文件创建时间超过 30 天且文件大小大于 10MB，将其移动到存档目录；如果文件创建时间在一周内且文件大小小于 1MB，将其压缩并移动到临时目录。

优化条件逻辑：

#!/bin/bash
log_dir="/var/log"
backup_dir="/backup"
archive_dir="/archive"
temp_dir="/temp"

# 执行 find 命令并对匹配文件执行指定操作
find_and_act() {
    local dir=$1
    local file_type=$2
    local time_criteria=$3
    local action=$4
    find $dir -type f -name "*.$file_type" $time_criteria -exec $action {} \;
}

# 处理日志文件
process_log_files() {
    local file=$1
    local creation_time=$(stat -c %Y $file)
    local current_time=$(date +%s)
    local age=$(( (current_time - creation_time) / 86400 ))
    local size=$(stat -c %s $file)

    if [ $age -gt 30 ] && [ $size -gt 10485760 ]; then
        mv $file $archive_dir
    elif [ $age -lt 7 ] && [ $size -lt 1048576 ]; then
        gzip $file
        mv ${file}.gz $temp_dir
    fi
}

for log_file in $(find $log_dir -type f -name "*.log"); do
    process_log_files $log_file
done

通过这次重构，将复杂的条件判断封装在 process_log_files 函数中，并使用循环来处理所有匹配的日志文件，使代码更加模块化和可维护。

通过这一系列的重构，原本简单且功能有限的日志管理脚本变得更加灵活、高效和易于维护，能够更好地适应不断变化的业务需求。

重构过程中的注意事项

备份与版本控制

在进行重构之前，一定要对原始脚本进行备份。可以使用版本控制系统，如 Git，来管理脚本的版本。这样，如果在重构过程中出现问题，可以轻松回滚到原始版本。

例如，在使用 Git 时，可以先初始化一个 Git 仓库：

git init

然后将脚本添加到仓库并提交：

git add script.sh
git commit -m "Initial version of the script"

在重构过程中，每次进行重要的修改后，可以提交新的版本：

git add script.sh
git commit -m "Refactored the script by extracting functions"

如果发现重构后的脚本出现问题，可以使用 git checkout 命令回滚到之前的版本：

git checkout HEAD^ script.sh

这里 HEAD^ 表示上一个提交版本。

测试与验证

重构后必须对脚本进行全面的测试，确保其功能与重构前一致，并且没有引入新的问题。可以编写测试用例来验证脚本的功能。

例如，对于上述日志管理脚本，可以编写以下测试用例：

测试日志文件删除功能：创建一些超过 30 天的日志文件，运行脚本后检查这些文件是否被删除。
测试日志文件压缩功能：创建一些一周内的日志文件，运行脚本后检查这些文件是否被压缩。
测试文件移动功能：创建特定服务的日志文件，运行脚本后检查这些文件是否被正确移动到相应的备份目录。

可以使用 assert 函数来编写简单的测试。例如：

#!/bin/bash
assert() {
    "$@"
    local status=$?
    if [ $status -eq 0 ]; then
        echo "Test passed: $*"
    else
        echo "Test failed: $*"
    fi
    return $status
}

# 测试日志文件删除功能
touch -d "31 days ago" /var/log/test1.log
./log_management_script.sh
assert [ ! -f /var/log/test1.log ]

# 测试日志文件压缩功能
touch -d "3 days ago" /var/log/test2.log
./log_management_script.sh
assert [ -f /var/log/test2.log.gz ]

# 测试文件移动功能
touch /var/log/service1.log
./log_management_script.sh
assert [ -f /backup/service1/service1.log ]

渐进式重构

对于大型复杂的脚本，不要试图一次性完成所有的重构工作。应该采用渐进式重构的方法，逐步对脚本的不同部分进行重构。

例如，先对脚本中重复代码较多的部分进行函数提取，然后再处理变量替换、条件逻辑简化等其他重构任务。这样可以降低重构的风险，并且在重构过程中可以及时发现和解决问题。

每次完成一部分重构后，都要进行测试和验证，确保这部分重构没有对其他部分造成影响。只有当前一部分重构稳定后，再进行下一部分的重构。

通过遵循这些注意事项，可以使重构过程更加顺利，减少重构带来的风险，提高脚本的质量和可维护性。