Bash - 个人参考手册

$ echo \\ \* \. \? \& \|
\ * . ? & |

# m 和 a 不是特殊字符, \ 转义没有效果，但也从结果中删除。
$ echo \msd \asd
msd asd
$

# \ 必须紧接着换行，这时换行会被删除（不是替换为一个空格）
$ echo abc\
> def
abcdef

$ echo afb cdf 'dfd''dfd'
afb cdf dfddfd

# \ 必须紧接着换行，中间不能有空格
$ echo abf cdf 'asdf'\
> 'dfd'
abf cdf asdfdfd

# \换行 只是起着下一行连接作用，前后的空格会被整合为一个
$ echo abc  \
>    asdfa\
>   asdf  \
>     asdf
abc asdfa asdf asdf
$ echo abc \
> "    asdfa"\
>   asdf \
>     "asfa  "
abc     asdfa asdf asfa

# 有空格的字符串需要转义
$ echo abc\ bcd |{ read var; echo "#$var#"; }
#abc bcd#

$ var="asdaf""afsdafs"
$ echo $var
asdafafsdafs

$ var="addf"\
> "afasdf"
$ echo $var
addfafasdf

# 字符串间不能有空格
$ var=asdfa\
>   asdfas
bash: asdfas: 未找到命令

$ var=asdfa\
> "asdf"
$ echo $var
asdfaasdf

$ var="asdaf"\ "afsdafs"
$ echo $var
asdaf afsdafs

$ var=asdf\ asdfasdfa
$ echo $var
asdf asdfasdfa

$ echo 'asdf
> asdfa
> asdfas
> '
asdf
asdfa
asdfas

$ echo "asdfa
> asdfa
> "
asdfa
asdfa

$ echo "asdfa\
asdfasdf\
asdfasdf\
asdfasdf"
asdfaasdfasdfasdfasdfasdfasdf

$ echo a \
> b
A b

$ echo 'asdfasd\
> asdfasd\
> asdfas\
> asdfa'
asdfasd\
asdfasd\
asdfas\
asdfa
$

# echo 支持 -e 选项，这时会将字符串中的转义字符按照 printf 的语义来解释。
$ echo -e "asdfasdf \ asdfasdf\nasdfasdf"
asdfasdf \ asdfasdf
asdfasdf
$

# \ 后是空格+换行, shell 不会连行
$ echo "asdfasdfa \
> asdfasd
> asdfasdf"
asdfasdfa \
asdfasd
asdfasdf

# \ 后必须紧跟换行, shell 才会连行
$ echo "asdfasdf \
> asfasdfa
> asdfadsfasdf"
asdfasdf asfasdfa
asdfadsfasdf
$

# 直接转义单引号
$ echo fa\'
fa'

# 单引号中 \ 是普通字符，不具有转义功能
$ echo 'asda
> asdfas \
> sdfa'
asda
asdfas \
sdfa

$ echo 'asdfa\basdfa'
asdfa\basdfa

# 由于单引号中 \ 不具有特殊含义，所以第一个 \' 会原样打印 \，同时与第一个 ' 匹配，
# 表示单引号字符串结束。由于第三个 ' 没有结束匹配单引号，所以提示继续输入。
$ echo 'asdfa\b\'asdfa'
> cd'
asdfa\b\asdfa
cd

# 第一个单引号字符串到 \'f 前结束，然后 a\' 表示对 ' 转义。
$ echo 'asd\a\'fa\'asdfa'asda'
asd\a\fa'asdfaasda

# 多行字符串，\newline 会删除\和换行符, 实现字符串连接
$ echo "asdfa
> aaa\
> bbb\n" # \n 不具有特殊含义，原样输出
asdfa
aaabbb\n

# 转义空格, 结果为一个 field.
$ set -- space\ space2
$ echo $#
1

# 双引号中，非 $ ` " \ newline 字符前，\ 原样输出。
$ echo "space\ space2"
SPACE\ space2

# 双引号中，!word 表示命令历史记录
$ echo "aszdafsd !. abc"
echo "aszdafsd ./target/debug/apsarabot  abc"
aszdafsd ./target/debug/apsarabot  abc
$ echo "asdfa !asdf"
bash: !asdf": event not found
$ echo "asdfas !_sdfa"
bash: !_sdfa: event not found
$ echo "asdfa !.abc"
bash: !.abc: event not found
$ echo "adfa !{sdf}"
bash: !{sdf}: event not found

# 如果 ！后是空格，则不具有命令历史 event 的含义，原样输出
$ echo 'asdfa ! asdf'
asdfa ! asdf

# \ 转义 !, 结果中 \ 不被删除（特殊情况）。
$ echo "asfa \!asdf"
asfa \!asdf

zj@a:~/docs$ echo -e 'ab\tcd\nd'
ab      cd
d
zj@a:~/docs$ echo -e "ab\tcd\nd"
ab      cd
d
zj@a:~$ echo -e 'asdfa\
>  asdfa\t\nasdf'
asdfa\
 asdfa
asdf

# 字符串被 shell 处理后再传给 echo
zj@a:~$ var=vvvv
zj@a:~$ echo -e "${var} \!.abc"
vvvv \!.abc

# 双引号中原样输出
$ echo  "abcd\t\r\nd"
abcd\t\r\nd
# 按照转义字符来解释
$ echo -e  "abcd\t\r\nd"
abcd
d
# 非有效的转义字符被原样输出
$ echo -e  "abcd\t\r\nd\x"
abcd
d\x

$ echo $'asdfa\tasdfa\nasda'
asdfa   asdfa
asda

# 只能使用单引号。
$ echo $"asdfa\tasdfa\nasda"
asdfa\tasdfa\nasda

# $var 变量并不会被替换
$ var=var
$ echo $'$var\tasda'
$var    asda

# 单引号中的 \ 是普通字符，不具有转义含义
$ echo 'asdfa\'asdfa'asda'
asdfa\asdfaasda

