在Linux系统中，作为/bin/sh的标准Shell是GNU工具集中的bash（GNU Bourne-Again Shell），大多数Linux发行版中/bin/sh是指向/bin/bash的一个链接。

Bash编程中，可以通过PID文件进行简单的单例控制——仅仅同时仅仅允许脚本的单个实例在运行：

#!/usr/bin/env bash
PIDFILE=/var/run/gmem-sync.pid
if [ -f $PIDFILE ]
then
  # PID文件存在
  PID=$(cat $PIDFILE)
  ps -p $PID > /dev/null 2>&1
  if [ $? -eq 0 ]
  then
    # PID文件指定的进程存在
    echo "Job is already running"
    exit 1
  else
    # PID文件指定的进程不存在
    echo $$ > $PIDFILE
    if [ $? -ne 0 ]
    then
      echo "Could not create PID file"
      exit 1
    fi
  fi
else
  echo $$ > $PIDFILE
  if [ $? -ne 0 ]
  then
    echo "Could not create PID file"
    exit 1
  fi
fi

# 这里编写主逻辑


# 完毕后删除PID文件
rm $PIDFILE

# 以独占锁（-x）打开gmem-sync.pid文件，并执行-c指定的命令
# -n 如果无法获得独占锁，立即静默的退出，退出状态非0
flock -xn /var/run/gmem-sync.pid -c /usr/local/bin/gmem-sync.sh

我们可以对终端输出的字符颜色、背景色等参数进行设置，实现方式是转义序列。这个控制实际上与Bash语言无关，其它语言在输出时也可以使用。

转义序列以ESC字符开头，对应八进制的\033。控制代码格式为：

\033[显示方式;前景色;背景色;动作m;

注意：显示方式、前景色、背景色都是可选的，而且顺序可以颠倒。示例：

# 恢复系统默认设置
\033[0m
# 设置蓝色背景、白色前景、光标闪烁
\033[44;37;5m

在脚本中使用色彩控制的例子：

echo -e "\033[44mDumping Gmem database on hk.gmem.cc ...\033[0m"

可以利用初始化脚本函数（Init Script Functions）来输出系统日志：

echo hello; echo there
if [ -x "$filename" ]; then # 注意分号后面的空格

case "$variable" in
    abc) echo "\$variable = abc" ;;
    xyz) echo "\$variable = xyz" ;;
esac

let "t2 = ((a = 9, 15 / 3))" #设置t2=15/3，a=9

if condition
then : #什么都不做
else 
    take-some-action
fi
: >> target_file #如果不存在，则创建文件

echo \"{These,words,are,quoted}\"
#打印："These" "words" "are" "quoted"
cat {file1,file2,file3} > combined_file
#将三个文件的内容连接合并到combined_file
cp file22.{txt,backup}
#复制file22.txt为file22.backup

echo {a..z} 
#打印 a b c d e f g h i j k l m n o p q r s t u v w x y z
echo {0..3} 
#打印 0 1 2 3
base64_charset=( {A..Z} {a..z} {0..9} + / = )
#初始化一个数组

#!/bin/bash
File=/etc/fstab
{
    read line1
    read line2
} < $File
echo "第一行:"
echo "$line1"
echo
echo "第二行:"
echo "$line2"
{
    echo "$line1"
} > $File
exit 0

a=3
b=7
echo $[$a+$b] # 10
echo $[$a*$b] # 21

#将a赋值为8
a=(( 5 + 3 ));
#双圆括号也是一种在Bash 中允许使用C 风格的变量处理的机制，注意下面赋值的空格
(( a = 23 ))
(( a++ ))
(( a-- ))
(( t = a<45?7:11 )) # C 风格的3元操作

veg1=carrots
veg2=tomatoes
if [[ "$veg1" < "$veg2" ]]
then :
else :
fi

#打印所有.lst文件，并排序和删除重复行
cat *.lst | sort | uniq

变量的名称是作为其值的占位符，获取其值的操作称为变量替换——使用$前缀执行。在以下情况下，不需要$前缀：变量声明、变量赋值、read、uset、export、((算术表达式))、或者作为代表信号的特殊情况下。在双引号中还是会发生变量替换，这被叫做部分引用，或叫弱引用；在单引号中就不会发生变量替换，这叫做全引用，也叫强引用。

$是${}的简写形式。

未初始化的变量的值为null。使用这样的变量可能出现问题，但是进行算术运算是允许的，相当于0

a=879
echo "The value of \"a\" is $a."
let a=16+5 #使用let赋值
#在for循环中赋值
for a in 7 8 9 11
do
    echo -n "$a "
done
#在read 命令状态中赋值
echo -n "Enter \"a\" "
read a
echo "The value of \"a\" is now $a."
#把echo 命令的结果传给变量a
a=`ls -l`
echo $a #注意，ls命令输出的空白符，包括换行，均消失
echo "$a" #空白符保留
# 命令替换的另外一种形式
a=$(cat /ect/redhat-release)

# 命令替换嵌套，$()形式嵌套了``形式
pid=$(ps `jcmd | awk '{print $1}' ` | grep passport | awk '{print $1}' | head -1)

Bash不区分变量的类型，在本质上所有变量均是字符串。但是在特定上下文下，又作为数字看待。

局部变量：只有在代码块或者函数中可见

环境变量：Shell启动时，创建自己的环境，并影响所有子Shell

位置参数：$0, $1, $2, $3...，其中$0代表脚本文件的名字1-9代表参数${10}代表第10个参数，等等。$*、$@表示所有位置参数的数组。使用shift可以左移参数

#!/bin/bash

# 解析传递给此脚本的参数
# -o 指定短参数，单字符，多个参数连续写在一起，结尾:
# -l 指定长参数，多个参数使用逗号分隔，结尾:
# 此命令修改$@，$N的含义可能发生改变，命令的非选项部分，最好放在前面
getopt -o lc: --long latest,chart:  -- "$@" > /dev/null

LATEST=false
CHART=""

echo '$1'=$1
echo '$2'=$2
echo '$3'=$3
echo '$4'=$4
echo '$5'=$5

while true; do
  case "$1" in
    -l | --latest ) LATEST=true; shift ;;
    -c | --chart )    CHART=$2; shift; shift ;;
    -- ) shift; break ;;
    * ) break ;;
  esac
