第14讲：Shell脚本编程（中）

# 正确命名
user_name="zhangsan"
_file_count=10
dirPath1="/home/user"

# 错误命名
1st_name="zhangsan"     # 不能以数字开头
my-var="hello"           # 不能包含连字符（会被解析为减法）
user name="zhangsan"     # 不能包含空格

name="野火"

# 方式1：直接赋值（不能有空格和特殊字符）
var1=hello

# 方式2：单引号 — 原样输出
var2='hello $name'      # 输出：hello $name（$name 不会被替换）

# 方式3：双引号 — 变量替换
var3="hello $name"      # 输出：hello 野火（$name 会被替换为变量的值）

readonly var="固定的值"

# 或者先定义再设置只读
name="野火"
readonly name

# 尝试修改只读变量会报错
name="新值"
# 输出：bash: name: readonly variable

# 实用场景：定义不可改变的常量
readonly PI=3.14159
readonly MAX_RETRY=3
readonly BASE_DIR="/opt/myapp"

# 整型变量：自动计算
declare -i result=10+5
echo $result            # 15（自动完成算术运算）

# 整型变量的好处：赋值字符串时自动转为 0
declare -i num
num="hello"
echo $num               # 0（字符串被转换为 0）

# 只读变量
declare -r VERSION="2.0"
VERSION="3.0"           # 报错：bash: VERSION: readonly variable

# 查看变量的属性和值
declare -p result       # 输出：declare -i result="15"

# 查看所有已声明的变量（包括类型属性）
declare

str="hello"

echo $str          # hello
echo $strBBB       # 空（Shell 认为整个 $strBBB 是变量名，但该变量不存在）
echo ${str}BBB     # helloBBB 正确：花括号明确了变量名是 str

# ${var:-default} — 提供默认值（不改原变量）
dir_name="${1:-/tmp}"          # 如果有传参就用，否则默认 /tmp
echo "目录：$dir_name"

name=""
greeting="Hello, ${name:-World}"   # name 为空，使用 World
echo $greeting               # Hello, World
echo $name                   # 仍然是空（name 本身未被修改）

# ${var:=default} — 赋值默认值（会修改原变量）
unset count
echo ${count:=0}             # 0（count 原本未定义，赋值为 0）
echo $count                  # 0（count 已被设置）

# ${var:?err_msg} — 必填校验，未定义则直接报错退出
filename="${1:?错误：缺少文件名参数}"
# 如果脚本没有传参数，输出：
# bash: 1: 错误：缺少文件名参数

# ${var:+alt_val} — 条件替换
DEBUG="true"
mode="${DEBUG:+debug mode}"  # DEBUG 非空，mode 被设置为 "debug mode"
echo $mode                   # debug mode