# 普通单引号中不能使用 \' 来转义单引号本身。
$ echo 'asdfa\'asdfa'
> bash: unexpected EOF while looking for matching `''
bash: syntax error: unexpected end of file

# 但是转义字符串中的 \ 具有特殊含义，可以用来转义单引号
$ echo $'asda\'asda'
asda'asda

$ cat yy
echo $#
for i in "$@"; do
  echo $i
done

$ ./yy $date
0

$ ./yy $(date)
6
一
10
17
10:48:15
CST
2022

$ ./yy "$(date)"
1
一 10 17 10:48:21 CST 2022
$

# 变量替换后再进行 filename 扩展。使用双引号可以避免文件名扩展。
$ a=$(echo  "/*")
$ echo "$a"
/*

$ echo $a
/Applications /Library /System /Users /Volumes /bin /cores /dev /etc /home /opt /private /sbin /tmp /usr /var
$

$ msg=$(printf "a: %s\nb: %s" "abc" "def")
# 未被分词，字符串中的换行还保留
$ echo -e "${msg}"
a: abc
b: def
# 被分词后，换行被转换为空格
$ echo -e ${msg}
a: abc b: def

$ aa=$(echo zhang jun)
$ echo $aa
zhang jun

# 变量赋值的 VALUE 也不会被 filename expansion, 所以也不需要加双引号:
$ bb=/*
$ echo "$bb"
/*
# 变量替换后,由于没有双引号包围，所以会进行 filename expansion 和 word splitting
$ echo $bb
/Applications /Library /System /Users /Volumes /bin /cores /dev /etc /home /opt /private /sbin /tmp /usr /var
$

foo "$(bar "$(baz "$(ban "bla")")")"

$ v1=value1
# 在 dup subshell 中执行  echo a" bc "d $v1 命令。
# $(xx) 中 xx 的双引号不需要转义，会被无差别的传给 sub shell 来解释和执行。
$ res="$(echo a" bc "d $v1)"  # subshell 中可以使用 v1 变量
$ echo $res
a bc d value1

# 在 dup subshell 中执行 echo a" bc "d "$v1"
$ res="$(echo a" bc "d "$v1")"
$ echo $res
a bc d value1

# 在 dup subshell 中执行 echo a" bc "d '$v1'
# 这也说明了对于 $(xx) 中的 xx 的处理和解释是完全在 sub shell 中进行的。
$ res="$(echo a" bc "d '$v1')"
$ echo $res
a bc d $v1

# $() 中的内容被原样传给 dup sub shell
$ echo "$(echo \"ab"c")"
"abc
$ pwd
/var
$ echo "$(realpath $(dirname "./spool"))"
/var

$ read name tag <<< $(echo "zhang4 jun4")
$ echo $name
zhang4
$ echo $tag
jun4

# shell 不对 here string 的内容进行分词, 所以外围的双引号是可选的。
$ read name tag <<< "$(echo "zhang5 jun5")"
$ echo $name
zhang5
$ echo $tag
jun5

$ echo adfasdf & >/dev/null # >/dev/null 重定向的是第二个空命令
[32528] 1
adfasdf
[1]+  Done                    echo adfasdf

# 重定向只是针对最后一个 echo 命令
$ echo abc; echo bcd; echo cde >out
abc
bcd
$

# 对命令列表整体做重定向。
$ { echo abc; echo bcd; echo cde; } > out

# 重定向操作符位于 simple command 范围内即可，位置任意。
$ echo ab ; > /dev/null echo cd
ab
$

# 输入重定向被 shell 执行后删除，应用不感知；
$ bash -c 'echo "$#" "$@"' a b c d </dev/null 3</dev/null e f
5 b c d e f
$

$ >/dev/null  # 单独使用

# 错误
$ ;;
bash: syntax error near unexpected token `;;'
$ ; ;
bash: syntax error near unexpected token `;'
$ echo ;;
bash: syntax error near unexpected token `;;'
$ echo ; | echo
bash: syntax error near unexpected token `|'
$ echo ; &
bash: syntax error near unexpected token `&'
$ echo fff  &| cat -
bash: syntax error near unexpected token `|'

# 正确
$ echo ; echo;

$ echo abc | echo bcd ; | echo def & | echo fff
bash: syntax error near unexpected token `|'
$

$ echo abcd |& cat
# 等效于, 因为 shell 优先对 pipeline 重定向，所以 2>&1 中的 &1 是 pipeline
$ echo abcd 2>&1 | cat

$ cmd1 3>&1 1>&2 2>&3- | echo -

$ echo test test >test
$ echo abc </dev/null | cat <&3 | echo bcd >/dev/null | echo cde |cat - 3<./test
bash: 3: Bad file descriptor
cde
$ echo abc </dev/null | cat 3<./test  <&3 | echo bcd >/dev/null | echo cde |cat -
cde
$

$ date; echo abc </dev/null | mybad | exit 4 | sleep 5 | echo bcd >/dev/null | echo cde | exit 6; echo $?; date
Sat 20 Aug 2022 05:04:52 PM CST
mybad: command not found
6
Sat 20 Aug 2022 05:04:57 PM CST
$

# 在子命令中 cd 的目录及设置的环境变量，calling shell 不感知：
$ echo a | (cd /tmp; pwd) |cat - && pwd
/tmp
/root

# 默认，pipeline 形式上最后一个命令的退出码作为 pipeline 的退出码
$ echo a | grep ff | cat -
$ echo $?
0

# pipeline 最右边执行失败的命令的退出码为 pipeline 的退出码
$ set -o pipefail
$ echo a | grep ff | cat -
$ echo $?
1

$ set -o pipefail
$ echo aa | cat - | echo bb
bb
# echo 不读取 pipeline, 所以通过 pipeline 向 echo 写入时返回 SIGPIPE 信号，命令因信号
# 的退出码为 141（128+13）
$ echo $?
141

# 虽然有三个命令都异常退出，但是 exit 6 位于最右侧，所以返回它的退出码
$ set -o pipefail
$ echo abc </dev/null | mybad| exit 4 | sleep 5 | echo bcd >/dev/null | echo cde |exit 6
mybad: command not found
$ echo $?
6

$ echo abc </dev/null | mybad | exit 4 | sleep 5 | echo bcd >/dev/null | echo cde |exit 0
mybad: command not found
echo $?$ echo $? # SIGPIPE  信号中止
141

