第165集：函数定义
教学目标
- 掌握Shell脚本中函数的基本定义和调用方法
- 学习函数参数的传递和处理
- 理解函数返回值的使用
- 掌握函数作用域的概念
- 学习递归函数的使用
- 能够在脚本中使用函数组织代码
主要知识点
- 函数的基本语法
- 函数的调用
- 函数参数
- 函数返回值
- 函数作用域
- 递归函数
- 函数库
实用案例分析
案例1：基本函数定义和调用
目标：学习在Shell脚本中定义和调用基本函数。
操作步骤：
- 创建基本函数演示脚本
# 创建脚本文件
touch basic-functions.sh
# 编辑脚本文件
vim basic-functions.sh
# 添加以下内容
#!/bin/bash
# 演示基本函数定义和调用
# 1. 定义无参数函数
function hello() {
echo "Hello, World!"
}
# 2. 定义带参数函数
function greet() {
echo "Hello, $1!"
}
# 3. 定义带返回值函数
function add() {
local sum=$(( $1 + $2 ))
return $sum
}
# 4. 定义使用echo返回值的函数
function multiply() {
local result=$(( $1 * $2 ))
echo $result
}
# 调用函数
echo "=== Calling functions ==="
hello
greet "Linux User"
# 调用带返回值的函数
add 5 3
add_result=$?
echo "5 + 3 = $add_result"
# 调用使用echo返回值的函数
multiply_result=$(multiply 4 6)
echo "4 * 6 = $multiply_result"
# 5. 函数的另一种定义方式
welcome() {
echo "Welcome to Shell scripting!"
}
welcome- 运行脚本并查看结果
# 设置执行权限
chmod +x basic-functions.sh
# 运行脚本
./basic-functions.sh案例2：函数参数处理
目标：学习在Shell函数中处理参数。
操作步骤：
- 创建函数参数处理演示脚本
# 创建脚本文件
touch function-params.sh
# 编辑脚本文件
vim function-params.sh
# 添加以下内容
#!/bin/bash
# 演示函数参数处理
# 1. 处理多个参数
function print_params() {
echo "Number of parameters: $#"
echo "All parameters: $*"
echo "All parameters as separate strings: $@"
# 遍历参数
echo "\nProcessing each parameter:"
local i=1
for param in "$@"; do
echo "Parameter $i: $param"
i=$((i + 1))
done
}
# 2. 处理可选参数
function greet_user() {
local name=${1:-"Guest"}
local greeting=${2:-"Hello"}
echo "$greeting, $name!"
}
# 3. 处理命名参数（使用位置参数模拟）
function create_user() {
local username=$1
local uid=$2
local gid=$3
local home=$4
echo "Creating user: $username"
echo "UID: $uid"
echo "GID: $gid"
echo "Home directory: $home"
}
# 调用函数
echo "=== Testing print_params function ==="
print_params "apple" "banana" "cherry"
echo "\n=== Testing greet_user function ==="
greet_user
greet_user "Alice"
greet_user "Bob" "Good morning"
echo "\n=== Testing create_user function ==="
create_user "john" 1001 1001 "/home/john"- 运行脚本并查看结果
# 设置执行权限
chmod +x function-params.sh
# 运行脚本
./function-params.sh案例3：函数作用域
目标：学习Shell函数的作用域规则。
操作步骤：
- 创建函数作用域演示脚本
# 创建脚本文件
touch function-scope.sh
# 编辑脚本文件
vim function-scope.sh
# 添加以下内容
#!/bin/bash
# 演示函数作用域
# 全局变量
global_var="Global variable"
# 1. 函数修改全局变量
function modify_global() {
echo "Inside modify_global:"
echo "Global var before: $global_var"
global_var="Modified global variable"
echo "Global var after: $global_var"
}
# 2. 函数使用局部变量
function use_local() {
local local_var="Local variable"
echo "Inside use_local:"
echo "Local var: $local_var"
echo "Global var: $global_var"
}
# 3. 函数中定义与全局变量同名的局部变量
function shadow_global() {
local global_var="Shadowed global variable"
echo "Inside shadow_global:"
echo "Local var (shadowing global): $global_var"
}
# 4. 函数间共享变量（通过全局变量）
function set_value() {
shared_var="Value set by set_value"
}
function get_value() {
echo "Shared var: $shared_var"
}
# 演示
echo "=== Testing function scope ==="
echo "Initial global var: $global_var"
modify_global
echo "After modify_global: $global_var"
echo "\n=== Testing local variables ==="
use_local
# 尝试访问局部变量（会失败）
echo "Outside use_local - local_var: $local_var"
echo "\n=== Testing variable shadowing ==="
echo "Global var before shadow_global: $global_var"
shadow_global
echo "Global var after shadow_global: $global_var"
echo "\n=== Testing shared variables ==="
set_value
get_value- 运行脚本并查看结果
# 设置执行权限
chmod +x function-scope.sh
# 运行脚本
./function-scope.sh案例4：递归函数
目标：学习使用递归函数解决问题。
操作步骤：
- 创建递归函数演示脚本
# 创建脚本文件
touch recursive-functions.sh
# 编辑脚本文件
vim recursive-functions.sh
# 添加以下内容
#!/bin/bash
# 演示递归函数
# 1. 计算阶乘
function factorial() {
local n=$1
if [ $n -eq 0 ] || [ $n -eq 1 ]; then
echo 1
else
local prev=$(factorial $((n - 1)))
echo $((n * prev))
fi
}
# 2. 计算斐波那契数列
function fibonacci() {
local n=$1
if [ $n -eq 0 ]; then
echo 0
elif [ $n -eq 1 ]; then
echo 1
else
local prev1=$(fibonacci $((n - 1)))
local prev2=$(fibonacci $((n - 2)))
echo $((prev1 + prev2))
fi
}
# 3. 递归遍历目录
function list_directory() {
local dir=$1
local indent=$2
for file in "$dir"/*; do
if [ -d "$file" ]; then
echo "${indent}$(basename "$file")/"
list_directory "$file" "${indent} "
else
echo "${indent}$(basename "$file")"
fi
done
}
# 演示
echo "=== Testing factorial function ==="
for i in {0..5}; do
echo "$i! = $(factorial $i)"
done
echo "\n=== Testing fibonacci function ==="
for i in {0..10}; do
echo "F($i) = $(fibonacci $i)"
done
echo "\n=== Testing directory listing function ==="
echo "Current directory structure:"
list_directory "." ""- 运行脚本并查看结果
# 设置执行权限
chmod +x recursive-functions.sh
# 运行脚本
./recursive-functions.sh案例5：函数库
目标：学习创建和使用函数库。
操作步骤：
- 创建函数库文件
# 创建函数库文件
touch utils.sh
# 编辑函数库文件
vim utils.sh
# 添加以下内容
#!/bin/bash
# 实用函数库
# 1. 日志函数
function log_info() {
echo "[INFO] $(date '+%Y-%m-%d %H:%M:%S') - $1"
}
function log_error() {
echo "[ERROR] $(date '+%Y-%m-%d %H:%M:%S') - $1" >&2
}
# 2. 文件操作函数
function file_exists() {
if [ -f "$1" ]; then
return 0
else
return 1
fi
}
function directory_exists() {
if [ -d "$1" ]; then
return 0
else
return 1
fi
}
# 3. 数学函数
function is_prime() {
local n=$1
if [ $n -le 1 ]; then
return 1
fi
for ((i=2; i*i<=n; i++)); do
if [ $((n % i)) -eq 0 ]; then
return 1
fi
done
return 0
}
# 4. 系统函数
function check_service() {
local service=$1
if systemctl is-active --quiet $service; then
echo "$service is active"
return 0
else
echo "$service is not active"
return 1
fi
}- 创建使用函数库的脚本
# 创建脚本文件
touch use-library.sh
# 编辑脚本文件
vim use-library.sh
# 添加以下内容
#!/bin/bash
# 演示使用函数库
# 导入函数库
source utils.sh
# 使用函数库中的函数
echo "=== Using function library ==="
# 使用日志函数
log_info "Starting script..."
log_info "Checking if utils.sh exists"
# 使用文件操作函数
if file_exists "utils.sh"; then
log_info "utils.sh exists"
else
log_error "utils.sh not found"
fi
# 使用数学函数
log_info "Checking if 17 is prime"
if is_prime 17; then
log_info "17 is a prime number"
else
log_error "17 is not a prime number"
fi
# 使用系统函数
log_info "Checking SSH service"
check_service ssh
log_info "Script completed"- 运行脚本并查看结果
# 设置执行权限
chmod +x use-library.sh
# 运行脚本
./use-library.sh案例6：高级函数技巧
目标：学习一些高级的函数使用技巧。
操作步骤：
- 创建高级函数技巧演示脚本
# 创建脚本文件
touch advanced-functions.sh
# 编辑脚本文件
vim advanced-functions.sh
# 添加以下内容
#!/bin/bash
# 演示高级函数技巧
# 1. 函数作为参数传递
function apply_operation() {
local operation=$1
local a=$2
local b=$3
$operation $a $b
}
function add() {
echo $(( $1 + $2 ))
}
function subtract() {
echo $(( $1 - $2 ))
}
# 2. 函数返回数组
function get_files() {
local files=($(ls -la | grep "^-" | awk '{print $9}'))
echo "${files[@]}"
}
# 3. 函数使用默认参数值
function setup_environment() {
local env=${1:-"development"}
local port=${2:-8080}
local host=${3:-"localhost"}
echo "Environment: $env"
echo "Port: $port"
echo "Host: $host"
}
# 4. 函数中的帮助信息
function complex_function() {
if [ "$1" == "--help" ] || [ "$1" == "-h" ]; then
echo "Usage: complex_function [options]"
echo "Options:"
echo " --help, -h Show this help message"
echo " --verbose, -v Enable verbose mode"
echo " --output, -o Specify output file"
return 0
fi
# 实际函数逻辑
echo "Running complex function with args: $@"
}
# 5. 函数中的错误处理
function safe_divide() {
if [ $# -ne 2 ]; then
echo "Error: Need exactly two arguments"
return 1
fi
if [ $2 -eq 0 ]; then
echo "Error: Division by zero"
return 1
fi
echo $(( $1 / $2 ))
return 0
}
# 演示
echo "=== Testing function as parameter ==="
echo "Add 5 and 3: $(apply_operation add 5 3)"
echo "Subtract 5 from 10: $(apply_operation subtract 10 5)"
echo "\n=== Testing function returning array ==="
files=($(get_files))
echo "Found ${#files[@]} files:"
for file in "${files[@]}"; do
echo "- $file"
done
echo "\n=== Testing default parameters ==="
echo "Default setup:"
setup_environment
echo "\nCustom setup:"
setup_environment "production" 80 192.168.1.1
echo "\n=== Testing help in function ==="
complex_function --help
echo "\n=== Testing error handling in function ==="
safe_divide
safe_divide 10 0
safe_divide 10 2- 运行脚本并查看结果
# 设置执行权限
chmod +x advanced-functions.sh
# 运行脚本
./advanced-functions.sh课后练习
基础练习
- 创建一个脚本，定义一个函数计算两个数的最大公约数
- 编写一个脚本，定义一个函数将字符串转换为大写
- 设计一个脚本，定义一个函数检查用户是否存在
进阶练习
- 创建一个脚本，使用递归函数计算目录大小
- 编写一个脚本，创建一个包含常用系统管理函数的函数库
- 设计一个脚本，使用函数实现一个简单的菜单系统
挑战练习
- 编写一个脚本，使用函数实现一个简单的文件加密/解密工具
- 创建一个脚本，使用递归函数实现一个文件搜索工具
- 设计一个脚本，使用函数库实现一个完整的备份系统
总结
本集详细介绍了Linux Shell脚本中的函数定义和使用方法，包括函数的基本语法、参数传递、返回值、作用域、递归函数和函数库等内容。通过学习这些知识，读者可以在Shell脚本中使用函数组织代码，提高代码的可读性和可维护性。
函数是Shell脚本编程中的重要组成部分，它允许将重复的代码块封装成可重用的单元，从而减少代码冗余，提高代码质量。掌握函数的使用是编写复杂Shell脚本的基础。
通过本集的学习，读者应该能够理解和使用基本的函数定义和调用，掌握函数参数的传递和处理，理解函数返回值的使用方法，掌握函数作用域的概念，以及学习递归函数和函数库的使用。这些知识将为后续学习数组操作、字符串处理和文件操作打下基础。