Bash 脚本

name=$(whoami)
name=`whoami`

$ x="hello"
$ var="x"
$ echo ${!var}  # 相当于 $x
hello

$ echo "hello $(whoami)"
hello king
$ echo 'hello $(whoami)'
hello $(whoami)

$ VAR1=value1 VAR2=value2 ... command

$ echo 'echo $var' > test.sh
$ var=123
$ var=456 ./test.sh
456
$ echo $var
123

$ var=123
$ var=456 echo $var
123

#!/bin/bash
echo "脚本名 = $0"
echo "第一个参数 = $1"
echo "第二个参数 = $2"
echo "共 $# 个参数"
echo "所有参数 = $@"

$ ./test.sh f1 f2 f3
脚本名 = ./test.sh
第一个参数 = f1
第二个参数 = f2
共 3 个参数
所有参数 = f1 f2 f3

echo "Using \"\$@\":"
for arg in "$@"; do
  echo "[$arg]"
done

echo "Using \"\$*\":"
for arg in "$*"; do
  echo "[$arg]"
done

$ ./test.sh a b 'c d'
Using "$@":
[a]
[b]
[c d]
Using "$*":
[a b c d]

$ ls /temp | grep -o "file"
ls: cannot access '/temp': No such file or directory
$ ls /temp |& grep -o "file"
file

$ mkfifo mypipe
$ echo 'hello world' > mypipe

$ cat < mypipe
hello world

$ ls -l /dev/std*
lrwxrwxrwx 1 root root 15 Apr 11  2025 /dev/stderr -> /proc/self/fd/2
lrwxrwxrwx 1 root root 15 Apr 11  2025 /dev/stdin -> /proc/self/fd/0
lrwxrwxrwx 1 root root 15 Apr 11  2025 /dev/stdout -> /proc/self/fd/1
$ ls -l /proc/self
lrwxrwxrwx 1 root root 0 Apr 11  2025 /proc/self -> 6719
$ ls -l /proc/self/fd/
lrwx------ 1 king king 64 Apr 10 18:46 0 -> /dev/pts/1
lrwx------ 1 king king 64 Apr 10 18:46 1 -> /dev/pts/1
lrwx------ 1 king king 64 Apr 10 18:46 2 -> /dev/pts/1

$ a=123;(echo $a)
123
$ a=123;(a=456);echo $a
123

$ { ls /var; ls /usr; } | grep lib
lib
lib
lib64
libexec

(( i++ ))
(( --i ))
(( a = b + c ))
(( a += 2 ))
result=$(( 2**4 ))

(( a > b && c < d ))
(( a > b || c < d ))
(( !(a > b) ))

(( a = 5 & 3 ))
(( b = 5 | 3 ))
(( c = 5 ^ 3 ))

(( hex = 0xFF ))
(( oct = 077 ))
(( bin = 2#1010 ))

(( a = 5, b = 10, c = a + b ))  # 逗号分隔多个表达式

[[ "$a" == "$b" ]]      # 字符串相等	    
[[ -z "$a" ]]           # 字符串为空	    
[[ -n "$a" ]]           # 字符串非空	      
[[ "$a" =~ ^[0-9]+$ ]]  # 正则表达式匹配	

if [ -f "file1" ]; then
elif test -f "file2"; then
elif [[ -f "file3" ]]; then
elif (( a > b )); then
else
fi

echo -n "The $1 has "
case $1 in
    d*g | "cat")
        echo -n "4"
        ;;
    "man")
        echo -n "2"
        ;;
    *)
        echo -n "?"
        ;;
esac
echo " legs"

$ ./test.sh cat
The cat has 4 legs
$ ./test.sh dog
The dog has 4 legs
$ ./test.sh dooog
The dooog has 4 legs
$ ./test.sh man
The man has 2 legs
$ ./test.sh snake
The snake has ? legs

select fruit in Apple Banana Cherry "Dragon Fruit"
do
    echo "Your selected: $fruit"
    break  # 退出选择循环
done

$ ./test.sh
1) Apple
2) Banana
3) Cherry
4) Dragon Fruit
#? 2
Your selected: Banana