$ echo abc </dev/null | exit 4 | sleep 5 | echo bcd >/dev/null | echo cde |exit 0
echo $?$ echo $?
4

# 虽然开启了 lastpipe, 但是当前 shell 是激活了 job control 的交互式 shell, 所以
# lastpipe 不生效
$ var=1
$ shopt -s lastpipe
$ date | cat  | ( echo $var; var=2; )
1
$ echo $var
1

# 在脚本或 bash -c 等非交互式 shell 中，不激活 job control

# 未开启时  var=2 在自己的 sub shell 中设置
$ bash -c 'var=1; date | cat  | var=2; echo $var'
1

# 开启了 lastpipe 后 var=2 在当前 shell 环境中执行
$ bash -c 'var=1; shopt -s lastpipe; date | cat | var=2; echo $var'
2

$ asdfa | asdfa | asdfa
bash: asdfa: command not found
bash: asdfa: command not found
bash: asdfa: command not found
$ echo ${PIPESTATUS[@]}
127 127 127

$ date | cat - |wc -c
28
$ echo ${PIPESTATUS[@]}
0 0 0

$ time sleep 1

real    0m1.039s
user    0m0.001s
sys     0m0.003s

$ echo | exit 2
$ echo $?
2
$ ! echo | exit 2  # pipeline 退出码取反，结果为 0 或 1;
$ echo $?
0

# 在 pipeline 命令最后添加 & 时，整个 pipeline 放到后台运行
$ echo abc </dev/null | sleep 100 | echo bcd >/dev/null | echo cde |cat - &
[1] 34438
cde

$ jobs
[1]+  Running   echo abc < /dev/null | sleep 100 | echo bcd > /dev/null | echo cde | cat - &
$

# set +o 用于关闭 bash 特性，而 set -o 用于开启 bash 特性。

# 关闭 pipefail 特性（默认行为）
$ set +o pipefail
$ date; echo aa | cat - | echo bb && echo cc |echo dd & echo ee | echo ff | exit 3
Sat 20 Aug 2022 05:45:06 PM CST
[1] 928905
bb
dd
[1]+  Done                    echo aa | cat - | echo bb && echo cc | echo dd
$ echo $? # 返回形式上最右侧命令的退出码
3
$

$ set -o pipefail
$ date; echo aa | cat - | echo bb && echo cc |echo dd & echo ee | echo ff
Sat 20 Aug 2022 05:19:36 PM CST
[1] 928720
ff
bb
$
[1]+  Exit 141                echo aa | cat - | echo bb && echo cc | echo dd
$

$ f1() { return 1; }
$ f2() { return 2; }
$ f3() { return 3; }
$ f1; f2; asdasd; f3
bash: asdasd: command not found
$ echo $?
3
$ f1; f2; asdasd; f3; echo ok
bash: asdasd: command not found
ok
$ echo $?
0
$

#  & 和 ; 都是用于分割命令, 最后一个 done 前使用 & 表示异步执行每个命令.
$ for i in one two three; do command "$i" & done

# job control 生效的情况下，异步命令读取 stdin 时会被 STOP
$ cat &
[1] 13426
[1]+  Stopped                 cat

$ echo aa && vim & echo bb
[1] 47605
bb
aa
[1]+  Stopped                 echo aa && vim

$ jobs
[1]+  Stopped                 echo aa && vim
$

# bash -c 的 cmd 是在 job control 未生效的 非交互式 shell 执行的
$ bash -c 'cat <(echo -n a) - <(echo -n b)&'
ab$

# && 的优先级比 || 高，所以 [ -n "$fasda" ] && echo "not zero" 整体为 false 时，后面
# 的 || 才会执行。

$ [ -n "$fasda" ] && echo "not zero" || echo "zero"
zero
$ [ -z "$fasda" ] && [ -z "$asdfasd" ] || echo "zero"
$

$ set -- a b "c d" e
$ for w; do echo $w;done
a
b
c d
e
$