str="hello world"
echo ${#str}         # 11（包含空格）

str="hello world"

echo ${str:0:5}      # hello（从索引 0 开始，取 5 个字符）
echo ${str:6}        # world（从索引 6 开始，取到末尾）

# 从右边数（推荐用括号包裹负数索引）
echo ${str:(-5)}     # world（从倒数第 5 个到末尾）
echo ${str:(-5):3}   # wor（从倒数第 5 个，取 3 个字符）

path="/home/user/config.txt"

echo ${path#*/}      # home/user/config.txt（删除最短匹配：/ → 删除第一个 /）
echo ${path##*/}     # config.txt（删除最长匹配：*/ → 删除到最后一个 /）

# 实用场景：提取文件名和路径
filepath="/var/log/app.log"
filename=${filepath##*/}    # app.log（提取文件名）
dirname=${filepath%/*}      # /var/log（提取目录名）

filename="archive.tar.gz"

echo ${filename%.*}      # archive.tar（删除最短 .* 匹配 → 删掉 .gz）
echo ${filename%%.*}     # archive（删除最长 .* 匹配 → 删掉 .tar.gz）

# 实用场景：提取文件扩展名和主名
file="backup.tar.gz"
ext=${file##*.}          # gz（扩展名）
basename=${file%%.*}     # backup（去掉所有扩展名）

str="hello world, hello shell"

echo ${str/hello/hi}     # hi world, hello shell（只替换第一个）
echo ${str//hello/hi}    # hi world, hi shell（替换所有）

# 替换前缀：以某内容开头的
echo ${str/#hello/HI}    # HI world, hello shell（只替换开头匹配的）

# 替换后缀：以某内容结尾的
echo ${str/%shell/SHELL} # hello world, hello SHELL（只替换结尾匹配的）

var=`pwd`
echo $var    # 输出当前工作目录，如 /home/user

var=$(pwd)
echo $var    # 输出当前工作目录，如 /home/user

# 实用示例：获取当前日期
today=$(date +%Y-%m-%d)
echo "今天是：$today"

# 嵌套命令示例
result=$(ls $(pwd))   # $() 方式嵌套清晰

unset 变量名

name="hello"
echo $name       # hello
unset name
echo $name       # 空（变量已被删除）

#!/bin/bash
# 保存为 special_var.sh
echo "脚本名：$0"
echo "第1个参数：$1"
echo "第2个参数：$2"
echo "参数个数：$#"
echo "所有参数（字符串）：$*"
echo "当前进程PID：$$"

./special_var.sh hello world
# 脚本名：./special_var.sh
# 第1个参数：hello
# 第2个参数：world
# 参数个数：2
# 所有参数（字符串）：hello world
# 当前进程PID：5678

#!/bin/bash
# 演示 shift
echo "处理前——参数个数：$#"
echo "第一个参数：$1"

shift               # 整体左移一位
echo "处理后——参数个数：$#"
echo "第一个参数（原$2）：$1"

./test.sh a b c d
# 处理前——参数个数：4
# 第一个参数：a
# 处理后——参数个数：3
# 第一个参数（原$2）：b

#!/bin/bash
# 处理命令行选项（case 语句在下一讲详讲）
while [ $# -gt 0 ]; do
    case "$1" in
        -f) file="$2"; shift 2 ;;   # 取 -f 后面的文件名，跳过两个参数
        -v) verbose=true; shift 1 ;; # 标记 verbose，只跳一个
        *) echo "未知选项：$1"; shift 1 ;;
    esac
done

name="野火"
greeting="hello ${name} 欢迎学习Linux"
echo $greeting     # hello 野火 欢迎学习Linux

# 也可以直接写在一起
var="hello"
result="${var} world"
echo $result       # hello world

read var              # 等待用户输入，按回车后存入变量 var
echo "你输入的是：$var"

read -p "请输入你的名字：" name
echo "你好，${name}！"

请输入你的名字：张三
你好，张三！

# 用户输入会被按空格拆分，依次赋给多个变量
read -p "请输入姓名和年龄：" name age
echo "姓名：$name, 年龄：$age"

请输入姓名和年龄：张三 25
姓名：张三, 年龄：25

read -s -p "请输入密码：" password
echo          # 输出一个换行（-s 模式不会自动换行）
echo "密码已输入（${#password} 位）"

#!/bin/bash
# 方式1：管道方式（最常用，但变量修改在子 Shell 中会丢失）
cat /etc/passwd | while read -r line; do
    echo "行内容：$line"
done

# 方式2：重定向方式（推荐，避免子 Shell 问题）
while read -r line; do
    echo "行内容：$line"
done < /etc/passwd

# 方式3：按特定分隔符读取（如读取 CSV 文件）
while IFS=',' read -r col1 col2 col3; do
    echo "列1: $col1, 列2: $col2, 列3: $col3"
done < data.csv

# 基本语法：printf "格式字符串" 参数1 参数2 ...
printf "姓名：%-10s 年龄：%3d\n" "张三" 25
# 输出：姓名：张三         年龄： 25

# 与 echo 对比
echo "姓名：$name 年龄：$age"             # 简单，但格式不可控
printf "姓名：%-10s 年龄：%03d\n" "$name" "$age"   # 可精确控制列宽、补零、对齐

# %10s：宽度为 10，右对齐
# %-10s：宽度为 10，左对齐（负号表示左对齐）
# %03d：宽度为 3，不足补零

printf "|%-10s|%10s|\n" "左对齐" "右对齐"
# 输出：|左对齐       |      右对齐|

printf "编号：%03d\n" 7
# 输出：编号：007

#!/bin/bash
# 打印格式化的表格标题
printf "%-4s %-10s %-8s %-8s\n" "ID" "姓名" "科目" "分数"
printf "%-4s %-10s %-8s %-8s\n" "---" "----" "----" "----"
printf "%-4d %-10s %-8s %-8.1f\n" 1 "张三" "数学" 92.5
printf "%-4d %-10s %-8s %-8.1f\n" 2 "李四" "语文" 88.0

ID   姓名         科目     分数
---  ----         ----     ----
1    张三         数学     92.5
2    李四         语文     88.0

a=5
b=3

sum=$((a + b))       # 注意：$(( )) 内部的变量可以省略 $ 符号
echo $sum             # 8

# 正确写法
echo $((a + b))

# 也可以
echo $(($a + $b))

# 错误：不用 $(( )) 的话，结果是字符串拼接
echo a+b      # 输出：a+b（字面量，不是运算）

# 错误：普通括号无效
echo (a+b)    # 语法错误

a=5; b=3

# (( )) 作为条件测试
(( a > b )) && echo "a 大于 b"
(( a == b )) || echo "a 不等于 b"

# 在 if 中使用（下一讲详讲）
if (( a > b )); then
    echo "a is greater"
fi

# 支持 C 风格的复合赋值和自增自减
(( count++ ))
(( sum += a + b ))

a=5; b=3

# let 基本用法
let result=a+b
echo $result           # 8

# 多条表达式（逗号分隔）
let x=10 y=20 z=x+y
echo $z                # 30

# 自增自减
let count=0
let count++
echo $count            # 1

# 复合赋值（注意 let 中 * 需要转义或加引号，否则会被当作通配符）
a=5
let "a *= 3"
echo $a                # 15

# 对比：let vs (( ))
let result=a+b         # let 后直接写表达式
result=$((a + b))      # $(( )) 需要 $ 来获取值，赋值给变量
(( result = a + b ))   # (( )) 可以直接赋值（内部不需要 $）

# expr 基本用法（注意：运算符和操作数之间必须有空格）
result=$(expr 5 + 3)
echo $result           # 8

# 乘法需要用反斜杠转义 *（防止被 Shell 当作通配符）
result=$(expr 5 \* 3)
echo $result           # 15

# expr 的缺点：必须有空格、乘法必须转义、只支持整数
result=$(expr 5+3)     # 输出字面量 "5+3"
result=$(expr 5 * 3)   # Shell 会把 * 展开为当前目录的文件名

# 基本用法：管道传表达式给 bc
echo "5.5 + 3.2" | bc
# 输出：8.7

echo "10 / 3" | bc
# 输出：3（默认只保留整数）

# scale 设置小数位数
echo "scale=2; 10 / 3" | bc
# 输出：3.33

echo "scale=4; 22 / 7" | bc
# 输出：3.1428

# 多条表达式（分号分隔）
echo "scale=2; a=3.14; b=2; a * b" | bc
# 输出：6.28

# 变量赋值
result=$(echo "scale=2; 100 / 3" | bc)
echo "结果：$result"    # 结果：33.33

# 使用 here-document 传复杂表达式
result=$(bc << EOF
scale=4
x = 3.14159
y = 2.71828
x + y
EOF
)
echo $result            # 5.8598

# 基础四则运算
echo "scale=2; 10.5 + 3.2" | bc    # 13.7
echo "scale=2; 10.5 - 3.2" | bc    # 7.3
echo "scale=2; 10.5 * 3.2" | bc    # 33.60
echo "scale=2; 10.5 / 3.2" | bc    # 3.28

# 幂运算
echo "2 ^ 10" | bc                  # 1024

# 平方根
echo "scale=4; sqrt(2)" | bc        # 1.4142

# 数学库（-l 参数启用标准数学库）
echo "scale=4; s(3.14159/2)" | bc -l    # 正弦 sin(pi/2)
echo "scale=4; l(2.71828)" | bc -l      # 自然对数 ln(e)

# 创建目录成功后才进入该目录
mkdir test && cd test

# 如果目录已存在（mkdir 失败），则不执行 cd

# 尝试进入目录，失败则创建该目录
cd test || mkdir test

# 如果目录不存在（cd 失败），则创建它

# 实用示例：确保目录存在并进入
cd test || mkdir test && cd test

# 等价于：如果 cd test 失败 → 创建 test 目录 → 再进入

ls /tmp
echo $?      # 0 = 成功

ls /nonexistent
echo $?      # 2 = 失败（目录不存在）

# 方式1：括号直接定义
fruits=(apple banana orange grape)

# 方式2：逐个赋值
fruits[0]=apple
fruits[1]=banana
fruits[2]=orange
fruits[3]=grape

# 方式3：declare 声明
declare -a names=(zhangsan lisi wangwu)

# 混合赋值（索引可以不连续）
arr=([0]=10 [5]=50 [8]=80)

fruits=(apple banana orange grape)

echo ${fruits[0]}        # apple（访问第 1 个元素，索引从 0 开始）
echo ${fruits[1]}        # banana

echo ${fruits[@]}        # apple banana orange grape（所有元素，作为独立元素展开）
echo ${fruits[*]}        # apple banana orange grape（所有元素，作为一个字符串）

echo ${#fruits[@]}       # 4（数组长度——元素个数）

echo ${!fruits[@]}       # 0 1 2 3（获取所有键/索引）

#!/bin/bash
fruits=(apple banana orange grape)

# 方式1：遍历值
for item in "${fruits[@]}"; do
    echo "水果：$item"
done

# 方式2：遍历索引
for i in "${!fruits[@]}"; do
    echo "索引 $i = ${fruits[$i]}"
done

# 方式3：C 风格 for 循环（下一讲详讲）
for ((i=0; i<${#fruits[@]}; i++)); do
    echo "第 $i 个：${fruits[$i]}"
done

fruits=(apple banana orange grape)

# 追加元素
fruits+=(mango)                     # fruits 变为 5 个元素
fruits+=("pineapple" "peach")       # 一次追加多个

# 修改元素
fruits[1]=berry                     # banana 变成 berry

# 切片（取出部分元素）
echo ${fruits[@]:1:2}               # banana orange（从索引 1 开始取 2 个）

# 删除元素
unset fruits[2]                     # 删除 orange（索引 2 变成空位，数组长度不变）
unset fruits                        # 删除整个数组

# 声明关联数组（必须用 declare -A）
declare -A user

# 赋值
user[name]=zhangsan
user[age]=25
user[city]=beijing

# 访问
echo ${user[name]}          # zhangsan
echo ${user[age]}           # 25

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

# 输出：
# name = zhangsan
# age = 25
# city = beijing

# 批量定义
declare -A colors=([red]="#FF0000" [green]="#00FF00" [blue]="#0000FF")
echo ${colors[red]}         # #FF0000

fruits=(apple "big banana" orange)

# [*] 将所有元素当做一个字符串
for item in "${fruits[*]}"; do
    echo "-> $item"
done
# 输出（一次循环）：-> apple big banana orange

# [@] 将每个元素独立展开（加引号保护空格）
for item in "${fruits[@]}"; do
    echo "-> $item"
done
# 输出（三次循环）：
# -> apple
# -> big banana
# -> orange

cmd="echo hello world"
eval $cmd          # 输出：hello world
# 等价于直接执行：echo hello world

# 场景1：变量中包含重定向符
cmd="echo hello > /tmp/out.txt"
$cmd                # 输出：hello > /tmp/out.txt（> 被当作字面输出）
eval $cmd           # 真正执行了重定向，hello 被写入 /tmp/out.txt

# 场景2：间接变量引用（用变量的值作为另一个变量名）
prefix="APP"
APP_NAME="my_application"

# 想要获取 APP_NAME 的值，但只知道 prefix 变量
var_name="${prefix}_NAME"      # var_name = "APP_NAME"
echo ${!var_name}               # my_application（间接引用，Bash 4.0+）
# 或者用 eval：
eval "echo \$${var_name}"       # my_application

# 危险示例：用户输入包含恶意命令
read -p "输入文件名：" filename
# 用户输入：file.txt; rm -rf /
eval "cat $filename"
# 被执行为：cat file.txt; rm -rf /（两条命令都会执行！）

#!/bin/bash
echo "脚本 PID：$$"
echo "即将被 exec 替换..."

exec /bin/ls -la /tmp
# 从这里开始，当前 Shell 已经被 ls 替换
# 下面的代码永远不会被执行
echo "这行不会输出"

./test.sh
# 脚本 PID：12345
# 即将被 exec 替换...
# （显示 /tmp 目录内容）
# 注意：echo "这行不会输出" 确实不会执行

# 将标准输出重定向到文件（之后所有 echo 的输出都写入文件）
exec > /tmp/output.txt
echo "这条会写入文件"
echo "这条也会写入文件"
# 恢复标准输出：exec > /dev/tty

# 打开文件描述符 3 并绑定到文件
exec 3> /tmp/log.txt
echo "写入 fd 3" >&3
exec 3>&-          # 关闭 fd 3

# 从文件描述符读取
exec 3< /etc/hostname
read -r hostname <&3
exec 3<&-          # 关闭 fd 3
echo "$hostname"

# 保存原始 stdout，临时重定向到文件
exec 3>&1                     # 将 fd 3 指向原始 stdout
exec > /tmp/script.log        # 所有输出转到日志
echo "这条写入日志"
exec 1>&3                     # 恢复原始 stdout
exec 3>&-                     # 关闭 fd 3
echo "这条回到终端显示"