Shell

Dynamic scoping means that variable lookups occur in the scope where a function is called, not where it is defined.

#!/bin/bash

#### bash动态作用域测试
value=1
function foo () {
    echo $value;
}
function bar () {
    local value=2;
    foo;
}

bar         # 由于bash采用动态作用域，这里会输出2，而不是1。

双引号中的变量引用会被替换为变量的值。单引号中的内容都是字面量。

不用引号时，变量中的连续多个空格仅会保留一个。

#!/usr/bin/env bash

var1='A B   C'
echo "$var1"     # output: A B   C
echo '$var1'     # output: $var1
echo $var1       # output: A B C

Bash 中 $'string' （和转义相关）和 $"string" （和 i18n 相关）有特殊含义。

其中，$'string' 称为 ANSI-C Quoting，实例：

~$ echo 'ab\ncd'
ab\ncd
~$ echo "ab\ncd"
ab\ncd
$ echo $'ab\ncd'
ab
cd

参考：
http://wiki.bash-hackers.org/syntax/quoting
https://www.gnu.org/software/bash/manual/bashref.html#ANSI_002dC-Quoting

declare 和 typeset 作用相同，都用来声明变量的属性。typeset 来自 ksh，要兼容 ksh 应该使用 typeset.

#!/usr/bin/env bash
var1=6/3
declare -i var2
var2=6/3

echo "var1 = $var1"       # output: var1 = 6/3
echo "var2 = $var2"       # output: var2 = 2

参考：
http://www.tldp.org/LDP/abs/html/declareref.html

Shell 中位置参数和特殊参数如表 1 所示。

下面是数组变量的使用实例：

$ my_array=(foo bar)                              # my_array 是数组变量
$ for i in "${my_array[@]}"; do echo "$i"; done   # 遍历 my_array
foo
bar
$ my_array+=(baz)                                 # 往数组中增加元素
$ for i in "${my_array[@]}"; do echo "$i"; done
foo
bar
baz

参考：
https://tldp.org/LDP/Bash-Beginners-Guide/html/Bash-Beginners-Guide.html#sect_10_02
https://linuxconfig.org/how-to-use-arrays-in-bash-script

while 语法如下：

while test-commands; do
  consequent-commands
done

只要 test-commands 返回零就执行 consequent-commands。其返回值是命令块中最后一个被执行的命令的返回值。如果命令块没有被执行则返回零。

下面是个无限循环的例子：

while true
do
  echo "Press [CTRL+C] to stop.."
  sleep 1
done

如果要写为一行，则可以这样：

while true; do echo 'Hit CTRL+C'; sleep 1; done

until 语法如下：

until test-commands; do
  consequent-commands
done

只要 test-commands 返回非零值就执行 consequent-commands。
其返回值是命令块中最后一个被执行的命令的返回值。如果命令块没有被执行则返回零。

for 语法如下：

# style 1
for arg [in list]; do
  commands
done

# style 2 (like C-style)
for (( expr1 ; expr2 ; expr3 )) ; do
  commands
done

第 1 种 for 循环形式，list 中的每个元素都会赋值给 arg 并执行一次命令块。省略 in list 时相当于 in "$@"。
其返回值是命令块中最后一个被执行的命令的返回值。如果对 list 的扩展没有得到任何元素，则不执行任何命令，并返回零。

下面是第 1 种形式的例子：

#!/bin/bash

fun1()
{
#   for循环中省略了in list，相当于
#   for var in "$@"
    for var
    do
        echo -n "$var "
    done
}

fun1 a b c d   # output: "a b c d "

第 2 种 for 循环形式，对算术表达式 expr1 进行求值，然后不断的对算术表达式 expr2 进行求值，直到其结果为零。每次求值时，如果 expr2 的值不是零，则执行一次命令块，并且计算算术表达式 exp3 的值。
其返回值是命令块中最后一个被执行的命令的返回值。如果表达式的值都是假的，则返回假。

下面是第 2 种形式的例子：

#!/bin/bash

for ((i=1; i<=100; i++)); do
    echo $i
done

if 语法如下：

if test-commands; then
  consequent-commands;
[elif more-test-commands; then
  more-consequents;]
[else alternate-consequents;]
fi

如果 test-commands 返回 0，就会执行 consequent-commands。

case 语法如下：

case word in
  [ [(] pattern [ | pattern ] ... ) list ;; ] ...
esac

pattern 左侧的小括号可省略，多个 pattern 可用 | 分隔。 如：

case word in
 ( pattern1 )
   commands
 ;;
 pattern2 | pattern3 )
   commands
 ;;
esac

select 来自于 ksh，用来生成选择菜单，提示用户选择指定的选项。 语法几乎和 for 一样。
select 直到遇到 break 语句才结束。
select 使用 PS3 作为提示符。

#!/bin/bash

PS3='Choose your favorite vegetable: ' # Sets the prompt string.
                                       # Otherwise it defaults to #? .

select vegetable in "beans" "carrots" "potatoes" "onions" "rutabagas"
do
  echo
  echo "Your favorite veggie is $vegetable."
  break  # What happens if there is no 'break' here?
done

执行上面脚本时，会把 select 中 in 后的选项自动编号，提示用户选择。如：

$ bash test.sh
1) beans
2) carrots
3) potatoes
4) onions
5) rutabagas
Choose your favorite vegetable: 2