# 支持文件名扩展
$ for f in ./*.org; do echo $f; done
./inbox.org
$
# 支持 brace 扩展
$ for w in {1..5}; do echo $w; done
1
2
3
4
5

# for (()) 算术表达式（算术表达式可以用逗号分割，变量引用可以不加 $ 前缀）
$ for ((i=1,j=1; i+j < 10; i++, j++)) do echo $((i+j));done
2
4
6
8
$

$ for c in $(seq 1 0.2 2); do echo $c;done
1.0
1.2
1.4
1.6
1.8
2.0

# for 和 {1..5} 大括号扩展使用
$ for i in {1..5}; do echo $i;done
$ for i in {1..5..2}; do echo $i;done
$ for i in $(seq 1 5); do echo $i;done

# && 的优先级比 || 高
[ -z "$asdf" ] && echo 'zero' || echo 'not zero'
# 等效为:
if [ -z "$asdf" ]; then
   echo 'zero'
else
   echo 'not zero'
fi

[ -z "$asdf" ] || echo "not zero"
# 等效为
if [ ! -z "$asdf" ]; then # 或者  if ! [ -z "$asdf" ]; then
  echo 'not zero'
fi

# [ -z "$asdf" ] && echo 'zero' || echo 'not zero'

case WORD in
    # pattern 是 glob 语法(不被引号引住, 不会被 glob 扩展) , 如果是字符串则是字符串严格匹配。
    [ [(] PATTERN [| PATTERN]...) COMMAND-LIST ;;]...
esac # esac 是 case 的反写

$ echo $-
himBH

$ case "$-" in
>   *i*) echo interactive ;;
>   *) echo non-interactive ;;  # *) 一般放到最后作为缺省匹配
> esac
interactive
$

LEN=72
CHAR='-'
while (( $# > 0 ))
do
    case $1 in
    [0-9]*) LEN=$1;;
    -c) shift
        CHAR=$1;;
    *) usagexit;;
    esac
    shift
done

select NAME [in WORDS ...]; do COMMANDS; done

# 是复合命令，而非算术替换表达式, 所以需要在使用命令而非变量的地方使用。
$ echo ((3+3,3+4))
bash: syntax error near unexpected token '('

# 多个算术运算可以使用 逗号 分割
$ ((3+3,3+4))
# 逗号后面可以有空格，如
$ (( 3+3, 3+4 ))
$ var=-1
# 其它分隔符号都是非法的
$ ((var+=1; var))
bash: ((: var+=1; var: syntax error: invalid arithmetic operator (error token is "; var")
$ ((var+=1,var))
$ echo $?
1

$ var=-1
# 变量不需要加 $ 前缀
# 变量赋值时，赋值后变量值为 0 时返回 1,  否则返回 0
$ ((var+=1))
$ echo $?
1
$ echo $var
0
$ ((var+=4))
$ echo $var
4
$ a=3
$ ((var+=a*3))
$ echo $var
13

# 算术运算结果为 0 时退出码为 1, 否则退出码为 0 时
$ (( 0 ))
$ echo $?
1
$ (( 1 ))
$ echo $?
0

# 算术运算的结果先参考 a 的值，由于为 0, 所以退出码为 1;
$ a=0
$ ((a++))
$ echo $?
1
$ echo $a
1

# 先进行 ++ 计算，然后参考计算结果来计算退出码，由于为 1, 所以退出码为 0;
$ a=0
$ ((++a))
$ echo $?
0
$ echo $a
1
$

# 逻辑运算为真时退出码为 0, 为假时退出码为 1
$ (( 4 > 3))
$ echo $?
0
$ (( 3 > 4))
$ echo $?
1
$ (( 2 > 4 || 4 > 3))
$ echo $?
0
$

$ echo $((0))
0
$ echo $((1))
1
$ echo $((4>3))
1
$ echo $((4<3))
0
$ a=-1
$ echo $((a+=2))
1
$ a=-1
$ echo $((a++))
-1
$

# 内容是表达式，而非命令
$ [[ echo ]]
bash: syntax error near unexpected token `echo'
$ [[ echo; ]]
bash: unexpected token `;', conditional binary operator expected

$ var=3
# 内容前后必须有空格
$ [[var]]
[[var]]: command not found
$ [[ var]]
bash: unexpected token `newline', conditional binary operator expected
$ [[ var ]]

# 支持算术运算，逗号运算（逗号前后不能有空格），逻辑运算表达式
$ [[ var+=3 ]]
$ [[ var,var++ ]]
$ [[ var,++var ]]
$ [[ var, var ]]
bash: syntax error near unexpected token `var,'
$ [[ 0 && 3 || 4 ]]
$

# 支持各种字符串匹配表达式：严格匹配，glob 匹配，正则匹配
$ [[ "asfas" = "asfsa" ]]; echo $?
1
$ [[ "asfas" = asfa ]]; echo $?
1
$ [[ "asfas" = asfa* ]]; echo $?
0
$ [[ "asfas" =~ asfa.* ]]; echo $?
0

# 支持 test/[] 的条件表达式，并且支持 && || ！逻辑运算表达式和 () 分组
$ [[ "asfas" =~ asfa.* && -f /etc/mtab ]]; echo $?
0
$ [[ "asfas" =~ asfa.* && -f /etc/mtab ]]; echo $?
0
$ [[ "asfas" =~ asfa.* && -f /etc/mtab && ! -f /etc/mtab ]]; echo $?
1
$ [[ "asfas" =~ asfa.* && (-f /etc/mtab && ! -f /etc/mtab) ]]; echo $?
1
$ [[ "asfas" =~ asfa.* && (-f /etc/mtab || ! -f /etc/mtab) ]]; echo $?
0

# EXPRESSION 不会进行分词和文件名扩展，所以 z* 不会被模糊替换。右侧是非字符串时，表示
# glob pattern
$ if [[ "zhang" = z* ]]; then echo yes ; else echo no;fi
yes
$

$ if [[ "zhang" = "z*" ]]; then echo yes ; else echo no;fi
no
$

# 支持各种字符串匹配表达式：严格匹配，glob 匹配，正则匹配
$ [[ "asfas" = "asfsa" ]]; echo $?
1
$ [[ "asfas" == asfa ]]; echo $?
1
$ [[ "asfas" == asfa* ]]; echo $?
0
$ [[ "asfas" =~ asfa.* ]]; echo $?
0

$ [[ "asdfas" = a ]] && echo yes || echo no
no
$ [[ "asdfas" = a* ]] && echo yes || echo no
yes
$ [[ "asdfas" =~ a ]] && echo yes || echo no
yes

[[ $line =~ [[:space:]]*(a)?b ]]

pattern='[[:space:]]*(a)?b'
[[ $line =~ $pattern ]]

pattern='\.'
[[ . =~ $pattern ]]
[[ . =~ \. ]]

# 以下两种都是字符串匹配
[[ . =~ "$pattern" ]]
[[ . =~ '\.' ]]

$ [ -z "$asdfa" -o -z "$baad" ] && echo or or

$ declare v
# -v 检查变量是否定义且不为 null string
$ if [ -v v ]; then echo ok; else echo bad;fi
bad

# 定义变量并设置为空字符串, 等效为 declare v=""
$ declare v=
$ if [ -v v ]; then echo ok; else echo bad;fi # 变量定义且不为 null string
ok

$ unset a
$ declare a # 只声明 a，未赋值，a 为 null string
$ [ -v a ] && echo ok || echo bad
bad
$ declare a b c   # a/b/c 是 null string，取值时等效于空串
$ echo "#${a}:${b}:${c}#"
#::#
$ unset a
$ declare a= # 声明 a 的同时赋值为空串，a 不为 null string，而是 a == ""
$ [ -v a ] && echo ok || echo bad
ok
$ unset a
$ a= # 声明 a 的同时赋值为空串，a 不为 null string，而是 a == ""
$ [ -v a ] && echo ok || echo bad
ok
$ unset a
$ a=""
$ [ -v a ] && echo ok || echo bad
ok

$ unset v2
$ if [ $v2 ]; then echo ok; else echo bad;fi
bad
$ v2=""
$ if [ $v2 ]; then echo ok; else echo bad;fi
bad
$ v2=" "
$ if [ $v2 ]; then echo ok; else echo bad;fi
bad
$ v2=0
$ if [ $v2 ]; then echo ok; else echo bad;fi
ok

$ unset ff
$ ff=  # 定义为空串
$ test -v ff; echo $? # -v 检查变量是否定义且非 null string
0
$ [ "" ]; echo $?
1

$ [ "asd" ] # 非空串
$ echo $?
0

$ [ "$asd" ] # 空串
$ echo $?
1

# 重定向针对 simple command，所以只会对第二个 cat 输出重定向
$ cat inbox.org; cat inbox.org >/tmp/log

# 对两个 cat 都重定向到一个文件
$ (cat inbox.org; cat inbox.org ) >/tmp/log

# 错误用法
$ {date; } # { 和 date 间没有空格
$ { date } # } 前少了 ;
# 正确
$ { date; }
Sat 27 Aug 2022 09:58:00 PM CST

# && 优先级比 || 高
$ [ -z "$UNSET" ] && { echo unset; exit 1; } || { echo setted; exit 0; }

# mkdir scratch areas and check for failure
# N.B. must have whitespace around the { and } and
#      must have the trailing ; in the {} lists
mkdir "$PRIV1" || { echo "to Unable mkdir '$PRIV1'" ; exit 4; }
mkdir "$PRIV2" || { echo "Unable to mkdir '$PRIV2'" ; exit 5; }

# 在当前 shell 环境执行变量赋值
$ { gv2=2; vg=11; }
$ echo gv2 $vg
gv2 11
$ echo $gv2 $vg
2 11
$

# 位于 pipeline 中时，在一个 sub shell 环境中执行
$ gv=1
$ echo ok1 | { gv2=2; vg=11; } | echo ok2
ok2
$ echo $gv2

$ echo $vg

# 在后台执行时，也是在一个 sub shell 环境中执行
root@devops-109:~# { sleep 1000 && read input && echo $input; } &
[1] 1149940
root@devops-109:~# ps -lfH
F S UID          PID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
4 S root     1149930 1149721  0  80   0 -  3491 do_wai 10:23 pts/1    00:00:00 -bash
1 S root     1149940 1149930  0  80   0 -  3491 do_wai 10:23 pts/1    00:00:00   -bash
0 S root     1149941 1149940  0  80   0 -  2787 hrtime 10:23 pts/1    00:00:00     sleep 1000
4 R root     1149942 1149930  0  80   0 -  3640 -      10:23 pts/1    00:00:00   ps -lfH

# 一个复合命令，自定义 NAME 为 tr。
coproc tr { tr a b; }

# 向 coproc 命令写入内容，注意使用的重定向语法。
echo aaa >&"${tr[1]}"

# 关闭 tr[1] FD 的写入, 表示写入完毕。
exec {tr[1]}>&-

# 读取 coproc 命令的输出。
cat <&"${tr[0]}"

# 错误: > 和 & 间有空格;
root@devops-109:~# echo hello 2 > &1
-bash: syntax error near unexpected token '&'

# 错误: 2 和 > 中间有空格, 故不属于 FD
root@devops-109:~# echo hello 2 >&1
hello 2

# 正确
root@devops-109:~# echo hello 2>&1
hello

# 在一个 sub shell 中执行 compound commands， 返回的 PID 为 sub shell 进程 PID。
root@devops-109:~# coproc myproc3 { echo hello3; cat -; }
[1] 1145641
root@devops-109:~# ps -lfH
F S UID          PID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
4 S root     1145617 1144545  0  80   0 -  3524 do_wai 21:53 pts/0    00:00:00 -bash
1 S root     1145641 1145617  0  80   0 -  3491 do_wai 21:55 pts/0    00:00:00   -bash
0 S root     1145642 1145641  0  80   0 -  2823 pipe_w 21:55 pts/0    00:00:00     cat -
4 R root     1145646 1145617  0  80   0 -  3640 -      21:55 pts/0    00:00:00   ps -lfH

# calling shell 可以通过 NAME_PID 来获得 sub shell PID;
root@devops-109:~# echo ${myproc3_PID}
1145641

# 写入部分内容，stdin 并未关闭
root@devops-109:~# echo hello cat >&${myproc3[1]}
root@devops-109:~# cat <&${myproc3[0]}
hello3
hello cat
^C

# 关闭文件描述符

# 错误: 这里的语义是 exec 60 > &- , 所以 exec 执行 60 命令出错。
root@devops-109:~# exec ${myproc3[1]}>&-
-bash: exec: 60: not found

# 正确：应该使用 exec {VARNAME}>&- 或 exec {VARNAME}<&- 来关闭变量 VARNAME 对应的 FD
# 的写入或读取。

root@devops-109:~# exec {myproc3[1]}>&-
root@devops-109:~#
[1]+  Done                    coproc myproc3 { echo hello3; cat -; }

FNAME () COMPOUND-COMMAND [ REDIRECTIONS ]
function FNAME [()] COMPOUND-COMMAND [ REDIRECTIONS ].

$ function myfunc() date # 必须是 COMPOUND-COMMAND
-bash: syntax error near unexpected token date

$ function myfunc() { date } # 大括号: 1. 内部前后有空格; 2. 右括号前有分号；
> -bash: syntax error: unexpected end of file
$ function myfunc() { date; }

$ function mytest() if [[ $1 == "zhang" ]]; then echo zhang; else echo who?;fi
$ mytest jun
who?
$ function mycal() ((k+=3))
$ mycal
$ echo $k
3

# subtract the (given) file size from the (global) free space
function REDUCE ()
(( FREE-=${1:-0}))

# 执行函数时才会实际重定向
$ mycat () { cat; cat iptables; } <extfrag.log  >output
$ mycat
$ wc -l output
35 output

# for p; do xx; done 等效为: for p in "$@";do xx; done
$ function mytest() { echo "$0"; echo "$#"; echo "${FUNCNAME[0]}"; for p; do echo $p;done; }
$ mytest 1 2 3 4
/bin/bash
4
mytest
1
2
3
4
$

function usagexit ()
{
    echo "usage: ${0##*/} file1 file2"
    echo "where both files must be .odt files"
    exit $1
} >&2

