Bash 学习摘录2-阿里云开发者社区

Bash 学习摘录1：https://developer.aliyun.com/article/1598574

$OLDPWD

之前的工作目录（“OLD-print-working-directory”，就是之前你所在的目录）

$OSTYPE

操作系统类型

$PATH

可执行文件的搜索路径，一般为 /usr/bin/， /usr/X11R6/bin/， /usr/local/bin，等等。

$PIPESTATUS

这个数组变量将保存最后一个运行的前台管道的退出状态码。相当有趣的是，这个退出状态码和最后一个命令运行的退出状态码并不一定相同。

$PPID

进程的 $PPID 就是这个进程的父进程的进程 ID（pid）。

$PROMPT_COMMAND

这个变量保存了在主提示符 $PS1 显示之前需要执行的命令。

$PS1

这是主提示符，可以在命令行中见到它。

$PS2

第二提示符，当你需要额外输入的时候，你就会看到它。默认显示 “>” 。

$PS3

第三提示符，它在一个 select 循环中显示。

$PS4

第四提示符，当你使用 -x 选项来调用脚本时，这个提示符会出现在每行输出的开头。默认显示 “+” 。

$PWD

$REPLY

当没有参数变量提供给 read 命令的时候，这个变量会作为默认变量提供给 read 命令。也可以用于 select 菜单，但是只提供所选择变量的编号，而不是变量本身的值。

$SECONDS

这个脚本已经运行的时间（以秒为单位）。

$SHELLOPTS

shell 中已经激活的选项的列表，这是一个只读变量。

bash$ echo $SHELLOPTS
braceexpand:hashall:histexpand:monitor:history:interactivecomments:emacs

$SHLVL

Shell 级别，就是 Bash 被嵌套的深度。如果是在命令行中，那么 $SHLVL 为 1，如果在脚本中那么 $SHLVL 为 2 。

$TMOUT

如果 $TMOUT 环境变量被设置为非零值 time 的话，那么经过 time 秒后， shell 提示符将会超时。这将会导致登出（logout）。

$UID

用户 ID 号。当前用户的用户标识号，记录在 /etc/passwd 文件中

位置参数

$0， $1， $2，等等。
位置参数，从命令行传递到脚本，或者传递给函数，或者 set 给变量
$#
命令行参数或者位置参数的个数
$*
所有的位置参数都被看作为一个单词。
“$*” 必须被引用起来。
$@
与 $* 相同，但是每个参数都是一个独立的引用字符串，这就意味着，参数是被完整传递的，并没有被解释或扩展。这也意味着，参数列表中每个参数都被看作为单独的单词。
“$@” 应该被引用起来。

其他的特殊参数

$-
传递给脚本的标记（使用 set 命令）。
$!
运行在后台的最后一个作业的 PID（进程 ID）
$_
这个变量保存之前执行的命令的最后一个参数的值

$?
命令，函数，或者是脚本本身的退出状态码
$$
脚本自身的进程 ID。 $$ 变量在脚本中经常用来构造 “唯一的” 临时文件名

（2）操作字符串

Bash 所支持的字符串操作的数量多的令人惊讶。但是不幸的是，这些工具缺乏统一的标准。一些是参数替换的子集，而另外一些则受到 UNIX expr 命令的影响。这就导致了命令语法的不一致，还会引起冗余的功能，但是这些并没有引起混乱。

expr --help
用法：expr 表达式
　或：expr 选项

      --help        显示此帮助信息并退出
      --version     显示版本信息并退出