# 遍历简单列表
for i in 1 2 3 4 5; do
    echo "Number $i"
done

# 遍历字符串列表
for color in red green blue; do
    echo "Color is $color"
done

# 使用大括号展开
for i in {1..5}; do
    echo "Counting $i"
done

# 指定步长
for i in {1..10..2}; do
    echo "Step $i"
done

# 遍历命令输出
for file in "$(ls)"; do
    echo "File: $file"
done

# C 语言风格的 for 循环
for ((i=0; i<5; i++)); do
    echo "C-style loop: $i"
done

# 基本计数器
count=1
while [ $count -le 5 ]; do
    echo "Count: $count"
    count=$((count + 1))
done

# 读取文件内容
while read line; do
    echo "Line: $line"
done < filename.txt

# 无限循环
while true; do
    echo "Press Ctrl+C to stop"
    sleep 1
done

# 使用算术表达式
count=0
while ((count < 5)); do
    echo "Count: $count"
    ((count++))
done

# 基本计数器
count=1
until [ $count -gt 5 ]; do
    echo "Count: $count"
    count=$((count + 1))
done

# 等待某个条件满足
until ping -c1 example.com &>/dev/null; do
    echo "Waiting for example.com to be reachable..."
    sleep 5
done
echo "example.com is now reachable!"

# 语法：不加 function 也可以
function func_name() {
    commands
}

# 函数参数：使用 位置参数变量 访问，$1 $2 ...
greet() {
    echo "Hello, $1!"
}
greet "Alice"

# 返回值：使用 echo 返回一个数组
create_array() {
    local arr=(1 2 3 4 5)
    echo "${arr[@]}"
}
my_array=($(create_array))
echo "Array elements: ${my_array[@]}"

# 返回函数执行状态：使用 return（0-255），0 表示成功，大于 1 表示失败
is_number() {
    [[ "$1" =~ ^[0-9]+$ ]] && return 0 || return 1
}
is_number "123" && echo "Valid number"

# 作用域：使用 local 创建局部变量，默认是全局变量
demo() {
    local var1="local"  # 局部变量
    var2="global"       # 全局变量
}

# 递归
factorial() {
    if (( $1 <= 1 )); then
        echo 1
    else
        local prev=$(factorial $(( $1 - 1 )))
        echo $(( $1 * prev ))
    fi
}
echo "计算阶乘： 5! = $(factorial 5)"

# 调用外部函数：使用 source 引入函数库
source functions.sh

# 重定向
log_to_file() {
    echo "This is a log message"
} > output.log
# 调用函数，输出会写入output.log
log_to_file

$ touch {a,b,c}.txt
$ files=(*.txt)
$ echo ${files[@]}
a.txt  b.txt  c.txt
$ files=(*.jpg)
$ echo ${files[@]}
*.jpg

$ shopt -s nullglob
$ files=(*.jpg)
$ echo ${files[@]}   # 输出为空

IFS=$'\n' files=($(ls -1 *.txt)) # 每个文件名占一行
for f in ${files[@]}; do
    echo "处理文件: $f"
done

$ touch {'a b c',d,e}.txt
$ ./test.sh
处理文件: a b c.txt
处理文件: d.txt
处理文件: e.txt

处理文件: a
处理文件: b
处理文件: c.txt
处理文件: d.txt
处理文件: e.txt

<(cmd)   # 作为输入文件
>(cmd)   # 作为输出文件

$ ls -l <(cat)
lr-x------ 1 king king 64 Apr 12 22:01 /dev/fd/63 -> 'pipe:[521085]'
$ ls -l >(cat)
l-wx------ 1 king king 64 Apr 12 22:02 /dev/fd/63 -> 'pipe:[525267]'

示例一：tee 命令能将标准输入的数据同时向多个文件及标准输出传送
$ cat 0<<eof 1>file
foo123
bar123
eof                    # 可以看作 tee 文件1 文件2 <file >/dev/null
$ tee >(grep foo >foo.txt) >(grep bar >bar.txt) 0<file 1>/dev/null 
$ cat foo.txt
foo123
$ cat bar.txt
bar123