#cat spool/x.sh
echo ok
echo $(dirname $0)
echo $0

#bash ./spool/x.sh
ok
./spool
./spool/x.sh

#realpath ./spool/x.sh
/var/spool/x.sh

$ return 3  # return 只能在 function 或 script 中使用
bash: return: can only return from a function or sourced script

$ function mytest3() { return 3; }
$ mytest3; echo $?
3

$ function mytest3() { return; }   # return 不带返回值时, 返回上一条命令的返回值
$ mytest3; echo $?
0

$ function mytest3() { d; return; }
$ mytest3; echo $?
bash: d: command not found
127

$ function mytest() { return $(echo OK); }  # return 命令的参数必需是数字
$ mytest; echo $?
bash: return: OK: numeric argument required
255
$

$ function mytest() { d; return $((1+2)); }
$ mytest; echo $?
bash: d: command not found
3
$

$ function mytest() { $1="zhangjun"; echo $1;  }
$ mytest
bash: =zhangjun: command not found

# 如果 $1 未定义或为空, 则返回 zhangjun 且对 $1 赋值。
$ function mytest() { local name="${1:=zhangjun}"; printf "%s\n" name; }
$ mytest
bash: $1: cannot assign in this way

# 如果 $1 未定义或为空, 则返回 zhangjun, 但不对 $1 赋值。
$ function mytest() { echo "${1:-zhangjun}"; }
$ mytest
zhangjun

