Linux: shell 脚本篇

set -euo pipefail

if [ 条件表达式 ]; then
    命令
elif [ 条件表达式 ]; then
    命令
else
    命令
fi

#!/bin/bash
num=5
if [ $num -gt 10 ]; then
    echo "大于10"
elif [ $num -eq 10 ]; then
    echo "等于10"
else
    echo "小于10"
fi

# 测试远程连接
test_connection() {
    log_info "测试远程连接..."
    
    local ssh_cmd="ssh -o ConnectTimeout=10 -o BatchMode=yes"
    if [[ -n "$SSH_KEY" ]]; then
        ssh_cmd+=" -i '$SSH_KEY'"
    fi
    ssh_cmd+=" '$REMOTE_HOST' 'echo 连接测试成功'"
    
    if eval "$ssh_cmd" >/dev/null 2>&1; then
        log_info "远程连接测试成功"
        return 0
    else
        log_error "远程连接失败"
        return 1
    fi
}


# 测试连接
if ! test_connection; then
    exit 1
fi

case 变量 in
    模式1)
        命令
        ;;
    模式2|模式3)
        命令
        ;;
    *)
        默认命令
        ;;
esac

#!/bin/bash
read -p "输入y或n: " ans
case $ans in
    y|Y)
        echo "你选择了YES"
        ;;
    n|N)
        echo "你选择了NO"
        ;;
    *)
        echo "输入无效"
        ;;
esac

# 语法 1 (列表):
for var in 值1 值2 值3; do
    命令
done