将 <表达式> 的值打印到标准输出。以下运算符按优先级从低到高排列，不同
优先级之间以空行隔开。<表达式> 可以是：

  参数1 | 参数2     若 <参数1> 的值不为 0 或 null，则返回 <参数1>，
                      否则返回 <参数2>

  参数1 & 参数2     若两边的值都不为 0 或 null，则返回 <参数1>，否则返回 0

  参数1 < 参数2     <参数1> 小于 <参数2>
  参数1 <= 参数2    <参数1> 小于或等于 <参数2>
  参数1 = 参数2     <参数1> 等于 <参数2>
  参数1 != 参数2    <参数1> 不等于 <参数2>
  参数1 >= 参数2    <参数1> 大于或等于 <参数2>
  参数1 > 参数2     <参数1> 大于 <参数2>

  参数1 + 参数2     计算 <参数1> 加 <参数2> 的和
  参数1 - 参数2     计算 <参数1> 减 <参数2> 的差

  参数1 * 参数2     计算 <参数1> 乘以 <参数2> 的积
  参数1 / 参数2     计算 <参数1> 除以 <参数2> 的商
  参数1 % 参数2     计算 <参数1> 除以 <参数2> 的余数

  字符串 : 正则     在 <字符串> 起始处进行 <正则> 的模式匹配

  match 字符串 正则          等于 "字符串 : 正则"
  substr 字符串 位置 长度    求 <字符串> 的子串，<位置> 从 1 开始数
  index 字符串 字符          在 <字符串> 中搜索 <字符> 中任何一个，返回其索引，
                               如未找到则返回 0
  length 字符串              <字符串> 的长度
  + 记号                     将 <记号> 解释为字符串，即使它是一个关键字，
                               例如 "match"，或者运算符，例如 "/"

  ( 表达式 )                 <表达式> 的值

请注意，由于 shell 这一层的存在，可能有许多运算符需要转义或者加引号。
如果两个 <参数> 都是数字，比较运算符就是算术比较，否则就是字典序比较。
模式匹配会返回 \( 和 \) 之间的字符串匹配的字符串，若没有匹配则返回 null；
如果未使用 \( 和 \)，则会返回匹配的字符的个数，若没有匹配则返回 0。

若 <表达式> 的值既不是 null 也不是 0，则退出状态为 0；若 <表达式> 的值为 null
或者 0，则退出状态为 1；如果 <表达式> 的句法无效，则退出状态为 2；如果有错误
发生，则退出状态为 3。

GNU coreutils 在线帮助：<https://www.gnu.org/software/coreutils/>
请向 <http://translationproject.org/team/zh_CN.html> 报告任何翻译错误
完整文档 <https://www.gnu.org/software/coreutils/expr>
或者在本地使用：info '(coreutils) expr invocation'

字符串长度

语法：