# 如果 $1 未定义或为空, 则报错, 打印 zhangjun，不再执行后面的语句
$ function mytest() { local name="${1:?zhangjun}"; printf "%s\n" $name; }
$ mytest
bash: 1: zhangjun

# 使用 set 来重新设置函数的位置参数。
$ function mytest() { set -- a b c ; echo "${1:-zhangjun}"; }
$ mytest
a

$ local a
bash: local: 只能在函数中使用

$ function  mytest () { var=4; }
$ echo $var
$
$ mytest
$ echo $var   # 全局变量 var
4

$ unset var
$ function mytest2 () { local var=1; mytest; }
$ mytest2
$ echo $var  # 全局没有该变量

$

$ var=global
$ function func1 () {
>   local var='func1 local'  # 遮盖外面同名的变量
>   func2
> }
$ function func2 () {
>   echo "in func2, var = $var"
> }
$ func1
in func2, var = func1 local
$

# 可以同时声明多个函数内的 local 变量，未赋值时这些变量为 null string。
fpmul()
{
    # 这些变量是 null string（没有值）
    local places tot qm neg n int dec df

    places=  # 等效于 places=""，将变量设置为空值
    tot=1
    qm=
    neg=
    #...
}

# [ -v var ] 检查变量 var 存在且赋值过（非 null string 即可，不管是否是空串）
$ function mytest () { local var; [ -v var ] && echo ok || echo bad; }
$ mytest
bad
# local var=; 将 var 设置为空字符串，var 变量被赋值过
$ function mytest () { local var=; [ -v var ] && echo ok || echo bad; }
$ mytest
ok

$ declare -f | grep mycat # 显示所有函数定义
mycat ()

$ declare -f mycat # 只显示 mycat 函数定义
mycat ()
{
    cat;
    cat iptables
} < extfrag.log > output

$ declare -F  |grep mycat
declare -f mycat
$

$ function add() { return $(($1+$2)); }
$ add 1 2
$ echo $?
3
$ echo a | add 1 2  # add 未导出，但是可以在 pipeline sub shell 环境中执行
$ echo $?
3
$
$ echo a | (add 1 2)
$ echo $?
3
$ echo a | { add 1 2 ; }
$ echo $?
3

$ bash -c 'add 1 2; echo $?'
bash: add: command not found
127
$ export -f add
$ bash -c 'add 1 2; echo $?'
3

$ function myfunc () {
>   printf '$#: %d, $0: %s, funcname: %s\n' "$#" "$0" "${FUNCNAME[0]}"
>   for a; do
>       echo $a
>   done
>   shift 2  # 参数左移两位
>   printf '$#: %d, $0: %s, funcname: %s\n' "$#" "$0" "${FUNCNAME[0]}" # $0 不变，但是 $# 减少两位
> }
$ myfunc  1 2 3 "a b" 4
$#: 5, $0: -bash, funcname: myfunc
1
2
3
a b
4
$#: 3, $0: -bash, funcname: myfunc
$

$ bash
$ PS1=">"
>simple() {
>   badcommand
>   echo bad
> }
>set -e
>simple  # 函数作为 simple command 直接执行时，set -e 可以捕获 body 中的错误。
bash: badcommand：未找到命令
$

root@devops-109:~# bash
root@devops-109:~# PS1='>'
>function mytest() { local ts; ts=$(myccc); echo $?; } # 纯粹的命令替换
>set -e
>mytest
myccc: command not found
root@devops-109:~#

# 非纯粹命令替换情况：local 内置命令定义一个变量，执行函数时并不退出
$ bash
$ PS1='>'
>function mytest() { local ts=$(myccc); echo $?; }
>set -e
>mytest
bash: myccc: command not found
0
>

# 如果先用 local 定义变量，然后再做变量赋值，则执行函数时退出
$ bash
$ PS1='>'
>function mytest() { local ts; ts=$(myccc); echo $?; }
>set -e
>mytest
bash: myccc: command not found
$

# 但是通过命令替换执行函数时，不退出。
$ bash
$ PS1='>'
>function mytest() { local ts; ts=$(myccc); echo $?; }
>set -e
>cc=$(mytest)
bash: myccc: command not found
>echo $cc  # 函数输出的内容
127
>

$ bash
$ PS1=">"
>simple () { badcommand; echo bad; }
>set -e
>if simple; then echo ok; else echo bad; fi  # sub shell 并没有退出
bash: badcommand：未找到命令
bad
ok

trap [-lp] [ARG] [SIGSPEC ...]

# 可以同时指定多个信号
trap 'catch $? $LINENO' ERR DEBUG

catch() {
  echo "Error $1 occurred on $2"
}

echo "Before bad command"
badcommand
echo "After bad command"

$ trap -p
trap -- 'echo trap: exit' EXIT  # -- 表示后续不是 trap 命令的选项
trap -- 'echo trap: error' ERR