Your favorite veggie is carrots.

当然不用 select，用 read 和 case 也能实现类似的功能，如：

!#/bin/bash
echo "select the operation:"
echo "1) operation 1"
echo "2) operation 2"
echo "3) operation 3"

read n
case $n in
    1) commands for operation 1;;
    2) commands for operation 2;;
    3) commands for operation 3;;
    *) invalid option;;
esac

break 和 continue 可用在 for, while, until 和 select 语句中。
The break command terminates the loop (breaks out of it), while continue causes a jump to the next iteration of the loop, skipping all the remaining commands in that particular loop cycle.

break 和 continue 后面都可以跟一个数字，表示要操作几层循环。
如，不跟数字时表示操作最里层循环：

#!/bin/bash
# break-levels.sh: Breaking out of loops.

# "break N" breaks out of N level loops.

for outerloop in 1 2 3 4 5
do
  echo -n "Group $outerloop:   "

  # --------------------------------------------------------
  for innerloop in 1 2 3 4 5
  do
    echo -n "$innerloop "

    if [ "$innerloop" -eq 3 ]
    then
      break  # Try   break 2   to see what happens.
             # ("Breaks" out of both inner and outer loops.)
    fi
  done
  # --------------------------------------------------------

  echo
done

上面例子会输出：

Group 1:   1 2 3
Group 2:   1 2 3
Group 3:   1 2 3
Group 4:   1 2 3
Group 5:   1 2 3

如果把前面例子中的 break 换成 break 2 ，则 break 会对 2 层循环（内层循环和外层循环）都有效，前面例子会输出：

Group 1:   1 2 3

参考：
http://tldp.org/LDP/abs/html/loopcontrol.html

通过 grep 可能得到多行输出，可把它通过管道传给 while 对每一行进行处理，如：

grep foo file.txt | while IFS='' read -r line; do
    echo "Processing [$line]"
    # your code goes here
    # 管道中的 while 在 subshell 中执行，这里的修改不会影响父进程
done

如果想在 while 中对父进程的变量进行操作，则可以使用进程替换（参考节 11），如：

while IFS='' read -r line; do
    echo "Processing [$line]"
    # your code goes here
    # while 直接在当前进程中执行，修改会影响父进程
done < <(grep foo file.txt)

说明：

1. read 前面指定 IFS='' 表示“不删除 line 前后的空格”（默认会删除前后空格）；如果你希望删除 line 前后空格，则可以不指定 IFS='' 。
   
2. read 的 -r 选项是 raw 的意思，表示“原封不动”地保留转义符 \ 。
   

&& 和 || 分别表示“和”和“或”。