done

echo LATEST=$LATEST
echo CHART=$CHART

调用上述脚本的示例：

./push.sh  --latest --chart ngress gmem digital
# $1=--latest
# $2=--chart
# $3=ngress
# $4=gmem
# $5=digital
# LATEST=true
# CHART=ngress

./push.sh  --latest  gmem digital
# $1=--latest
# $2=gmem 注意非参数的位置改变
# $3=digital
# $4=
# $5=
# LATEST=true
# CHART=

例如：eval var1=\$$var2

declare 或者typeset 内建命令(这两个命令是完全一样的)允许指定变量的具体类型

引号可以保护字符串的字面值，避免特殊字符被重新解释，或者被Shell扩展

grep '[Ff]irst' *.txt #基于正则式搜索*.txt文件的内容

处理一个或者多个命令的输出，并字面的（literally）将其赋予另外一个上下文（设置变量、作为另外一个命令的参数、甚至生成for循环的列表）。命令替换的典型的语法是反引用包围的命令。命令替换以subshell形式调用

script_name=`basename $0`
echo "The name of this script is $script_name."

textfile_listing=`ls *.txt`
#命令替换的可选语法：textfile_listing=$(ls *.txt)
echo $textfile_listing

#把文件内容赋值给变量
variable1=`<file1`
variable2=`cat file2`
#命令替换可能导致单词分隔
COMMAND `echo a b` #COMMAND有两个参数a、b
COMMAND "`echo a b`" #一个参数 "a b"
COMMAND `echo` #没有参数
COMMAND "`echo`" #一个空参数

VAR=$(command)

ERROR=$(cat file1.txt nofile.txt 2>&1 > /dev/null)

VAR=$(cat file1.txt nofile.txt 2>&1) 

算数扩展提供了强大的整数算术操作机制。

z=`expr $z + 3`
z=$(($z+3))       #双括号，注意不要和命令替换混淆
z=$((z+3))        #双括号中，变量解引用可有可无
let z=z+3
let "z += 3"      #引号允许在变量赋值语句中使用空格 