$ trap -p EXIT
trap -- 'echo trap: exit' EXIT
$

# 脚本 sleep 期间收到 HUP 信号时并不立即执行 trap, 而是需要等待脚本执行结束
root@devops-109:~# cat test.sh
trap 'echo sighup >/root/trap.sighup.$$;' SIGHUP
sleep 1000
root@devops-109:~# bash test.sh

root@devops-109:~# ps -elfH |grep sleep -C 3
4 S root     1094956     686  0  80   0 -  3451 poll_s 19:28 ?        00:00:00     sshd: root@pts/0,pts/2
4 S root     1095243 1094956  0  80   0 -  3557 do_wai 19:39 pts/0    00:00:00       -bash
0 S root     1095711 1095243  0  80   0 -  3141 do_wai 20:16 pts/0    00:00:00         bash test.sh
0 S root     1095712 1095711  0  80   0 -  2787 hrtime 20:16 pts/0    00:00:00           sleep 1000
# 向 shell 发送 HUP 信号时, shell 因为在等待 sleep 的返回, 所以并不会执行 trap
root@devops-109:~# kill -HUP 1095711
root@devops-109:~# ps -elfH |grep sleep -C 3
4 S root     1094956     686  0  80   0 -  3451 poll_s 19:28 ?        00:00:00     sshd: root@pts/0,pts/2
4 S root     1095243 1094956  0  80   0 -  3557 do_wai 19:39 pts/0    00:00:00       -bash
0 S root     1095711 1095243  0  80   0 -  3141 do_wai 20:16 pts/0    00:00:00         bash test.sh
0 S root     1095712 1095711  0  80   0 -  2787 hrtime 20:16 pts/0    00:00:00           sleep 1000
# 当向 test.sh 进程组发送 HUP 信号时, shell 向进程组所有进程发送 HUP 信号, 这时 sleep
# 被中止, shell 脚本执行结果, shell 执行 trap。
root@devops-109:~# kill -HUP -1095711 # PID 值为负值表示向进程组中所有进行发送信号
root@devops-109:~# bash test.sh
Hangup
root@devops-109:~#
root@devops-109:~# cat trap.sighup.1095711
sighup

# 即使将脚本中 sleep 修改为 while 循环, 向 shell 发送 HUP 信号时, 也不会立即执行trap,
# 需要等待 shell 脚本退出时才执行。
root@devops-109:~# cat test.sh
trap 'echo sighup >/root/trap.sighup.$$;' SIGHUP
sleep 20
while ((i++, i<5)); do
        sleep 1
done
root@devops-109:~# bash test.sh
root@devops-109:~#

root@devops-109:~# ps -elfH |grep test.sh
4 S root     1096646 1094956  0  80   0 -  3524 do_wai 20:31 pts/3    00:00:00       -bash
0 S root     1096889 1096646  0  80   0 -  3141 do_wai 20:35 pts/3    00:00:00         bash test.sh
0 S root     1096890 1096889  0  80   0 -  2787 hrtime 20:35 pts/3    00:00:00           sleep 20
root@devops-109:~# kill -HUP 1096889

# 等待一段时间 shell 脚本退出后, 执行了 trap 指令。
root@devops-109:~# cat trap.sighup.1096889
sighup

#!/bin/bash

echo starting up

function shut_down() {
    echo shutting down

    pid=$(ps -e | grep myapp | awk '{print $1}')
    kill -SIGTERM $pid
    exit
}

trap "shut_down" SIGKILL SIGTERM SIGHUP SIGINT EXIT

/opt/myapp

#!/bin/bash
echo starting up

exec /opt/myapp

#!/bin/bash

_term() {
  echo "Caught SIGTERM signal!"
  kill -TERM "$child" 2>/dev/null
}

trap _term SIGTERM

echo "Doing some initial work...";
/bin/start/main/server --nodaemon &

# $! 或 ${!} 返回上次执行的后台任务 PID
child=$!
wait "$child"

$ bash -c 'trap "echo trap:exit" exit;  date'
Thu 01 Sep 2022 05:07:09 PM CST
trap:exit

scratch=$(mktemp -d -t tmp.XXXXXXXXXX)
function finish {
  rm -rf "$scratch"
}
trap finish EXIT

#!/bin/bash
set -e
trap 'catch $? $LINENO' EXIT

catch() {
  echo "catching!"
  if [ "$1" != "0" ]; then
    echo "Error $1 occurred on $2"
  fi
}

simple() {
  badcommand
  echo "Hi from simple()!"
}

$ trap 'echo trap:debug $LINENO' DEBUG
trap:debug

# 在执行命令前执行 DEBUG trap 命令
$ date
trap:debug 38
Thu 01 Sep 2022 05:18:40 PM CST

$ for a in 1 2 3 ;do echo $a;done
trap:debug 39  # 各 for 变量前也会执行 DEBUG trap
trap:debug 39  # 这个是执行 echo $a 命令前执行的 DEBUG trap
1
trap:debug 39
trap:debug 39
2
trap:debug 39
trap:debug 39
3

$ trap 'echo trap:return $FUNCNAME' return

$ function mytest() { var=1; return 0; }
# 正常执行 shell 命令或函数返回时不会执行 return trap (因为函数默认不继承 calling
# shell 的 return/debug trap)
$ mytest

$ echo 'function mytest() { var=1; echo mytest; }; function mytest2() { echo mytest2; }; mytest; mytest2 ' >x.sh

# 非 source 或 . 执行脚本, 不会执行 return trap
root@devops-109:~# bash x.sh
mytest
mytest2

#  . 执行脚本返回时，执行 return trap
$ . x.sh
mytest
mytest2
trap:return

$ bash
$ cat x.sh
function mytest() { var=1; echo mytest; };
function mytest2() { echo mytest2; };
mytest;
exit 0;
mytest2
$ trap 'echo trap:return' return

# 如果脚本提前退出（exit 或者 set -o errexit 导致的退出），则不执行 return trap
$ . x.sh
mytest

root@devops-109:~# function mytest() { trap 'echo "return"; ((var++));' RETURN; var=1; }
root@devops-109:~# mytest
return
root@devops-109:~# echo $var
2