${#string}
expr length $string
expr "$string" : '.*'

示例：

stringZ=abcABC123ABCabc

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

${#var}

字符串长度 (变量$var得字符个数) 。对于 array 来说， ${#array} 表示的是数组中第一个元素的长度。

例外情况：

${#*} 和 ${#@} 表示位置参数的个数。
对于数组来说， ${#array[*]} 和 ${#array[@]} 表示数组中元素的个数。

匹配字符串开头的子串长度

语法：

expr match "$string" '$substring'
# $substring 是一个正则表达式.
expr "$string" : '$substring'
# $substring是一个正则表达式.

示例：

stringZ=abcABC123ABCabc
#       |------|

echo $(expr match "$stringZ" 'abc[A-Z]*.2') # 8
echo $(expr "$stringZ" : 'abc[A-Z]*.2')     # 8

索引

语法：

expr index $string $substring
# 在字符串 $string 中所匹配到的 $substring 第一次所出现的位置

示例：

stringZ=abcABC123ABCabc

echo $(expr index "$stringZ" C12)   # 6 
                                    # C 字符的位置
echo $(expr index "$stringZ" 1c)    # 3
# 'c' (in #3 position) matches before '1'.

提取子串

语法：

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

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

示例：

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

echo ${stringZ:0}   # abcABC123ABCabc
echo ${stringZ:1}   # bcABC123ABCabc
echo ${stringZ:7}   # 23ABCabc
echo ${stringZ:7:3} # 23A
                    # 提取子串长度为3.

# 能不能从字符串的右边(也就是结尾)部分开始提取子串?
echo ${stringZ:-4} # abcABC123ABCabc
# 默认是提取整个字符串， 就象${parameter:-default}一样. 
# 然而 . . . 

echo ${stringZ:(-4)} # Cabc
echo ${stringZ: -4}  # Cabc
# 这样， 它就可以工作了. 
# 使用圆括号或者添加一个空格可以"转义"这个位置参数.

如果 $string 参数是 "*" 或 "@" ，那么将会从 $position 位置开始提取 $length 个位置参数，但是由于可能没有 $length 个位置参数了，那么就有几个位置参数就提取几个位置参数。

echo ${*:2} # 打印出第2个和后边所有的位置参数.
echo ${@:2} # 同上.

echo ${*:2:3} # 从第2个开始， 连续打印3个位置参数.

#./t.sh 1 2 3 4 5 6
#2 3 4 5 6
#2 3 4 5 6
#2 3 4

语法：

expr substr $string $position $length
# 在 $string 中从 $position 开始提取 $length 长度的子串.

expr match "$string" '\($substring\)'
# 从 $string 的开始位置提取 $substring， $substring 是正则表达式.


expr "$string" : '\($substring\)'
# 从 $string 的开始位置提取 $substring ， $substring 是正则表达式.

示例：

stringZ=abcABC123ABCabc
# =======
echo $(expr match "$stringZ" '\(.[b-c]*[A-Z]..[0-9]\)') # abcABC1
echo $(expr "$stringZ" : '\(.[b-c]*[A-Z]..[0-9]\)')     # abcABC1
echo $(expr "$stringZ" : '\(.......\)')                 # abcABC1
# 上边的每个echo都打印出相同的结果.

语法：

expr match "$string" '.*\($substring\)'
# 从 $string 的结尾提取$substring， $substring 是正则表达式.
expr "$string" : '.*\($substring\)'
# 从 $string 的结尾提取 $substring， $substring 是正则表达式.

示例：

stringZ=abcABC123ABCabc
# ======

echo $(expr match "$stringZ" '.*\([A-C][A-C][A-C][a-c]*\)') # ABCabc
echo $(expr "$stringZ" : '.*\(......\)')                    # ABCabc

子串削除

语法：

${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'之间最短的匹配. 

echo ${stringZ%%b*c} # a
# 从$stringZ的结尾位置截掉'b'到'c'之间最长的匹配.

子串替换

语法：

${string/substring/replacement}
# 使用 $replacement 来替换第一个匹配的 $substring .

${string//substring/replacement}
# 使用 $replacement 来替换所有匹配的 $substring .

示例：

stringZ=abcABC123ABCabc
echo ${stringZ/abc/xyz}     # xyzABC123ABCabc
                            # 使用'xyz'来替换第一个匹配的'abc'.

echo ${stringZ//abc/xyz}    # xyzABC123ABCxyz
                            # 用'xyz'来替换所有匹配的'abc'.

语法：

${string/#substring/replacement}
# 如果 $substring 匹配 $string 的开头部分， 那么就用 $replacement 来替换 $substring .

${string/%substring/replacement}
# 如果 $substring 匹配 $string 的结尾部分， 那么就用 $replacement 来替换 $substring.

示例：

stringZ=abcABC123ABCabc

echo ${stringZ/#abc/XYZ}    # XYZABC123ABCabc
                            # 用'XYZ'替换开头的'abc'.

echo ${stringZ/%abc/XYZ}    # abcABC123ABCXYZ
                            # 用'XYZ'替换结尾的'abc'.

（3）参数替换

处理和(或)扩展变量

${parameter}
与 $parameter 相同，也就是变量 parameter 的值。
${parameter-default}， ${parameter:-default}

${parameter-default} – 如果变量 parameter 没被声明，那么就使用默认值。

${parameter:-default} – 如果变量 parameter 没被设置，那么就使用默认值。

${parameter=default}， ${parameter:=default}

${parameter=default} – 如果变量 parameter 没声明，那么就把它的值设为 default。

${parameter:=default} – 如果变量 parameter 没设置，那么就把它的值设为 default。

这两种形式基本上是一样的。只有在变量 $parameter 被声明并且被设置为 null 值的时候，才会引起这两种形式的不同。

${parameter+alt_value}， ${parameter:+alt_value}

${parameter+alt_value} – 如果变量 parameter 被声明了，那么就使用 alt_value ，否则就使用 null 字符串。

${parameter:+alt_value} – 如果变量 parameter 被设置了，那么就使用 alt_value ，否则就使用 null 字符串。

这两种形式绝大多数情况下都一样。只有在 parameter 被声明并且设置为 null 值的时候，多出来的这个: 才会引起这两种形式的不同。

${parameter?err_msg}， ${parameter:?err_msg}

${parameter?err_msg} – 如果 parameter 已经被声明，那么就使用设置的值，否则打印 err_msg 错误消息。

${parameter:?err_msg} – 如果 parameter 已经被设置，那么就使用设置的值，否则打印 err_msg 错误消息。

这两种形式绝大多数情况都是一样的。和上边所讲的情况一样，只有在 parameter 被声明并设置为 null 值的时候，多出来的:才会引起这两种形式的不同。

（4）指定变量的类型: 使用 declare 或者 typeset

declare 或者 typeset 内建命令（这两个命令是完全一样的)允许指定变量的具体类型。在某些编程语言中，这是指定变量类型的一种很弱的形式。 declare 命令是从 Bash 2.0 之后才被引入的命令。 typeset 也可以用在 ksh 的脚本中。

declare/typeset 选项

-r 只读

declare -r var1

（declare -r var1 与 readonly var1 是完全一样的）

这和 C 语言中的 const 关键字一样，都用来指定变量为只读。如果你尝试修改一个只读变量的值，那么会产生错误信息。

-i 整型

declare -i number
# 脚本将会把变量"number"按照整型进行处理。

number=3
echo "Number = $number" # Number = 3

number=three
echo "Number = $number" # Number = 0
# 脚本尝试把字符串"three"作为整数来求值（译者注: 当然会失败， 所以出现值为0）。

如果把一个变量指定为整型的话，那么即使没有 expr 或者 let 命令，也允许使用特定的算术运算。

n=6/3
echo "n = $n" # n = 6/3

declare -i n
n=6/3
echo "n = $n" # n = 2

-a 数组

declare -a indices

变量 indices 将被视为数组。

-f 函数

declare -f

如果在脚本中使用declare -f，而不加任何参数的话，那么将会列出这个脚本之前定义的所有函数。

declare -f function_name

如果在脚本中使用declare -f function_name这种形式的话，将只会列出这个函数的名字。

-x export

declare -x var3

这句将会声明一个变量，并作为这个脚本的环境变量被导出。

-x var=$value

declare -x var3=373

declare 命令允许在声明变量类型的同时给变量赋值。

示例：

#!/bin/bash

func1() {
    echo This is a function.
}

declare -f # 列出前面定义的所有函数。
echo

declare -i var1 # var1是个整型变量。
var1=2367
echo "var1 declared as $var1"
var1=var1+1 # 整型变量的声明并不需要使用'let'命令。
echo "var1 incremented by 1 is $var1."
# 尝试修改一个已经声明为整型变量的值。
echo "Attempting to change var1 to floating point value, 2367.1."
var1=2367.1 # 产生错误信息， 并且变量并没有被修改。
echo "var1 is still $var1"

echo

declare -r var2=13.36   # 'declare'允许设置变量的属性，
                        #+ 同时给变量赋值。
echo "var2 declared as $var2" # 试图修改只读变量的值。
var2=13.37                    # 产生错误消息， 并且从脚本退出。

echo "var2 is still $var2" # 将不会执行到这行。

exit 0 # 脚本也不会从此处退出。

（5）变量的间接引用

假设一个变量的值是第二个变量的名字。那么我们如何从第一个变量中取得第二个变量的值呢? 比如，如果 a=letter_of_alphabet 并且 letter_of_alphabet=z ，那么我们能够通过引用变量 a 来获得 z 么? 这确实是可以做到的，它被称为间接引用。它使用 eval var1=\$$a 这种不平常的形式。

#!/bin/bash

# ind-ref.sh: 间接变量引用. 
# 访问一个以另一个变量内容作为名字的变量的值.(译者注: 怎么译都不顺)

a=letter_of_alphabet # 变量"a"的值是另一个变量的名字.
letter_of_alphabet=z

echo

# 直接引用.
echo "a = $a" # a = letter_of_alphabet

# 间接引用.
eval a=\$$a
echo "Now a = $a" # 现在 a = z

echo

# 现在， 让我们试试修改第二个引用的值.

t=table_cell_3
table_cell_3=24
echo "\"table_cell_3\" = $table_cell_3" # "table_cell_3" = 24
echo -n "dereferenced \"t\" = "
eval echo \$$t # 解引用 "t" = 24
# 在这个简单的例子中， 下面的表达式也能正常工作么(为什么?).
# eval t=\$$t; echo "\"t\" = $t"

echo

t=table_cell_3
NEW_VAL=387
table_cell_3=$NEW_VAL
echo "Changing value of \"table_cell_3\" to $NEW_VAL."
echo "\"table_cell_3\" now $table_cell_3"
echo -n "dereferenced \"t\" now "
eval echo \$$t
# "eval" 带有两个参数 "echo" 和 "\$$t" (与$table_cell_3等价)

echo

# (感谢， Stephane Chazelas， 澄清了上边语句的行为.)

# 另一个方法是使用${!t}符号， 见"Bash， 版本2"小节的讨论. 45 # 也请参考 ex78.sh.

exit 0

变量的间接引用到底有什么应用价值? 它给 Bash 添加了一种类似于 C 语言指针的功能，比如，在表格查找中的用法。

（6）$RANDOM: 产生随机整数

$RANDOM 是 Bash 的内部函数 (并不是常量)，这个函数将返回一个伪随机整数，范围在 0 - 32767 之间。它不应该被用来产生密匙。

#!/bin/bash
# 每次调用$RANDOM都会返回不同的随机整数. 
# 一般范围为: 0 - 32767 (有符号的 16-bit整数).

MAXCOUNT=10
count=1

echo
echo "$MAXCOUNT random numbers:"
echo "-----------------"

while [ "$count" -le $MAXCOUNT ] # 产生10 ($MAXCOUNT)个随机整数. 
do
    number=$RANDOM
    echo $number
    let "count += 1" # 增加计数. 
done
echo "-----------------"

# 如果你需要在特定范围内产生随机整数, 那么使用'modulo'(模)操作.(译者注: 事实上, 这不是一个非常 好的办法. 理由见man 3 rand)
# 取模操作会返回除法的余数. 
RANGE=500

echo

number=$RANDOM
let "number %= $RANGE"
#           ^^
echo "Random number less than $RANGE --- $number"

echo


# 如果你需要产生一个大于某个下限的随机整数. 
#+ 那么建立一个test循环来丢弃所有小于此下限值的整数. 

FLOOR=200

number=0 #初始化
while [ "$number" -le $FLOOR ]
do
    number=$RANDOM
done
echo "Random number greater than $FLOOR --- $number"
echo

# 让我们对上边的循环尝试一个小改动, 如下: 
# let "number = $RANDOM + $FLOOR"
# 这将不再需要那个while循环, 并且能够运行的更快. 
# 但是, 这可能会产生一个问题, 思考一下是什么问题?
# 结合上边两个例子, 来在指定的上下限之间来产生随机数. 
number=0 #initialize
while [ "$number" -le $FLOOR ]
do
    number=$RANDOM
    let "number %= $RANGE" # 让$number依比例落在$RANGE的范围内. 
done
echo "Random number between $FLOOR and $RANGE --- $number"
echo

# 产生二元值, 就是, "true" 或 "false" 两个值. 
BINARY=2
T=1
number=$RANDOM
let "number %= $BINARY"
# 注意 let "number >>= 14" 将会给出一个更好的随机分配. #(译者注: 正如man页中提到的, 更 高位的随机分布更加平均)
#+ (右移14位将把所有的位全部清空, 除了第15位, 因为有符号, 第16位是符号位). #取模操作使用低位来 产生随机数会相对不平均)
if [ "$number" -eq $T ]
then
    echo "TRUE"
else
    echo "FALSE"
fi 

echo

# 抛骰子. 
SPOTS=6 # 模 6 给出的范围是 0 - 5.
# 加 1 会得到期望的范围
# 感谢, Paulo Marcel Coelho Aragao, 对此进行的简化. 
die1=0
die2=0
# 是否让SPOTS=7会比加1更好呢? 解释行或者不行的原因?
# 每次抛骰子, 都会给出均等的机会. 
let "die1 = $RANDOM % $SPOTS +1" # 抛第一次. 
let "die2 = $RANDOM % $SPOTS +1" # 抛第二次. 
# 上边的算术操作中, 哪个具有更高的优先级呢 -- 
#+ 模(%) 还是加法操作(+)?
let "throw = $die1 + $die2"
echo "Throw of the dice = $throw"
echo
exit

（7）双圆括号结构

与 let 命令很相似， ((…)) 结构允许算术扩展和赋值。举个简单的例子， a=$(( 5 + 3 ))，将把变量 “a” 设为 “5 + 3” ，或者 8 。然而，双圆括号结构也被认为是在 Bash 中使用 C 语言风格变量操作的一种处理机制。

#!/bin/bash
# 使用((...))结构操作一个变量, C语言风格的变量操作.

echo

((a = 23)) # C语言风格的变量赋值, "="两边允许有空格.
echo "a (initial value) = $a"

((a++)) # C语言风格的后置自加.
echo "a (after a++) = $a"

((a--)) # C语言风格的后置自减.
echo "a (after a--) = $a"

((++a)) # C语言风格的前置自加.
echo "a (after ++a) = $a"

((--a)) # C语言风格的前置自减.
echo "a (after --a) = $a"

echo

########################################################
# 注意: 就像在C语言中一样, 前置或后置自减操作
#+ 会产生一些不同的副作用.

n=1
let --n && echo "True" || echo "False" # False
n=1
let n-- && echo "True" || echo "False" # True

# 感谢, Jeroen Domburg.
########################################################

echo

((t = a < 45 ? 7 : 11)) # C语言风格的三元操作.
echo "If a < 45, then t = 7, else t = 11."
echo "t = $t " # Yes!

echo

# ------------
# 复活节彩蛋!
# ------------
# Chet Ramey显然偷偷摸摸的将一些未公开的C语言风格的结构
#+ 引入到了Bash中 (事实上是从ksh中引入的, 这更接近些).
# 在Bash的文档中, Ramey将((...))称为shell算术运算,
#+ 但是它所能做的远远不止于此.
# 不好意思, Chet, 现在秘密被公开了.

# 你也可以参考一些 "for" 和 "while" 循环中使用((...))结构的例子.

# 这些只能够在Bash 2.04或更高版本的Bash上才能运行.

exit 0

Bash 学习摘录2

位置参数

其他的特殊参数

（2）操作字符串

字符串长度

匹配字符串开头的子串长度

索引

提取子串

子串削除

子串替换

（3）参数替换

处理和(或)扩展变量

（4）指定变量的类型: 使用 declare 或者 typeset

（5）变量的间接引用

（6）$RANDOM: 产生随机整数

（7）双圆括号结构

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Bash 学习摘录2

位置参数

其他的特殊参数

（2） 操作字符串

字符串长度

匹配字符串开头的子串长度

索引

提取子串

子串削除

子串替换

（3） 参数替换

处理和(或)扩展变量

（4）指定变量的类型: 使用 declare 或者 typeset

（5）变量的间接引用

（6）$RANDOM: 产生随机整数

（7）双圆括号结构

热门文章

最新文章

相关课程

相关电子书

相关实验场景

（2）操作字符串

（3）参数替换