#下面3种方式均可得到字符串长度
stringZ=abcABC123ABCabc
echo ${#stringZ} # 15
echo `expr length $stringZ` # 15
echo `expr "$stringZ" : '.*'` # 15

expr match "$string" '$substring'    #$substring 是一个正则表达式
expr "$string" : '$substring'        #$substring 是一个正则表达式
#举例
echo `expr match "$stringZ" 'abc[A-Z]*.2'`

#                注意：不要加引号
                 # 前缀匹配              # 后缀匹配
if [[ "$line" == flannel* || "$line" == *$K8S_VERSION ]]; then
  echo $line
fi 

expr index $string $substring    #匹配到子串的第一个字符的位置
#举例
stringZ=abcABC123ABCabc
echo `expr index "$stringZ" C12`   #6

#在string中从位置$position 开始提取子串
#如果$string 为"*"或"@",那么将提取从位置$position 开始的位置参数
${string:position} 

#在string中从位置$position 开始提取$length 长度的子串
${string:position:length}

#举例
stringZ=abcABC123ABCabc
echo ${stringZ:0}     # abcABC123ABCabc
echo ${stringZ:1}     # bcABC123ABCabc
echo ${stringZ:7}     # 23ABCabc
echo ${stringZ:7:3}   # 23A
echo ${stringZ:(-4)}  # Cabc
echo ${*:2}           # Echo 出第2个和后边所有的位置参数
echo ${@:2}           # 与前边相同
echo ${*:2:3}         # 从第2个开始,Echo后边3个位置参数
if [ "${1:0:1}" = '-' ]; then echo " $1 is a option"; fi

#在string中从位置$position开始提取$length 长度的子串
expr substr $string $position $length 
#举例
stringZ=abcABC123ABCabc
echo `expr substr $stringZ 1 2` # ab
echo `expr substr $stringZ 4 3` # ABC

#从$string 的开始位置提取$substring,$substring 是一个正则表达式
expr match "$string" '\($substring\)'
expr "$string" : '\($substring\)'
#举例
stringZ=abcABC123ABCabc
echo `expr match "$stringZ" '\(.[b-c]*[A-Z]..[0-9]\)'` # abcABC1

#从$string 的左边截掉第一个匹配的$substring
${string#substring}
#从$string 的左边截掉最后一个匹配的$substring
${string##substring}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ#a*C} # 123ABCabc   截掉'a'和'C'之间最近的匹配
echo ${stringZ##a*C} # abc        截掉'a'和'C'之间最远的匹配

#从$string 的右边截掉第一个匹配的$substring
${string%substring}
#从$string 的右边截掉最后一个匹配的$substring
${string%%substring}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ%b*c}  # abcABC123ABCa 从$stringZ 的后边开始截掉'b'和'c'之间的最近的匹配

#使用$replacement 来替换第一个匹配的$substring
${string/substring/replacement}
#使用$replacement 来替换所有匹配的$substring
${string//substring/replacement}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ/abc/xyz}  # xyzABC123ABCabc
echo ${stringZ//abc/xyz} # xyzABC123ABCxyz

#如果$substring 匹配$string 的开头部分,那么就用$replacement 来替换$substring
${string/#substring/replacement}
#如果$substring 匹配$string 的结尾部分,那么就用$replacement 来替换$substring
${string/%substring/replacement}
#举例
stringZ=abcABC123ABCabc
echo ${stringZ/#abc/XYZ} # XYZABC123ABCabc
echo ${stringZ/%abc/XYZ} # abcABC123ABCXYZ

exit 命令被用来结束脚本，返回一个值来传给父进程，如果没有exit，则最后执行的命令的exit状态被返回。

每个命令都会返回一个 exit 状态(有时候也叫return 状态)，成功返回0，如果返回一个非0 值，通常情况下都会被认为是一个错误码。

变量：$?用于读取退出码。

一个

if/then

内建命令

[

test

Bash 2.02以后，关键字

[[...]]

[[ $a -lt $b ]]

((...))

let...

[[]]

[]

test EXPRESSION

test

[ EXPRESSION ]

[ ]

[ OPTION

EXPRESSION的语法如下：

# 空白表达式为假


# 如果表达式为真，通过测试（结果为真）
( EXPRESSION )

# 如果表达式为假，通过测试
! EXPRESSION

# 逻辑与
EXPRESSION1 -a EXPRESSION2

# 逻辑或
EXPRESSION1 -o EXPRESSION2

# 字符串长度不为零，通过测试
-n STRING

# 如果字符串长度为零，通过测试
-z STRING

# 字符串比较、文件测试、数字比较见下文

[ "$1" = 'mysqld' -a -n "$CLUSTER_INIT" ]   # 如果第一个参数为mysqld，并且变量CLUSTER_INIT不为空

(( 0 && 1 ))                                # 逻辑与，$?为1
let "num = (( 0 && 1 ))"                    # num的值为0，故$?为1
(( 200 || 11 ))                             # 逻辑或，$? # 0
let "num = (( 200 || 11 ))"                 # num的值为1，故$?为0
(( 200 | 11 ))                              # 按位或，$?为0     
   
# 注意，本行不会打印var变量，因为算术扩展的退出状态不是一个错误码                                  
var=-2 && (( var+=2 )) && echo $var     

# 测试任何命令    
if grep -q Bash file                        
    then echo "At least one Bash in file"
fi
# []或者[[]]测试时，必须与内部表达式之间保留一个空格

# 如果在同一行上边写多个子句，必须使用; 来分隔（注意后面的空格）
if [ ! -x "$filename" ]; then :               #空命令:不执行任何动作
else if [0]; then :
elif [1]; then :                            #elif是else if的简写
fi

# 测试上一个命令的退出码
if [[ $? -eq 0 ]] ; then echo 'Successful'; fi
if [[ $? -eq 0 ]] ; then
    echo 'Succeeded'
    echo 'OK'
else
    echo 'Failed'
fi

# 测试第四个参数是否存在
if [ -z "$4" ] ; then
   echo "Argument 4 not exist"
fi

# 所有内容集中在单行编写的例子
if [[ $? -eq 0 ]]; then echo FOUND; fi
# 使用逻辑与/或
if [[ 1 -eq 1 && 2 eq 2 ]]; then : fi
if [[ 1 -eq 1 ]] || [[ 2 -eq 1 ]]; then : fi

if [ condition1 ]
then
    if [ condition2 ]
    then
    do-something # 这里只有在condition1 和condition2 都可用的时候才行.
    fi
fi

case "$variable" in
"$condition1")         #测试行都以右小括号)结尾
    command...
;;                     #条件块都以两个分号结尾
"$condition1")
    command...
;;
esac
#举例
read Keypress
case "$Keypress" in
[[:lower:]] ) echo "Lowercase letter";;
[[:upper:]] ) echo "Uppercase letter";;
[0-9] )       echo "Digit";;
* )           echo "Punctuation, whitespace, or other";;
esac

#for循环
for arg in [list]
do
    command(s)...
done

默认的分隔符是whitespace，也就是每当遇到分隔符，就会产生新的arg。要修改分隔符为换行，在循环前添加：

IFS=$'\n'

LIMIT=10
for ((a=1, b=1; a <= LIMIT ; a++, b++))
do
    echo -n "$a "
done

# 无限循环
for (( ; ; ))

while [condition]
do
    command...
done

((a = 1))
while (( a <= LIMIT ))
do
    echo -n "$a "
    ((a += 1)) # let "a+=1"
done

until [condition-is-true]
do
    command...
done 

# 无限循环1
while :

# 无限循环2
while true

# 遍历范围
var0=0
LIMIT=10
while [ "$var0" -lt "$LIMIT" ]
do
    echo -n "$var0 "
    var0=`expr $var0 + 1` 
    # var0=$(($var0+1))
    # var0=$((var0 + 1))
    # let "var0 += 1"
done

可以使用管道：

ip route | while read -r route; do
  dest=$(echo $route | awk '{print $1}')
  if [[ "$dest" != *"/"* ]]; then
    continue
  fi
done

注意，某些命令结尾没有\n，这会导致遍历的时候最后一行被略过，需要这样：

{ yourcmd; echo; } | while read -r line; do echo $line; done

# 遍历文件的每一行，注意，echo确保文件不以换行符结尾的情况下，最后一行不丢失
{ cat images.txt; echo; } | while read -r line; do
  if [[ "$src" == "" ]]; then
    continue
  fi
done

使用管道时，while运行在subshell中，缺点是无法修改变量，可以使用Here String规避：

declare -A tgt_service_versions
while read -r line; do
  comp=$(echo "$line" | yq r - '.service_name')
  version=$(echo "$line" | yq r - '.tmplgrp_version')
  tgt_service_versions[$comp]=$version
done <<< "$(yq r global.yaml ".vars.services")"

# 遍历字符串列表，注意，如果字符串加引号，作为整体看待
for planet in Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune Pluto
do
    echo $planet # Each planet on a separate line.
done

# 遍历字符串列表，使用变量
FILES="/usr/sbin/accept
/usr/sbin/pwck
/usr/sbin/chroot
/usr/bin/fakefile
/sbin/badblocks
/sbin/ypbind"
for file in $FILES
do
    if [ ! -e "$file" ]
        break
        continue 1   # 控制循环的行为，数字用于跳出或继续N层循环
    fi
done

# 遍历文件列表。如果列表中包含通配符*?，则会扩展文件名，即file globbing
#   *所有文件
#   [jx]* 所有j或者x开头的文件
for file in *; do ...
for cfg in config/*; do
    if
done

# 遍历参数数组。如果忽略列表，则操作$@
for a
do
    echo -n "$a "
done 

一个内建命令通常与一个系统命令同名，但是Bash 在内部重新实现了这些命令

declare [-aAfFgilnrtux] [-p] [name[=value] ...]

local [option] [name[=value] ...]

eval arg1 ... [argN]

# 方括号内的是作业号
# Running表示正在运行的作业， 它会打印到标准输出
[1]- Running ping www.baidu.com &
# +表示当前作业，如果fg、bg不指定参数，则针对当前作业
# Stopped表示挂起的作业，但是进程并没有退出
[2]+  Stopped                 ping www.163.com
# -表示如果当前作业退出，则它会变成当前作业
[3]-  Stopped                 ping www.qq.com

参见：Linux命令知识集锦

command --args << EOF
...
#注意在这里会发生变量替换，因此需要必要的转义
\$PWD is $PWD
...
...
EOF

# 将Here Document写入到文件
cat << EOF  > /path/to/file
drill.exec: {
  cluster-id: "$CLUSTER_ID",
  zk.connect: "$ZK_CONNECT"
}
EOF

下面两种语法都可以：

cat - <<'EOF'
$KNOWN
EOF
# 输出 $KNOWN

cat - <<\EOF
$KNOWN
EOF

可以看作是Here Document的stripped-down形式。字符串被展开，并逐个喂给命令的stdin：

COMMAND <<< $WORD

示例：

if grep -q "txt" <<< "$VAR"
then
   echo "$VAR contains the substring sequence \"txt\""
fi

String="This is a string of words."
# 将字符串中的每个字符写入为数组元素
read -r -a Words <<< "$String" 

Linux中，有三个文件：stdin、stdout、stderr总是处于打开状态的。这些文件或者任何打开的文件，可以被重定向。所谓重定向，就是捕获来自文件、命令、程序、脚本甚至代码块的输出（output），并将其作为其它文件、命令、程序或者脚本的输入。

#重定向输出到文件，如果不存在，则创建，否则覆盖
ls -lR > dir-tree.list
: > filename     #将文件的内容清空，如果不存在则创建

#重定向输出到文件，如果不存在，则创建，否则附加到文件结尾
ls -lR >> dir-tree.list

1>filename       #把标准输出重定向到文件
2>filename       #把标准错误重定向到文件
&>filename       #把标准输出、错误同时重定向到文件

LOGFILE=script.log
echo "命令的输出被重定向到文件描述符" 1>$LOGFILE
echo "命令的错误被重附加到文件描述符" 2>>$LOGFILE

2>&1             #把标准错误重定向到标准输出
i>&j             #重定向文件描述符i到文件描述符j
>&j              #重定向默认文件描述符（1，stdout）到j

0< FILENAME      #从文件读取输入

[j]<>filename    #打开文件进行读写，并分配文件描述符j
exec 3<> File    #打开File，并分配3位文件描述符
read -n 4 <&3    #从文件描述符3读入4字符
echo -n . >&3    #输出一个小数点到文件描述符3
exec 3>&-        #关闭文件描述符3

n<&-             #关闭输入文件描述符n
0<&-, <&-        #关闭标准输入
n>&-             #关闭输出文件描述符n
1>&-, >&-        #关闭标准输出

while [ "$name" != Smith ]
do
    read name
    echo $name
    let "count += 1"
done <"$Filename"#重定向代码块的输入

Subshell指Shell发动的子进程。一般的，外部命令会发动子Shell，而内置命令则不会，此外，括号包含的命令列表发动Subshell：

( command1; command2; command3; ... )

#Subshell可用于构建专用运行环境
COMMAND1
COMMAND2
COMMAND3
(
    IFS=:
    PATH=/bin
    unset TERMINFO
    set -C
    shift 5
    COMMAND4
    COMMAND5
    exit 3 #这里只会退出Subshell
)

 Subshell中的变量，在代码块以外无法访问，相当于局部变量。

在受限模式下运行的Shell，一些命令被禁用：

1. 使用cd改变当前目录
2. 修改环境变量$PATH, $SHELL, $BASH_ENV,  $ENV
3. 读取或者改变$SHELLOPTS
4. 重定向输出
5. 调用包含/符号的命令
6. 调用exec命令来替换Shell的进程
7. 解除受限模式
8. 其它一些命令

使用set -r、set --restricted开启脚本受限模式。

进程替换把一些进程的输出作为其它进程的输入来使用。命令格式如下（使用括号包围），注意没有空格：

>(command_list)
<(command_list)

函数语法：

function function_name {
    command...
}
#第二种语法支持C-Style
function_name () {
    if [ -z "$1" ] #$1表示第一个参数
    then
        echo "-Parameter #1 is zero length.-"
    else
        echo "-Param #1 is \"$1\".-"
    fi
}
#调用函数
function_name 
function_name $arg1 $arg2  #传参，只支持传值方式，可以使用间接引用来传引用
#支持函数嵌套
f1 ()
{
    f2 () # nested
    {
        echo "Function \"f2\", inside \"f1\"."
    }
}

 函数的退出：函数返回一个值，称为exit status，这与命令退出码类似。可以使用return语句指定返回值，否则，最后一条命令的退出码作为返回值。

Bash别名可以简单的看作一个键盘快捷方式：

alias ll="ls -l"

and list：如果前一个命令的退出码为0，则继续执行后面的命令

command-1 && command-2 && command-3 && ... command-n

 or list：如果前一个命令退出码味非0，则继续执行后面的命令

command-1 || command-2 || command-3 || ... command-n

较新版本的Bash支持一维数组，数组元素以

variable[xx]

${element[xx]}

area[11]=23
area[13]=37
area[51]=UFOs

echo ${area[11]}
area[5]=`expr ${area[11]} + ${area[13]}`

area2=( zero one two three four )
area3=([17]=seventeen [24]=twenty-four)
base64_charset=( {A..Z} {a..z} {0..9} + / = )

没有下标的索引点，不会占用元素个数：

adobe=([0]='Flash' [2]='Flex' [4]='Photoshop')
echo ${#adobe[@]}
# 打印 3 

可以使用表达式：

${array[@]}

# 声明一个数组，它的元素来自DOCKER数组的所有成员 +
#                                    run字面之 +
#                                         docker_run_opts数组的所有成员 +
#                                                                KUBE_BUILD_IMAGE 变量
local -ra docker_cmd=("${DOCKER[@]}" run "${docker_run_opts[@]}" "${KUBE_BUILD_IMAGE}")

通过扩展操作，可以连接两个数组：

adobe=('Flash' 'Flex' 'Photoshop' 'Dreamweaver' 'Premiere')
adobe2=('Fireworks' 'Illustrator')
adobe3=(${adobe[@]} ${adobe2[@]}) 

adobe=('Flash' 'Flex' 'Photoshop' 'Dreamweaver' 'Premiere')
echo ${adobe[@]:1:3}
# 打印 Flex Photoshop Dreamweaver
echo ${adobe[@]:3}
# 打印 Dreamweaver Premiere

names=(`cat 'names.txt'`)

adobe=('Flash' 'Flex' 'Photoshop' 'Dreamweaver' 'Premiere')

for item in ${adobe[@]};do
	echo $item
done

len=${#adobe[@]}
for ((i=0;i<$len;i++));do
	echo ${adobe[$i]}
done 

关联数组也就是字典/映射，声明语法：

declare -A archMap=(
  [x86_64]=amd64
  [aarch64]=arm64
)

${#filetypes[*]}
${#filetypes[@]}

archMap[arm64]=aarch64 

arch=x86_64
${archMap[$arch]}

# 使用*，并且整个表达式用双引号包围，则结果是一个字符串
${!filetypes[*]}
# 使用@，并且整个表达式用双引号包围，则结果是一个数组
${!filetypes[@]}

# 使用*，并且整个表达式用双引号包围，则结果是一个字符串
"${filetypes[*]}"
# 使用@，并且整个表达式用双引号包围，则结果是一个数组
${filetypes[@]}

for key in "${!filetypes[@]}"; do 
  echo ${filetypes[$key]}
done

Unix、Linux的文件系统中，通常都有这两个特殊用途的子目录。

包含设备文件（device files），包括环回文件（loopback devices，例如/dev/loop0。所谓环回文件是一种虚拟机制，可以将一个普通文件作为块设备访问）。此目录下还包含若干常用的伪设备：/dev/null, /dev/zero,/dev/urandom, /dev/sda1, /dev/udp,/dev/tcp。

/dev/null：相当于一个黑洞，可以用于忽略输出：

#忽略命令的输出
cat $filename >/dev/null
#忽略命令的错误
rm $badname 2>/dev/null

#从中无法读取到任何东西，可以用于清空文件内容
cat /dev/null > /var/log/messages

 /dev/zero：该设备制造二进制0，主要用于生成交换文件

当在/dev/tcp/$host/$port这样的伪设备上执行命令时，Bash会打开一个TCP连接：

#从time.nist.gov获取时间
cat /dev/tcp/www.net.cn/80
echo -e "GET / HTTP/1.0\n" >&5
cat <&5

该目录中的文件是当前系统中正在运行的系统和内核进程的镜像，包含了运行时和统计信息。可以获取CPU、内存、电池等多种组件的信息。

关于Linux信号相关的知识，参考Linux信号、进程和会话

注意：如果存在正在运行的子进程，Bash默认会忽略发送给父进程的信号。

当你在终端窗口按下Ctrl + C或者Break键后，正常情况下应用程序会立即停止。但是你可以在脚本中指定信号处理函数。其格式为：

# arg默认为 - 表示捕获到信号时，需要执行的命令
trap [-lp] [[arg] sigspec ...]

示例用法：

# 列出信号名称和编号的对应关系
trap -l

# 接收到HUP INT PIPE QUIT TERM这几种信号时，执行exit 1命令
trap "exit 1" HUP INT PIPE QUIT TERM

# 也可以指定函数来处理信号
sighdl() {
}
trap sighdl SIGTERM

# 重置信号的默认处理逻辑
trap 1 2

# 忽略信号
trap '' 1

当进程收到信号后，在同一线程中发生以下事件序列：

1. 当前进程正在进行的内置命令（不产生子进程）立即退出
2. 程序转到trap指定的信号处理脚本执行
3. 执行完毕后，到被中断的命令的下一行执行

例如下面的脚本：

trap "echo TRAPED" HUP INT PIPE QUIT TERM
while true; do :; done

当按下Ctrl + C后，信号处理脚本运行，但是然后会继续循环，程序无法停止。下面的代码则可以正常工作：

sighdl() {
    echo TRAPED
    TERM_FLAG=1
}
trap sighdl HUP INT PIPE QUIT TERM

while [ "$TERM_FLAG" != "1" ] ; do :; done 

设置选项

set -o errexit

set -e

要捕获这个信号，你需要选项

set -o errexit -o errtrace

set -eE

# 出错时清理后台进程
trap 'kill $(jobs -p)' ERR

# 分割字符串 1,2,3,4,5,6,7,8,9,10
# IFS指定基于什么符号拆分，这里是逗号
IFS=',' read -ra ARRAY <<< `seq -s ',' 10`
for i in "${ARRAY[@]}"; do
    # 遍历分割后的子串
    echo $i 
done

可以使用Glob：

if [[ $line = *"Server startup in"* ]]; then ...

#!/bin/bash
shopt -s globstar
for file in ./*.go ./**/*.go ; do
	echo $file
done

./*

./**/*

exec 2> /var/log/on-startup.log   # 将当前脚本的标准错误重定向到文件
exec 1>&2                         # 将当前脚本的标准输出重定向到标准错误
set -x

echo >&2 "ERROR: "

如果你读取标准输入，并且循环处理：

while read p; do
  cmd $p
done < input.file

当循环体中的命令cmd也会读取标准输入时，上述循环会立即退出。

解决办法：

for p in `cat input.file`
do
  cmd $p
done

报错信息：Permission denied

解决办法：

sudo sh -c "echo '' > $LOG"

如果在管道的某个命令中需要退出处理，你需要显式的关闭管道中的其它命令（Subshell），简单的例子：

tail -f /usr/local/$TOMCAT_PATH/logs/catalina.out | while read line
do
    if [[ $line = *"Server startup in"*  ]]; then
          # 找到管道前面的命令tail，并杀死
          TAIL_PID=`ps --ppid $PID  | grep tail | awk '{print $1}'`
          echo "Killing subprocess $TAIL_PID"
          kill -9 $TAIL_PID
          exit 0
    fi
done

如果管道由很多命令组成，可以将它们放置到同一进程组中，然后向进程组发送信号，一起终结它们：

# 项目的命令启用Job控制，导致后台进程运行在独立的进程组
set -m

tail -Fn0 /tmp/report | while :
do 
    echo "pre"
    # 向后台进程组发送信号，使其中的所有进程终结
    sh -c 'PGID=$( ps -o pgid= $$ | tr -d \  ); kill -TERM -$PGID'
    echo "past"
done &  # 在后台运行
wait    # 等待上述后台任务退出 

pushd `dirname $0` > /dev/null
SCRIPT_DIR=`pwd`
popd > /dev/null

单引号字符串默认是禁止转义的，如果其中包含成对的单引号本身，会自动被忽略。

echo '''a'''    # a

 如果其中包含的单引号不成对，属于语法错误。如果要在单引号字符串中使用单引号本身，可以：

echo  $'\'a\''

即，在字符串前面加上特殊符号$，即可启用ANSI C风格的转义

#跨行编写的多行字符串变量
mls="
line 1
line 2
line 3
"

#echo的默认行为是把换行符修改为空格输出
echo $mls
#输出：line 1 line 2 line 3

#目标变量外面加上引号，则可避免此默认行为
echo "$mls"
#输出：
#
#line 1
#line 2
#line 3
#
#可以看到，首尾有空白行，这分别是第一个"后的空白行，以及line3后面的空白行

#行尾加上反斜杠，可以把相邻的两行作为单行看待：
mls="\
line 1
line 2
line 3\
"
#再执行echo "$mls"，就不会有空白行了：
#line 1
#line 2
#line 3

mls="\
line 1
line 2\n
line 3\
"
#默认的，反斜杠转义是不被echo命令启用的，除非指定-e
#执行echo -e  "$mls"，会发现\n被转义为换行输出:
#line 1
#line 2

#line 3

#可以使用 $'\n' 把新行添加到变量尾部
mls="$mls"$'\n'"line 4"

#使用Here Document捕获多行文本到变量
read -d '' mls << EOF
line 1git-study-note
line 2
line 3
EOF
#首尾不会出现空行
echo "$mls"

The post Bash学习笔记 appeared first on 绿色记忆.