示例二：使用重定向发送数据到进程替换，可以看作 echo "foobar" > 文件
$ echo "foobar" 1> >(tr 'a-z' 'A-Z' >foobar.txt)
$ cat foobar.txt
FOOBAR

错误示例：后面的重定向会覆盖前面的重定向，应该使用 tee 命令（见示例一）
$ echo "foobar" 1> >(tr 'a-z' 'A-Z' >foobar.txt) 1> >(sed s/$/BAD/ >bad.txt)
$ cat foobar.txt
$ cat bad.txt
foobarBAD

示例三：可以看作 sed 参数 文件1 文件2
$ sed -e 's/foo/FOO/' -e 's/bar/BAR/' <(echo foo) <(echo bar)
FOO
BAR

printf "%q\n" "$IFS"
IFS=$' \t\n'

str="one:two:three"
IFS=:
for word in $str; do
    echo "[$word]"
done

[one]
[two]
[three]

str="one:two:three"
IFS=:
for word in "$str"; do
    echo "[$word]"
done

[one:two:three]

IFS=:
for word in one:two:three; do
    echo "[$word]"
done

[one:two:three]

IFS=: read user pass shell <<< "root:secret:/bin/bash"
echo -e "User=$user,  Passwd=$pass,  Shell=$shell"

User=root,  Passwd=secret,  Shell=/bin/bash

str="apple:banana:orange"
IFS=: arr=($str)
echo "arr[0]=${arr[0]},  arr[1]=${arr[1]},  arr[2]=${arr[2]}"

arr[0]=apple,  arr[1]=banana,  arr[2]=orange

set -- "one" "two" "three"    # set -- 用于手动设置位置参数 $1, $2, $3 ...
IFS=:
# $* 会按 IFS 的第一个字符为分隔符展开变量
echo "Using \$*: $*"
# $@ 不受 IFS 影响
echo "Using \$@: $@"

Using $*: one:two:three
Using $@: one two three

coproc NAME { command; }

#!/bin/bash

coproc data_processor {
    while read input; do
        sleep 1  # 模拟处理延迟
        echo "$input" | tr 'a-z' 'A-Z'  # 处理数据 - 这里简单转换为大写
    done
}

for i in {1..5}; do
    echo "data packet $i" >&"${data_processor[1]}"  # 非阻塞发送
done
echo "数据发送完成"

echo "干点别的事..."
sleep 3

for i in {1..5}; do
    read -t 5 response <&"${data_processor[0]}"
    echo "Received: $response"
done
echo "数据接收完成"

exec ${data_processor[0]}<&-  # 无阻塞风险也可不关闭
exec ${data_processor[1]}>&-  # 关闭协程的输入 fd，避免协进程的 read 无限等待输入（阻塞）

# 关闭文件描述符后，协进程通常会自行终止，也可 kill ${data_processor_PID}
wait $data_processor_PID     # 确保协进程正确退出并回收其资源

$ ./test.sh
数据发送完成
干点别的事...
Received: DATA PACKET 1
Received: DATA PACKET 2
Received: DATA PACKET 3
Received: DATA PACKET 4
Received: DATA PACKET 5
数据接收完成

$ bash -x script.sh

#!/bin/bash
set -x   # 开启调试
# 需要调试的代码部分
set +x   # 关闭调试

$ sleep 60 &
[1] 13492

$ jobs
[1]   Done                    sleep 60
[2]   Stopped                 sleep 600 &
[3]-  Running                 sleep 6000 &
[4]+  Running                 sleep 60000 &

$ fg      # 恢复最近的任务到前台，即带 + 号的
$ fg %2   # 恢复 2 号任务到前台

$ bg      # 让最近放入后台的任务继续运行
$ bg %2   # 让 2 号后台任务继续运行

#!/bin/bash
trap "echo '捕获到Ctrl+C';" SIGINT
echo "按Ctrl+C试试看"
sleep 10

$ ./test.sh
按Ctrl+C试试看
^C捕获到Ctrl+C