# 语法 2 (C 风格):
```bash
for ((i=1; i<=5; i++)); do
    命令
done

# 语法 1 (列表):
# 遍历字符串列表
for fruit in apple banana orange; do
    echo "水果：$fruit"
done
# 遍历数字范围
for num in {1..5}; do
    echo "数字：$num"
done

# 语法 2 (C 风格):
for ((i=1; i<=3; i++)); do
    echo "数字: $i"
done

while [ 条件 ]; do
    命令
done

count=1
while [ $count -le 3 ]; do
    echo "第$count次循环"
    count=$((count+1))
done

for i in {1..10}; do
    if [ $i -eq 3 ]; then
        continue  # 跳过3
    fi
    if [ $i -eq 5 ]; then
        break     # 遇到5退出
    fi
    echo "i=$i"
done

i=1
i=2
i=4

[ -f myfile.txt ] && echo "文件存在" || echo "文件不存在"

mkdir test_dir && cd test_dir || echo "创建目录失败"

echo "第一步"; echo "第二步"

# 模式匹配
[[ "hello" == h* ]] && echo "matched"  # 输出 matched  

# 正则匹配
[[ "abc123" =~ ^[a-z]+[0-9]+$ ]] && echo "regex matched"

# 写法 1
function func_name {
    commands
}

# 写法 2 (POSIX 兼容, 更通用)
func_name() {
    commands
}

greet() {
    # $1 $2 $3 … 表示位置参数  
    echo "Name: $1"
    echo "Age: $2"

    # $# 表示参数个数
    echo "Total args: $#"
    
    # $@ 表示所有参数 (保持原始分隔)
    echo "All args (\$@): $@"
    
    # $* 表示所有参数 (作为一个整体字符串)
    echo "All args (\$*): $*"
}

greet "Alice" 20

check_num() {
    if [ $1 -gt 10 ]; then
        return 0    # 成功
    else
        return 1    # 失败
    fi
}

check_num 15 && echo "OK" || echo "FAIL"

sum() {
    # 标准错误, 不是返回值, 会直接输出到控制台
    echo "sum 函数开始计算." >&2
    
    local result=$(( $1 + $2 ))
    
    # 标准输出是返回值
    echo $result
    
    echo "sum 函数结束计算." >&2
}

total=$(sum 3 5)
echo "Sum is $total"

sum 函数开始计算.
sum 函数结束计算.
Sum is 8

demo() {
    local msg="local variable"
    echo "$msg"
}

demo
echo "$msg"  # 空, 因为是局部变量

cleanup() {
    echo "Cleaning up..."
    rm -f /tmp/mytempfile
}

# 脚本退出时执行
trap cleanup EXIT  

trap 'commands' SIGNALS

# ${var} 可以明确变量的边界，避免变量名与后续字符混淆
name="world"
echo "hello $name123"    # looks for variable name123, which likely doesn't exist
echo "hello ${name}123"  # outputs hello world123

# 若 var 未定义或为空时，返回 default；否则返回 var 的值
${var:-default}

# 若 var 未定义或为空，将 var 设为 default 并返回；否则返回 var
${var:=default}

echo ${username:-"Guest"}  # 若 username 未定义，输出 Guest
username="Bob"
echo ${username:-"Guest"}  # 输出 Bob

echo ${count:=0}  # count 未定义，赋值为 0 并输出 0
echo $count       # 输出 0（变量已被赋值）

# 若 var 未定义或为空，输出 error_msg 并终止脚本；否则返回 var
${var:?error_msg}  

# 若 filename 未定义，会报错并退出
echo "处理文件: ${filename:?请指定文件名}"

# （1）从开头截取（删除最短匹配）
${var#pattern}  
# 例子: 
path="/usr/local/bin/bash"
echo ${path#*/}  # 从开头删除最短的 "*/" 匹配，输出 usr/local/bin/bash

#（2）从开头截取（删除最长匹配）
${var##pattern}  
# 例子: 
path="/usr/local/bin/bash"
echo ${path##*/}  # 从开头删除最长的 "*/" 匹配，输出 bash（获取文件名）

# （3）从结尾截取（删除最短匹配）
${var%pattern}
# 例子
file="document.txt.bak"
echo ${file%.*}  # 从结尾删除最短的 ".*" 匹配，输出 document.txt

# （4）从结尾截取（删除最长匹配）
${var%%pattern} 
# 例子
file="document.txt.bak"
echo ${file%%.*}  # 从结尾删除最长的 ".*" 匹配，输出 document

${var:offset:length}  # 从 offset 位置（0 开始）截取 length 个字符
                        # 若 length 省略，截取到结尾

str="Hello, World"
echo ${str:7:5}  # 从位置7开始截取5个字符，输出 World
echo ${str:0:5}  # 从开头截取5个字符，输出 Hello
echo ${str:7}    # 从位置7截取到结尾，输出 World

echo ${str: -5}  # 从结尾第5个字符开始截取，输出 World（注意冒号后有空格）

# （1）替换第一个匹配项
${var/pattern/replacement}  # 将 var 中第一个与 pattern 匹配的部分替换为 replacement
# 例子:
text="apple, banana, apple"
echo ${text/apple/orange}  # 替换第一个 apple，输出 orange, banana, apple


# （2）替换所有匹配项
${var//pattern/replacement}  # 将 var 中所有与 pattern 匹配的部分替换为 replacement
# 例子:
text="apple, banana, apple"
echo ${text//apple/orange}  # 替换所有 apple，输出 orange, banana, orange

${#var}  # 返回变量值的字符长度
# 例子:
name="Bash"
echo ${#name}  # 输出 4（"Bash" 有4个字符）

# 定义
arr=()                      # 定义空数组
arr=(apple banana cherry)   # 直接赋值
arr[0]="apple"              # 按索引赋值
arr[5]="orange"             # 可以跳过索引

# 追加元素
arr+=(grape mango)


# 访问元素
echo "${arr[0]}"   # apple
echo "${arr[1]}"   # banana
# 数组切片
echo "${arr[@]:1:2}"   # 从索引 1 开始取 2 个元素
# 访问所有元素
echo "${arr[@]}"   # apple banana cherry orange grape mango
echo "${arr[*]}"   # apple banana cherry orange grape mango

# 遍历数组
for item in "${arr[@]}"; do
    echo "$item"
done


# 获取数组长度
echo "${#arr[@]}"   # 元素个数
echo "${#arr[1]}"   # 第 2 个元素的字符长度

# 删除元素
arr=()              # 清空数组, 也是定义空数组
unset arr[1]        # 删除索引 1 的元素
unset arr           # 删除整个数组

# 定义
declare -A dict
dict[apple]="red"
dict[banana]="yellow"

# 访问
echo "${dict[apple]}"  # red

# 遍历
for key in "${!dict[@]}"; do
    echo "$key => ${dict[$key]}"
done

mapfile -t arr < filename.txt
# 等价于
readarray -t arr < filename.txt

env         # 显示所有环境变量
printenv    # 类似 env，通常用于脚本中
set         # 显示当前 Shell 的所有变量（包括环境变量和 Shell 变量）
echo $PATH  # 查看某个环境变量的值

# 先定义变量, 后导出为环境变量
VAR_NAME="value"
export VAR_NAME  # 让它成为环境变量

# 直接定义并导出
export VAR_NAME="value"

# 修改已有变量
export PATH=$PATH:/opt/bin

# 删除环境变量
unset VAR_NAME

echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

source 脚本文件

# 简写
. 脚本文件

# 文件 env.sh 内容
export MYVAR="Hello"
v_name="abby"

# 当前 shell 中执行
source env.sh
echo $MYVAR   # 输出 Hello
echo $v_name  # 输出 abby

command << delimiter
content
delimiter

cat << EOF
Hello, World!
This is a test.
EOF

Hello, World!
This is a test.

# 结合重定向 > 或 >> 将内容写入文件：
cat << EOF > test.txt
Line 1: Hello
Line 2: World
EOF

# 默认情况下，Heredoc 会解析变量
name="Linux"

cat << EOF
Welcome to $name tutorial.
EOF

Welcome to Linux tutorial.

cat << 'EOF'
Welcome to $name tutorial.
EOF

Welcome to $name tutorial.

read [选项] [变量1 变量2 ...]

read -p "请输入你的年龄：" age
echo "你的年龄是 $age 岁"

read -p "请输入姓名和职业（空格分隔）：" name job
echo "姓名：$name，职业：$job"

while read line; do
    echo "$line"
done < filename.txt

cat filename.txt | while read line; do 
    echo "$line"
done

# 假设 people.txt 内容是：
# Alice 30 Paris
# Bob 25 London

while read name age city
do
    echo "Name: $name, Age: $age, City: $city"
done < people.txt

while IFS=, read -r col1 col2 col3
do
    echo "Column1: $col1, Column2: $col2, Column3: $col3"
done < data.csv

[josie@MyJosie ~]$ cat script.sh
for arg in $@; do echo "[$arg]"; done
echo "----------"
for arg in "$@"; do echo "[$arg]"; done
echo "======================"
for arg in $*; do echo "[$arg]"; done
echo "----------"
for arg in "$*"; do echo "[$arg]"; done

[josie@MyJosie ~]$ ./script.sh "a b" c d
[a]
[b]
[c]
[d]
----------
[a b]
[c]
[d]
======================
[a]
[b]
[c]
[d]
----------
[a b c d]

sleep NUMBER[SUFFIX]
# s（秒，默认）, m（分钟）, h（小时）, d（天）

sleep 5        # 暂停 5 秒
sleep 0.5      # 暂停 0.5 秒（500 毫秒）
sleep 2m       # 暂停 2 分钟

long_task &  # 后台执行 long_task

(sleep 10; echo "10 秒后执行") &

# 将 标准输出和标准错误 都重定向到 output.log 文件
command >> output.log 2>&1

# Bash 4.0+ 可以用简写：
command &>> output.log