如果使用 [[ ，则 && 和 || 可以在括号内或者括号外。

if [[ expression ]] && [[ expression ]] || [[ expression ]] ; then

They can also be used within a single [[ ]]:
if [[ expression && expression || expression ]] ; then

And, finally, you can group them to ensure order of evaluation:
if [[ expression && ( expression || expression ) ]] ; then

如果使用 [ ，则 && 和 || 只能在括号外，如果放在括号内则报语法错误。

if [ -n "$var" ] && [ -e "$var" ]; then
   echo "\$var is not null and a file named $var exists!"
fi

$ if [ -n "/tmp" && -d "/tmp"]; then echo true; fi # Does not work
-bash: syntax error near unexpected token `then'

[ 和 test 是一样的，仅在用法的形式上有区别。它们都是 POSIX 要求的。

if test -z "$a"; then
    echo "test."
fi

## 相当于：
if [ -z "$a" ]; then
    echo "test."
fi

[[ 的功能更加强大，Bash，Korn shell 中可用。
比如， [[ 可支持把逻辑操作符 ||, && 等放入在 [[]] 中间，而 [ 不支持。

参考：http://mywiki.wooledge.org/BashFAQ/031

大括号里用逗号分隔的各个单词会被展开，如： cp file{,.bk} 相当于 cp file file.bk

Bash 中参数展开（Parameter Expansion）如表 2 所示。

注 1：一般情况下 str 的值不会被修改，仅当使用=时，才有可能修改 str 的值。
注 2：一般情况下会使用对应的带冒号形式。 使用冒号形式时，当 str 为 unset 或 null 时，其行为是相同的。
注 3：使用不带冒号的形式时，只检测 str 是不是设置过。str 为 null 或 non-null 的行为一样。

${string:position}
Extracts substring from $string at $position.

If the $string parameter is "*" or "@", then this extracts the positional parameters, starting at $position.

${string:position:length}
Extracts $length characters of substring from $string at $position.

If the $string parameter is "*" or "@", then this extracts a maximum of $length positional parameters, starting at $position.

#!/bin/bash

stringZ=abcABC123ABCabc
#       0123456789.....
#       0-based indexing.

echo ${stringZ:0}                            # abcABC123ABCabc
echo ${stringZ:1}                            # bcABC123ABCabc
echo ${stringZ:7}                            # 23ABCabc

echo ${stringZ:7:3}                          # 23A

# Is it possible to index from the right end of the string?

echo ${stringZ:-4}                           # abcABC123ABCabc
# Defaults to full string, as in ${parameter:-default}.
# However . . .

echo ${stringZ:(-4)}                         # Cabc
echo ${stringZ: -4}                          # Cabc
# Now, it works.
# Parentheses or added space "escape" the position parameter.

# Thank you, Dan Jacobson, for pointing this out.

用 GNU coreutils 中的工具 expr 也能实现类似的功能。
注意：bash 的 Substring Expansion 中第 1 个元素下标为 0，而 expr substr 的第 1 个元素下标为 1。

#!/bin/bash

stringZ=abcABC123ABCabc
#       123456789......
#       1-based indexing.

echo `expr substr $stringZ 1 2`              # ab
echo `expr substr $stringZ 4 3`              # ABC

参考：
http://www.tldp.org/LDP/abs/html/string-manipulation.html#AWKSTRINGMANIP
http://www.gnu.org/software/bash/manual/bashref.html#Shell-Parameter-Expansion

Bash 支持从字符串中删除部分内容，如表 3 所示的。

注 1：word 中支持'*' (Matches any string), '?' (Matches any single character), '[...]' (Matches any one of the enclosed characters)。
注 2：#从前往后删；%从后往前删；两个叠加就是匹配“最长”。

#!/bin/bash
stringZ=abcABC123ABCabc
#       |----|          shortest
#       |----------|    longest

echo ${stringZ#a*C}      # 123ABCabc
# Strip out shortest match between 'a' and 'C'.

echo ${stringZ##a*C}     # abc
# Strip out longest match between 'a' and 'C'.

# You can parameterize the substrings.
X='a*C'

echo ${stringZ#$X}      # 123ABCabc
echo ${stringZ##$X}     # abc
                        # As above.

Bash 支持从字符串中替换部分内容，如表 4 所示。

函数体内可以使用 return 语句返回，如果省略 return 语句，那么函数中最后一个命令的退出码将作为函数的返回码。

return 语句后面只能是 0 到 255 的整数（不能是字符串等其他内容），使用 $? 可以获得函数的返回值，如：

fun1() {
    # something
    return 2
}

fun1
retval=$?

echo $retval    # 2

return 不一定用在函数体内，可也以用在 sourced script 中。其帮助文档如下：

$ help return
return: return [n]
    Return from a shell function.

    Causes a function or sourced script to exit with the return value
    specified by N.  If N is omitted, the return status is that of the
    last command executed within the function or script.

    Exit Status:
    Returns N, or failure if the shell is not executing a function or script.

在 man bash 的文档中，有这样的描述：
When local is used within a function, it causes the variable name to have a visible scope restricted to that function and its children.

#!/bin/bash

recurse1()
{
    local x=$1
    echo "rec1 hit1" $x
    if [ $1 -lt 3 ]; then
        recurse1 $(($1 + 1))
    fi
    echo "rec1 hit2" $x
    # 变量x是local的，递归调用时下层的recurse1不会修改它。
}

recurse2()
{
    x=$1
    echo "rec2 hit1" $x
    if [ $1 -lt 3 ]; then
        recurse2 $(($1 + 1))
    fi
    echo "rec2 hit2" $x
    # 变量x没有声明为local，递归调用时被下层的recurse2修改了。
    # 在这之后，引用x时应该注意它已经不是之前的值了。
}

recurse1 1
echo '---------------'

recurse2 1
echo '---------------'

#### Output:
## rec1 hit1 1
## rec1 hit1 2
## rec1 hit1 3
## rec1 hit2 3
## rec1 hit2 2
## rec1 hit2 1
## ---------------
## rec2 hit1 1
## rec2 hit1 2
## rec2 hit1 3
## rec2 hit2 3
## rec2 hit2 3
## rec2 hit2 3
## ---------------

说明：使用 typeset 也可以在函数体内定义局部变量，但这种写法已经是过时的。

参考：
http://www.tldp.org/LDP/abs/html/localvar.html

bash 中允许定义嵌套函数，它的用处不大。

#!/bin/bash

f1 ()
{

  f2 () # nested
  {
    echo "Function \"f2\", inside \"f1\"."
  }

}

f2  #  Gives an error message.
    #  Even a preceding "declare -f f2" wouldn't help.

echo

f1  #  Does nothing, since calling "f1" does not automatically call "f2".
f2  #  Now, it's all right to call "f2",
    #+ since its definition has been made visible by calling "f1".

    # Thanks, S.C.

参考：http://www.tldp.org/LDP/abs/html/functions.html

在 bash 中定义了一个变量，如何通过调用一个函数来修改这个变量？如果在 C 语言中，则容易实现，把变量的地址传给函数能实现。

在 bash 中，可以通过 eval 实现。

#!/bin/bash
fun1() {
eval $1="bb"
}

var1="aa"
echo ${var1}
fun1 var1
echo ${var1}

执行上面脚本，会输出：

aa
bb

#!/bin/bash

echo 1234567890 > File    # Write string to "File".
exec 3<> File             # Open "File" and assign fd 3 to it.
read -n 4 <&3             # Read only 4 characters.
echo -n . >&3             # Write a decimal point there.
exec 3>&-                 # Close fd 3.
cat File                  # ==> 1234.67890

参考：http://www.tldp.org/LDP/abs/html/io-redirection.html

方法 1：

command >file1 2>&1

说明：不要写 command 2>&1 >file1，它仅相当于 command >file1，因为 2>&1 执行时 stdout 指向的是屏幕。

方法 2：

command  &>file1

方法 3：

command  >&file1

注：尽量不要用方法 3 的方式，它在形式上看起来很奇怪，因为只有用 fd 表示文件时才在文件前加符号&。

要把 stdout 和 stderr 以追加方式重定向到另一文件，可以使用下面两种方式中的一种：

command &>> file2          # 方式一
command >>file2 2>&1       # 方法二

在 EOF 前加一个连字符，表示忽略 here document 中开头的 tabs（空格会保留）

cat <<-EOF
	"leading tab(s) would be removed."
EOF

把 EOF 用单引号括起来，表示不解释 here documents 中的变量。

#!/bin/bash
a=test

cat <<EOF
echo ${a}
EOF

cat <<EOF
echo \${a}
EOF

cat <<'EOF'
echo ${a}
EOF

执行上面脚本会输出：

echo test
echo ${a}
echo ${a}

A here string can be considered as a stripped-down form of a here document.
It consists of nothing more than COMMAND <<< $WORD, where $WORD is expanded and fed to the stdin of COMMAND.

如：

$ sed 's/a/b/g' <<< "aaa"
bbb

又如：

$ read first second <<< "hello world"
$ echo $second $first
world hello

参考：http://www.tldp.org/LDP/abs/html/x17837.html

man bash 中有所有内置命令的说明，但内容太多，不易快速找到想要的内容。要精确找到内置命令的帮助文档，可用 help 命令，如： help test 可查看内置命令 test 的帮助文档；又如 help ulimit 可查看内置命令 ulimit 的帮助文档。

ulimit 可用于控制 shell 以及其派生的子进程的资源使用。

有两种类型的限制 soft 限制和 hard 限制。其中 soft 限制是当前的限制；而 hard 限制是软限制的上限值，也就是说 soft 限制不能超过 hard 限制。

$ . filename [arguments]
$ source filename [arguments]        # same as above

Read and execute commands from the filename argument in the current shell context. This builtin is equivalent to source.

set 有两个作用。一是用来打开或关闭 bash 的选项。二是用来设置位置参数。

用 set 打开或关闭 bash 的选项本文其它部分已经介绍，这里仅介绍它不常使用的设置位置参数的功能。

#!/bin/bash
fun1() {
set a b c d
echo $1 $2 $3 $4
}

fun1

上面例子中，不管给 fun1 传递什么参数，都会输出 a b c d，因为 set 重置了它的位置参数。

exec 的语法格式为：
exec [-cl] [-a name] [file [redirection ...]]
exec 用 file 代替当前进程，并执行；如果 file 没有指定，则可以通过重定向来影响当前的 shell 环境。

即 exec 有两个功能。 一是在当前进程中执行命令。二是修改当前 shell 的文件描述符。

trap 语法：
trap [COMMANDS] [SIGNALS]
可以捕捉信号，并执行指定的动作。

被捕捉的 SIGNALS，可以通过 kill -l 查看，即可直接写数字，也可以写名字。
如，下面两个语句的作用是一样的：

trap '' 1
trap '' SIGHUP

除了 kill -l 列出的信号外，还可以捕捉 EXIT(0), DEBUG, ERR

$ cat 1.sh
trap "echo Goodbye" EXIT
echo "hello"

$ bash 1.sh
hello
Goodbye

http://www.tldp.org/LDP/Bash-Beginners-Guide/html/sect_12_02.html

查看选项，用 set -o 即可，如：

$ set -o
allexport      	off
braceexpand    	on
emacs          	on
errexit        	off
errtrace       	off
functrace      	off
hashall        	on
histexpand     	on
history        	on
ignoreeof      	off
interactive-comments	on
keyword        	off
monitor        	on
noclobber      	off
noexec         	off
noglob         	off
nolog          	off
notify         	off
nounset        	off
onecmd         	off
physical       	off
pipefail       	off
posix          	off
privileged     	off
verbose        	off
vi             	off
xtrace         	off

打开和关闭选项：

$ set -o option-name        # 打开选项
$ set +o option-name        # 关闭选项，如 set +o emacs 可关闭 emacs 风格的行内编辑器

打开一个选项，还有好几种方法，总结如下：
方法 1：set -o option-name
例如：

#!/bin/bash
set -o verbose              # 设置这个选项，每个命令在执行前会先显示出来。

方法 2：set -option-abbrev
直接用 option 的缩写，比较简单，例如：

#!/bin/bash
set -v                       # 和前面的作用一样。

方法 3：运行脚本时指定（注意：它又有好几种形式）

bash -v script-file
bash -o verbose script-file
bash --verbose script-file

方法 4：在脚本第一行 #! 头中指定

#!/bin/bash -v

注意：要使方法 4 有效，必须给脚本赋予可执行权限后直接执行，如 $ ./1.sh ，而不能把脚本作为 bash 参数执行，如 bash 1.sh 这样执行是不会生效的。

http://www.tldp.org/LDP/abs/html/options.html

建议 bash 脚本中使用：

#!/usr/bin/env bash

set -euo pipefail

它是下面 3 个选项的缩写：

set -e                  # 等价于 set -o errexit，表示如果某命令（有例外情况，后面介绍）的 exit code 不是 0，就退出脚本
set -u                  # 等价于 set -o nounset，表示如果使用没有定义的变量会输出错误，并退出脚本
set -o pipefail         # 表示管道中只要一个子命令失败，整个管道命令就失败

后面分别介绍一下这 3 个选项。

bash 中还有很多选项可通过命令 shopt 来控制。

查看所有可用 shopt 设置的选项的当前状态：

$ shopt

打开选项（以 extglob 为例）：

$ shopt -s extglob

关闭选项（以 extglob 为例）：

$ shopt -u　extglob

详细列表参见：
http://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html

下面代码片断将检测程序“/home/user1/my_app”是否正在运行：

 1:     exe_dir=/home/user1
 2:     running=0
 3:     for pid in $(pgrep my_app); do
 4:         full_path=$(readlink /proc/$pid/exe)
 5:         # 如果 /home/user1/my_app 启动后，改文件被删除或者被更新，则
 6:         # readlink /proc/$pid/exe 的输出会以 ' (deleted)' 结尾
 7:         # 下面将通过 sed 将尾部的 ' (deleted)' 删除
 8:         full_path=$(echo $full_path |sed 's/ (deleted)$//')
 9:         if [[ $full_path == ${exe_dir}/my_app ]]; then
10:             running=1
11:         fi
12:     done
13:     if [[ $running -eq 1 ]]; then
14:         echo "/home/user1/my_app is running"
15:     fi

注：pgrep 仅会检测进程名字的“前 15 个字符”，所以当程序名字超过 15 个字符时上面代码会失效。比如你检测的程序是 “/home/user1/my_ap012345678901234”，那么上面代码的第 3 行 pgrep my_ap0123456789 是找不到相关进程的！要修复这个问题，可以改为 pgrep my_ap0123456789 （只留前 15 个字符）。

用下面脚本可检测程序是否在 PATH 中。

if command -v foo >/dev/null 2>&1; then
    echo "foo exists."
fi

Command command is POSIX compliant, see here for its specification: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/command.html

参考：http://stackoverflow.com/questions/592620/how-to-check-if-a-program-exists-from-a-bash-script

在 while 循环中用 read 命令可以分析 CSV 格式文件。
说明：通过 IFS 可以指定 CSV 文件的分隔符，如果指定 IFS 在 read 命令前（如下面例子所示），则 IFS 只会影响 read 命令，不会影响到后面的代码。

#! /bin/bash

while IFS=: read user pass uid gid full home shell
do
    echo -e "$full :\n\
 Pseudo : $user\n\
 UID :\t $uid\n\
 GID :\t $gid\n\
 Home :\t $home\n\
 Shell :\t $shell\n\n"
done < /etc/passwd

参考：
http://stackoverflow.com/questions/10929453/read-a-file-line-by-line-assigning-the-value-to-a-variable
http://ccm.net/faq/1757-how-to-read-a-linux-file-line-by-line
http://unix.stackexchange.com/questions/18922/in-while-ifs-read-why-does-ifs-have-no-effect

如何删除当前目录中除 *.iso 和 *.zip 外的所有文件？

方法 1：

$ shopt -s extglob     # 确认开启 extglob 选项
$ rm !(*.iso|*.zip)

注意：如果没有开启(在 shopt -s 输出中找不到 extglob)，则可用 shopt -s extglob 开启 extglob 选项！

方法 2：

$ export GLOBIGNORE=*.zip:*.iso
$ rm *
$ unset GLOBIGNORE

方法 3 (这个方法比较通用，zsh 等中也能使用)：

$ find . -type f -not \( -name '*.zip' -or -name '*.iso' \) -delete

参考：http://www.linuxeden.com/html/softuse/20140606/152379.html

在 bash 中求字符串长度有如下几种方法：
${#string}
`expr length $string`
`expr "$string" : '.*'`

测试如下：

#!/bin/bash
stringZ=abcABC123ABCabc

echo ${#stringZ}                 # 15
echo `expr length $stringZ`      # 15
echo `expr "$stringZ" : '.*'`    # 15

使用 tr 可以把字符串转换为小写：

$ echo "ABc" | tr '[:upper:]' '[:lower:]'     # Posix 兼容
abc

使用 awk 也可以把字符串转换为小写：

$ echo "ABc" | awk '{print tolower($0)}'      # Posix 兼容
abc

如果使用 bash 4.0+，则可以这样把字符串转换为小写：

$ a=ABc
$ echo "${a,,}"                               # 仅 bash 4.0+ 才工作
abc

有多种方式可以进行算术运算。

方法 1：利用 expr ，如

$ expr 3 + 4         # 算术运算操作符（如加号）前后要有空格
7
$ expr 3 \* 4        # 乘法要用转义符
12
$ expr 4 / 2
2

方法 2：利用 $(()) ，如：

$ echo $((3+4))
7
$ echo $((3*4))
12

方法 3：利用 $[] （这种方法已经 deprecated，不推荐使用），如：

$ echo $[3+4]
7
$ echo $[3*4]
12

方法 4：利用 let ，如：

$ let a=3+4; echo $a
7
$ let a=3*4; echo $a
12

方法 5：利用外部程序 bc ，如：

$ echo "scale=2; 15/4" | bc     # 要使bc进行浮点运算，用15/4.0的技巧是无效的，必须先设置scale！
3.75

注：前面 4 种方法不支持浮点数！

下面是清空文件内容的几种方法。

方法 1：删除它，再 touch 它。

$ rm file
$ touch file

方法 2：

$ echo -n >file

方法 3：

$ : >file

方法 4：

$ >file

如果你不关心文件的内容，只关心文件大小，则可以这样产生随机文件：

$ dd if=/dev/urandom of=file.txt bs=2048 count=10

如果你想得到的文件由有意义的单词组成，则可以这样产生随机文件：

$ ruby -e 'a=STDIN.readlines;X.times do;b=[];Y.times do; b << a[rand(a.size)].chomp end; puts b.join(" "); end' < /usr/share/dict/words > file.txt

运行上面命令时，请把 X 替换为总行数（如 10），Y替换每行的单词数（如 3）。

参考：http://www.skorks.com/2010/03/how-to-quickly-generate-a-large-file-on-the-command-line-with-linux/

变量 $RANDOM 可以得到闭区间 [0, 32767] 内的随机数字，如：

echo $RANDOM                                    # 闭区间 [0, 32767] 内的随机数字

如果要得到指定范围内的数字，可以这样：

MAX=90
MIN=10
echo $(($RANDOM%$(($MAX-$MIN+1)) + $MIN))       # 闭区间 [10, 90] 内的随机数字

此外，也可以使用外部程序生成指定范围的随机数，如：

$ shuf -n 1 -i $MIN-$MAX          # Linux 系统中，最小值和最大值之间是连字符
$ jot -r 1 $MIN $MAX              # Mac OS, BSD 系统中，最小值和最大值之间是空格

下面脚本可实现进度条效果。其思想很简单：每次更新输出时不换行，而是利用 \r 更新当前行。

#!/bin/bash
b=''
i=0
while [ $i -le  100 ]
do
    printf "progress:[%-50s]%d%%\r" $b $i
    sleep 0.1
    i=`expr 2 + $i`
    b=#$b
done
echo

利用 xargs 的 -P num 选项（指定最大并行数），可以并行地执行任务，具备简单的“线程池”功能。

第一步，把要执行的任务写入到一个文件（如 commands.txt）中，每行一个任务。

$ cat commands.txt
sleep 2; echo Hello world
sleep 2; echo Goodbye world
sleep 2; echo Goodbye cruel world
sleep 2; echo Goodbye cruel world world

第二步，执行下面语句（下面例子中，同时有 3 个任务在执行）。

$ cat commands.txt | xargs -I CMD -P 3 bash -c CMD     # 当commands.txt比较复杂时可能出错

上面实例程序的一个可能输出（注：结果会乱序，且由于是并行执行的，多次运行的结果会不一样）：

Goodbye world
Goodbye cruel world
Hello world
Goodbye cruel world world

特别说明：如果文件 commands.txt 中的命令包含单引号，且单引号意义重大（不可省略）。比如：

sleep 2; echo Hello world
sleep 2; echo Goodbye world
sleep 2; echo Goodbye cruel world
sleep 2; awk 'BEGIN {print "Goodbye cruel world world"}'

这时，需要用下面方式（重点是 -0 选项）并行执行任务：

$ cat commands.txt | tr '\n' '\0' | xargs -0 -I CMD -P 3 bash -c CMD     # 正确用法

参考：
Easy parallelization with Bash in Linux
Make xargs execute the command once for each line of input

co-processes are a ksh feature (already in ksh88). zsh has had the feature from the start (early 90s), while it has just only been added to bash in 4.0 (2009).

参考：http://unix.stackexchange.com/questions/86270/how-do-you-use-the-command-coproc-in-bash

有很多方法可以获取 CPU 核数，但没有一种方法是可移植的。

# 不同系统中，获取CPU核数的方法不同

Linux:
    1) getconf _NPROCESSORS_ONLN
    2) grep -c process /proc/cpuinfo

Solaris:
    1) psrinfo -p

OS X:
    1) getconf _NPROCESSORS_ONLN
    2) sysctl hw.ncpu

NetBSD:
    1) grep -c process /proc/cpuinfo
    2) sysctl hw.ncpu

OpenBSD:
    1) sysctl hw.ncpu

FreeBSD:
    1) sysctl hw.ncpu

如果在脚本中获取操作系统的类型呢？
在 Bash 中，可以通过测试变量 $OSTYPE 来得到操作系统的类型，但这种方法不通用，如在 ksh 中就不适应。

通用的可移植方法是测试命令 uname -s 的输出。
如：

if [ "$(uname -s)" = "Linux" ]; then
    echo "This is Linux"
fi

参考：
https://en.wikipedia.org/wiki/Uname
http://stackoverflow.com/questions/3466166/how-to-check-if-running-in-cygwin-mac-or-linux

下面代码可获取脚本所在目录的全路径：

#!/bin/bash
DIR="$( cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd -P)" # 仅适应于 bash

不过上面脚本，仅在 Bash 下工作（因为变量 BASH_SOURCE 仅在 Bash 中存在）。

如果想在其它 Shell 中也工作，可以把 ${BASH_SOURCE[0]} 换为 $0 （不过这有缺点，后面会介绍），如：

DIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P)"  # 在 bash 下用 source 执行时有问题

注意，在 Bash 下如果用 source 命令来执行脚本（如 source /1.sh 或者 . /1.sh ），那么在 1.sh 中打印 $0 会输出 bash，而不是 1.sh。这会导致上面的方案在脚本用 source 执行的情况下工作不正常。

所以，没有一种 POSIX 兼容的方式能完美地“获取脚本所在目录的全路径”。如果你的脚本不会用 source 来执行，那么使用 $0 ；如果你的脚本仅在 Bash 下执行，那么使用 ${BASH_SOURCE[0]} 。

参考：
https://stackoverflow.com/questions/29832037/how-to-get-script-directory-in-posix-sh
https://stackoverflow.com/questions/59895/how-to-get-the-source-directory-of-a-bash-script-from-within-the-script-itself

下面函数可以把相对路径转为绝对路径：

## 注：被测试的文件必须存在，否则下面的 cd 命令可能失败，导致错误结果
absolute_path() {
    fn=$1
    case "$fn" in
        # check $file_path if starts with /
        /*) fn_dirname=$(dirname "$fn") ;;
        *) fn_dirname=$(dirname "${PWD}/$fn") ;;
    esac
    fn_basename=$(basename "${PWD}/$fn")
    fn_absolute="$(cd "$fn_dirname"; pwd)/$fn_basename"
    ## If your want to resolve symbolic link, add -P (posix compatible) for pwd.
    # fn_absolute="$(cd "$fn_dirname"; pwd -P)/$fn_basename"
    echo "$fn_absolute"
}

file_name="path/to/your/file"

file_name_abs="$(absolute_path "$file_name")"
echo "$file_name_abs"

在 Shell 中如何捕获正则表达式中的 group 呢？使用 Shell 内置的正则不是很方便，下面介绍在 Shell 中使用 perl 来实现这个功能：

connection_string='mysql://root:123456@127.0.0.1:3306/db1'

host=$(echo $connection_string | perl -ne '/mysql:\/\/([a-zA-Z0-9]+):([^@]+)@([a-zA-Z0-9.]+):([0-9]+)\/([a-zA-Z0-9_-]+)/ and print $3')
port=$(echo $connection_string | perl -ne '/mysql:\/\/([a-zA-Z0-9]+):([^@]+)@([a-zA-Z0-9.]+):([0-9]+)\/([a-zA-Z0-9_-]+)/ and print $4')
user=$(echo $connection_string | perl -ne '/mysql:\/\/([a-zA-Z0-9]+):([^@]+)@([a-zA-Z0-9.]+):([0-9]+)\/([a-zA-Z0-9_-]+)/ and print $1')
password=$(echo $connection_string | perl -ne '/mysql:\/\/([a-zA-Z0-9]+):([^@]+)@([a-zA-Z0-9.]+):([0-9]+)\/([a-zA-Z0-9_-]+)/ and print $2')
database=$(echo $connection_string | perl -ne '/mysql:\/\/([a-zA-Z0-9]+):([^@]+)@([a-zA-Z0-9.]+):([0-9]+)\/([a-zA-Z0-9_-]+)/ and print $5')

statement='select * from test'
mysql --connect-timeout=5 --host=$host --port=$port --user=$user --password=$password --database=$database --execute="$statement"

如何在退出脚本时杀死子进程？

方法一：记录子进程 PID，退出时杀死子进程：

./subprocess.sh &
child_pid=$?
trap 'kill $child_pid' EXIT

方法二：利用 jobs -p 找到所有子进程，退出时杀死所有的子进程：

trap 'kill $(jobs -p)' EXIT

总结了 40 多条日常 Bash 编程中，老手和新手都容易忽略的错误编程习惯。

参考：
http://mywiki.wooledge.org/BashPitfalls
http://kodango.com/bash-pitfalls-part-1

参考：
编写 Bash 补全脚本：http://kodango.com/bash-competion-programming
Linux 中 10 个有用的命令行补齐命令，英文原版：http://www.thegeekstuff.com/2013/12/bash-completion-complete/
An introduction to bash completion: http://www.debian-administration.org/article/317/An_introduction_to_bash_completion_part_2

$() 和 `` 的作用一样，用来作 Command substitution（命令替换，其功能是把命令的 stdout 放到当前位置）。但 `` 是“过时的”用法，它有很多缺点（可参考：http://mywiki.wooledge.org/BashFAQ/082 ），所以请使用 $() 语法。

命令替换使用实例：

$ ls
file1.txt file2.txt file3.txt
$ files=$(ls *.txt)             # 也可以写为（过时的用法） files=`ls *.txt` ，变量files的内容为命令ls *.txt的输出
$ echo $files
file1.txt file2.txt file3.txt

需要说明的是：命令替换（即 $() 或 `` ）是在 sub-shell 中执行，它们不能修改父 shell 中的变量，如：

a=100

func1() {
    a=200
    echo "ok"
}

x=$(func1)            # 这样调用 func1，并不会修改 a。因为它在 sub-shell 中执行
echo $a               # 输出 100

func1                 # 这样调用 func1，会修改 a
echo $a               # 输出 200

$(()) 用来作整数运算（ $[] 也可以用作整数运行，但已经过时，不推荐使用），称为 Arithmetic expansion。
$() 和 `` 的作用一样（用法 `` 已经过时，不推荐使用），用来作 Command substitution（命令替换）。
${} 用来引用变量，用来作 Parameter expansion（变量替换）。

可以把一组命令放入()或{}中执行，含义不相同。

() 会启动一个子进程（subshell），不会对父进程的环境变量造成影响。
{} 在同一个进程中运行，它相当于“匿名函数”。

a=123
( a=321 )
echo "a = $a"   # output: a = 123

b=123
{ b=321; }
#      ^
echo "b = $b"    # output: b = 321

注意：{}中的最后一个命令后面必须有分号或换行符，否则会报语法错误。

参考：http://www.gnu.org/software/bash/manual/bashref.html#Command-Grouping

在需要执行的命令前面加个反斜杠字符即可，如禁用 ls 的 alias： \ls

read -a 和 readarray (mapfile)的区别

read -a
把输入内容按分隔符(空格或者跳格之类)分配给数组，连续的空格也算为 1 个分割。

readarray (mapfile)
把输入内容按行分配给数组。

如果要更新当前行的内容，可以使用 echo -e "\r" 回到当前行的行首，再输出内容。

$ echo -n "Old line"; sleep 2; echo -e "\rThis new line"

执行上面命令时，会输出：

Old line

过 2 秒后，上面的输出会更新为：

This new line

如果要更新之前行的内容，可以使用 echo -e "\033[nA" （它表示向上移动光标 n 行）。如：

$ echo -e "line1 ...\nline2 ..."; sleep 2; echo -en "\033[2A"; echo "line1 ... done"; echo "line2 ... done"  # 输出两行后，再更新它。推荐用法
$ echo -e "line1 ...\nline2 ..."; sleep 2; echo -en "\e[2A"; echo "line1 ... done"; echo "line2 ... done"    # 和上相同。但有些版本的echo不支持\e，不推荐
$ echo -e "line1 ...\nline2 ..."; sleep 2; tput cuu 2; echo "line1 ... done"; echo "line2 ... done"          # 和上相同。

执行上面命令时，会输出：

line1 ...
line2 ...

过 2 秒后，上面的输出会更新为：

line1 ... done
line2 ... done

参考：
https://en.wikipedia.org/wiki/Escape_character#ASCII_escape_character
man 5 terminfo
man tput

如何测试交互式和非交互式 shell？

方法 1：
测试 $PS1 变量。

方法 2：
可以通过打印 $- 变量的值（代表着当前 shell 的选项标志），查看其中的“i”选项（表示 interactive shell）来区分交互式与非交互式 shell。

参考：
http://see.xidian.edu.cn/cpp/html/1519.html

bash 中，如何输入上个命令的最后参数？

有 3 个方法：
!$
$_
Alt + .(或者<Esc> .)

注：
最后 1 个方法最好用，因为它可以在运行前直观地看到将会运行什么，有机会修改它再运行。
在 tcsh 中仅方法 1 可用。

bashdb 是一个 bash 调试器。
在 Debian 系列的操作系统中，可以这样安装：

sudo apt-get install bashdb

Learning the bash Shell 一书中介绍了一种实现 bash debugger 的方法，通过 bash 的 trap 接口实现的。

参考：
http://bashdb.sourceforge.net/
http://blog.csdn.net/yfkiss/article/details/8636758

用 -n 选项可以只检查语法而不执行。bash 和 ksh 都支持。

bash -n 1.sh
ksh -n 1.sh

为什么是 -n ，因为它对应的 set -o 为 noexec，noexec 的第一个字母为 n

要显示脚本中所执行的命令，可以在脚本中设置 set -x ，如：

#!/bin/bash

set -x         # bash
set -o xtrace  # 同上，这种写法POSIX兼容

# other command

也可以使用 -x 选项执行脚本，如 bash -x script.sh 。

用工具 shellcheck 可以检测 Shell 脚本中的一些不好用法。

在 Debian 系列系统中，可以用下面方法安装 shellcheck：

$ apt-get install shellcheck

参考：http://www.shellcheck.net/

直接执行 chsh 会提示输入密码，输入密码后再输入想要设置的 shell 的全路径即可。

所有可用的 shell 可通过命令 cat /etc/shells 得到。

注：由于更改 shell 需要更大的权限，所以文件 /usr/bin/chsh 的 owner 会为 root，它的 setuid 或 setgid 位被置上。只有这样才能“使程序以 owner 的权限运行（即其 effective UID 为 root）”。

推荐使用

#!/usr/bin/env bash

而不是

#!/bin/bash

说明：一般来说，/usr/bin/env 在“所有”系统上都存在。

参考：
http://unix.stackexchange.com/questions/29608/why-is-it-better-to-use-usr-bin-env-name-instead-of-path-to-name-as-my

ksh 88 是商业软件，不开源。ksh 93于 2000 年已经开源，使用 EPL（Eclipse Public License）协议！

Top Ten Reasons not to use the C shell
http://www.grymoire.com/Unix/CshTop10.txt

Some differences between BASH and TCSH
http://web.fe.up.pt/~jmcruz/etc/unix/sh-vs-csh.html

Zsh is an extended Bourne shell with a large number of improvements, including some features of bash, ksh, and tcsh.

参考：
使用 zsh 的九个理由：http://lostjs.com/2012/09/27/zsh/
24 Outstanding ZSH Gems：http://www.refining-linux.org/categories/13/Advent-calendar-2011/
zsh 入门：http://wiki.gentoo.org/wiki/Zsh/HOWTO