# 如果函数异常返回, 则不会执行 RETURN trap;
root@devops-109:~# cat x.sh
function mytest() {
  trap 'echo "return"; ((var++));' RETURN
  var=1
  exit 1
}
mytest
echo  $var
root@devops-109:~# bash x.sh

# 未定义任何 trap
$ trap -p

$ trap 'echo trap:debug' debug
trap:debug

$ function mytest() { echo 'mytest func1'; echo 'mytest func2'; }
# 对于 debug/return trap, 默认 func 内是不继承的, 但是在执行函数命令前执行一次
$ mytest
trap:debug

mytest func1
mytest func2

$ set -o functrace
trap:debug

$ mytest
trap:debug # 执行 mytest 命令前
trap:debug # 进入函数体前
trap:debug # 执行 echo 命令前
mytest func1
trap:debug # 执行 echo 命令前
mytest func2
trap:debug # 函数返回前
$

$ trap 'echo "trap:return"' return
$ f () { echo ok; }
$ echo $'f\nf' >y
$ . y # 执行脚本 y 退出时执行一次 return trap
ok
ok
trap:return
$ set -o functrace
$ . y  # 执行脚本 y 内的每个函数返回时都执行 return trap
ok
trap:return
ok
trap:return
trap:return  # 最终执行 y 脚本退出时, 也会执行 return trap
$

root@devops-109:~# trap -p
trap:debug
trap -- 'echo trap:debug' DEBUG
trap -- 'echo "trap:return"' RETURN

root@devops-109:~# cat y
trap:debug
mytest
mytest

root@devops-109:~# bash y
trap:debug
mytest func1
mytest func2
mytest func1
mytest func2

root@devops-109:~# . y   # source/. 执行脚本时, 当脚本正常返回时执行 RETURN trap
trap:debug
mytest func1
mytest func2
mytest func1
mytest func2
trap:return

root@devops-109:~# set -o functrace  # 开启 functrace
trap:debug
root@devops-109:~# echo $-
trap:debug
himBHTs
root@devops-109:~# bash -c 'echo $-'  # 子 shell 并没有继承 functrace 特性(无 T)
trap:debug
hBc
root@devops-109:~# bash y  # calling shell 是 bash 子 shell, 没有开启 functrace 特性
trap:debug
mytest func1
mytest func2
mytest func1
mytest func2
root@devops-109:~# . y # calling shell 是当前 shell
trap:debug
trap:debug
trap:debug
trap:debug
mytest func1
trap:debug
mytest func2
trap:debug
trap:return
trap:debug
trap:debug
trap:debug
mytest func1
trap:debug
mytest func2
trap:debug
trap:return
trap:debug
trap:return
root@devops-109:~#

trap 'catch' ERR  # catch 为捕获 ERR 时执行的命令, 这里的 catch 为函数命令

catch() {
  echo "An error has occurred but we're going to eat it!!"
}

echo "Before bad command"
badcommand  # 命令执行失败, 执行 ERR trap
echo "After bad command"

$ cat err.sh
trap 'echo "trap:exit"' exit
trap 'echo "trap:err"' err

function foo () {
  echo foo1-1
  ffff
  echo foo1-2
}

function foo2 () {
  echo foo2
  fff
}

echo before ffff
ffff

echo before foo
foo

echo before foo2
foo2

echo before ffff
ffff

echo before 'echo ok'
echo ok

$ bash err.sh
before ffff
err.sh: line 18: ffff: command not found # 脚本命令执行失败，执行 err trap
trap:err
before foo
foo1-1
err.sh: line 8: ffff: command not found  # 函数内命令执行失败，默认不执行 err trap,
					 # 除非先执行 set -o errtrace或 set -E 命令
foo1-2
before foo2
foo2                                     # 函数内最后一条命令执行失败时，函数返回后，
					 # 执行 err trap
err.sh: line 14: fff: command not found
trap:err
before ffff
err.sh: line 27: ffff: command not found # 脚本内的其它非函数命令执行失败时, 执行 err
					 # trap
trap:err
before echo ok
ok
trap:exit
$

$ bash
$ PS1=">"
>simple() {
>   badcommand
>   echo bad
> }
>set -e
>simple
bash: badcommand：未找到命令
$

$ bash
$ PS1=">"
>simple () { badcommand; echo bad; }
>set -e
>if simple; then echo ok; else echo bad; fi  # sub shell 并没有退出
bash: badcommand：未找到命令
bad
ok
>myvar=$(simple)                  # sub shell 并没有退出
bash: badcommand：未找到命令
>

# 不开启 set -e 时, 函数执行出错返回时，执行 trap error
$ cat err2.sh
#set -e
trap 'echo "trap:err"' err

myfunc () {
  foo
}

myfunc
$ bash err2.sh
err2.sh: line 5: foo: command not found
trap:err
$

# 开启 set -e 后，函数执行出错返回时，不再执行 err trap
$ sed -i 's/^#//' err2.sh
$ bash err2.sh
err2.sh: line 5: foo: command not found

# a/b/c 是 null string，取值时等效于空串
$ declare a b c
$ echo "#${a}:${b}:${c}#"
#::#

$ local a
bash: local: 只能在函数中使用
$
$ function mytest () { local var; [ -v var ] && echo ok || echo bad; }
$ mytest
bad
$ function mytest () { local var=; [ -v var ] && echo ok || echo bad; }
$ mytest
ok

# a/b/c 是空串，而非 null string
$ a= b= c=
# 等效于：
$ declare a= b= c=
# 等效于：
$ declare a="" b="" c=""

set -e
# 即使 myccc 执行失败，local 命令还是执行成功，隐藏了错误。
>function mytest() { local ts=$(myccc); echo $?; }
>mytest
bash: myccc：未找到命令
0
>

# 先定义一个 local 变量，然后再赋值，这样如果 myccc 执行出错则赋值命令也返回出错。注
# 意 myccc 如果是函数，则看函数最后一条命令的返回码，而不是中间情况出错时就终止(因为
# 函数体是 compound commands，退出码为最后一条命令)。
>function mytest() { local ts=; ts=$(myccc); echo $?; }
>mytest
bash: myccc：未找到命令
127