赞
踩
使用 $(…) 机制来进行变量赋值(这是一种比后置引用(反引号`)更新的一种方法)。 事实上这两种方法都是命令替换的一种形式。
arch=$(uname -m)
一个脚本只能够 export 变量到这个脚本所产生的子进程, 也就是说只能够对这个脚本所产生的命令和进程起作用。 如果脚本是从命令行中调用的, 那么这个脚本所 export 的变量是不能影响命令行环境的。 也就是说, 子进程是不能够 export 变量来影响产生自己的父进程的环境的。
从命令行传递到脚本的参数: $0, $1, $2, $3 . . .
$0 就是脚本文件自身的名字, $1 是第一个参数, $2 是第二个参数, $3 是第三个参数, 然后是第四个。 $9 之后的位置参数就必须用大括号括起来了, 比如, ${10}, ${11}, ${12} 。
两个比较特殊的变量 $* 和 $@ 表示所有的位置参数。
shift 命令会重新分配位置参数, 其实就是把所有的位置参数都向左移动一个位置。
$1 <— $2, $2 <— $3, $3 <— $4, 等等。
原来的 $1 就消失了, 但是 $0 (脚本名) 是不会改变的。 如果传递了大量的位置参数到脚本中, 那么 shift 命令允许你访问的位置参数的数量超过 10 个, 当然 {} 标记法也提供了这样的功能。
双引号中通过直接使用变量名的方法来引用变量。单引号 (’ ') 操作与双引号基本一样, 但是不允许引用变量, 因为 $ 的特殊意义被关闭了。
test, /usr/bin/test, [ ], 和 /usr/bin/[ 都是等价命令
[[ ]] 结构比 [ ] 结构更加通用。 这是一个扩展的 test 命令, 是从 ksh88 中引进的。
(( )) 结构扩展并计算一个算术表达式的值
二元比较操作符用来比较两个变量或数字。 注意整数比较与字符串比较的区别。
-eq
等于
if [ “$a” -eq “$b” ]
-ne
不等于
if [ “$a” -ne “$b” ]
-gt
大于
if [ “$a” -gt “$b” ]
-ge
大于等于
if [ “$a” -ge “$b” ]
-lt
小于
if [ “$a” -lt “$b” ]
-le
小于等于
if [ “$a” -le “$b” ]
<
小于(在双括号中使用)
((“$a” < “$b”))
<=
小于等于(在双括号中使用)
((“
a
"
<
=
"
a" <= "
a"<="b”))
>
大于(在双括号中使用)
((“$a” > “$b”))
>=
大于等于(在双括号中使用)
((“$a” >= “$b”))
=
等于
if [ “$a” = “$b” ]
==
等于
if [ “$a” == “$b” ]
与 = 等价。
!=
不等号
if [ “$a” != “$b” ]
这个操作符将在 [[ … ]] 结构中使用模式匹配。
<
小于, 按照 ASCII 字符进行排序
if [[ “$a” < “$b” ]]
if [ “$a” \< “$b” ]
注意 “<” 使用在 [ ] 结构中的时候需要被转义。
>
大于, 按照 ASCII 字符进行排序
if [[ “$a” > “$b” ]]
if [ “$a” \> “$b” ]
注意 “>” 使用在 [ ] 结构中的时候需要被转义。
-z
字符串为 “null” , 意思就是字符串长度为零
-n
字符串不为 “null” 。
-a
逻辑与
exp1 -a exp2 如果表达式 exp1 和 exp2 都为真的话, 那么结果为真。
-o
逻辑或
exp1 -o exp2 如果表达式 exp1 和 exp2 中至少有一个为真的话, 那么结果为真。
shell 脚本在默认情况下都是把数字作为 10 进制数来处理, 除非这个数字采用了特殊的标记或者前缀。
如果数字以 0 开头的话那么就是 8 进制数。 如果数字以 0x 开头的话那么就是 16 进制数。 如果数字中间嵌入了 # 的话, 那么就被认为是 BASE#NUMBER 形式的标记法(有范围和符号限制)。
# 其他进制: BASE#NUMBER
# BASE 的范围在 2 到 64 之间.
# NUMBER 的值必须使用 BASE 范围内的符号来表示, 具体看下边的示例.
let "bin = 2#111100111001101"
echo "binary number = $bin" # 31181
let "b32 = 32#77"
echo "base-32 number = $b32" # 231
这些变量将会影响 bash 脚本的行为。
$ echo $BASH
/bin/bash
$BASH_ENV
这个环境变量会指向一个 Bash 的启动文件, 当一个脚本被调用的时候, 这个启动文件将会被读取。
$BASH_SUBSHELL
这个变量用来提示子 shell 的层次。 这是一个 Bash 的新特性, 直到版本 3 的 Bash 才被引入近来。
$BASH_VERSINFO[n]
这是一个含有 6 个元素的数组, 它包含了所安装的 Bash 的版本信息。 这与下边的 $BASH_VERSION 很相像, 但是这个更加详细一些。
# Bash version info:
for n in 0 1 2 3 4 5; do
echo "BASH_VERSINFO[$n] = ${BASH_VERSINFO[$n]}"
done
# BASH_VERSINFO[0] = 3 # 主版本号
# BASH_VERSINFO[1] = 00 # 次版本号。
# BASH_VERSINFO[2] = 14 # 补丁次数。
# BASH_VERSINFO[3] = 1 # 编译版本。
# BASH_VERSINFO[4] = release # 发行状态。
# BASH_VERSINFO[5] = i386-redhat-linux-gnu # 结构体系
# (与变量$MACHTYPE相同)。
bash$ echo $BASH_VERSION
3.00.14(1)-release
tcsh% echo $BASH_VERSION
BASH_VERSION: Undefined variable.
$DIRSTACK
在目录栈中最顶端的值。 (将会受到 pushd 和 popd 的影响)
这个内建变量与 dirs 命令相符, 但是 dirs 命令会显示目录栈的整个内容。
$EDITOR
脚本所调用的默认编辑器, 通常情况下是 vi 或者是 emacs 。
$EUID
“有效” 用户 ID 。
不管当前用户被假定成什么用户, 这个数都用来表示当前用户的标识号, 也可能使用 su 命令来达到假定的目的。
$EUID 并不一定与 $UID 相同。
$FUNCNAME
当前函数的名字。(数组形式 $FUNCNAME[0] )
$GLOBIGNORE
一个文件名的模式匹配列表,如果在通配(globbing)中匹配到的文件包含有这个列表中的某个文件, 那么这个文件将被从匹配到的结果中去掉。
$GROUPS
目前用户所属的组。
这是一个当前用户的组 id 列表(数组), 与记录在 /etc/passwd 文件中的内容一样。
root# echo $GROUPS
0
root# echo ${GROUPS[1]}
1
root# echo ${GROUPS[5]}
6
$HOME
用户的 home 目录, 一般是 /home/username
$HOSTNAME
hostname 放在一个初始化脚本中, 在系统启动的时候分配一个系统名字。 然而, gethostname() 函数可以用来设置这个 Bash 内部变量 $HOSTNAME 。
$HOSTTYPE
主机类型
就像 $MACHTYPE , 用来识别系统硬件。
bash$ echo $HOSTTYPE
i686
$IFS
内部域分隔符
这个变量用来决定 Bash 在解释字符串时如何识别域, 或者单词边界。
$IFS 默认为 空白(空格, 制表符,和换行符), 但这是可以修改的, 比如, 在分析逗号分隔的数据文件时, 就可以设置为逗号。 注意 $* 使用的是保存在 $IFS 中的第一个字符。
$IGNOREEOF
忽略 EOF : 告诉 shell 在 log out 之前要忽略多少文件结束符(control-D)。
$LC_COLLATE
常在 .bashrc 或 /etc/profile 中设置, 这个变量用来控制文件名扩展和模式匹配的展开顺序。 如果 $LC_COLLATE 设置得不正确的话, LC_COLLATE 会在文件名匹配(filename globbing)中产生不可预料的结果。
$LC_CTYPE
这个内部变量用来控制通配(globbing)和模式匹配中的字符串解释。
$LINENO
这个变量用来记录自身在脚本中所在的行号。 这个变量只有在脚本使用这个变量的时候才有意义,并且这个变量一般用于调试目的。
$MACHTYPE
机器类型。标识系统的硬件。
bash$ echo $MACHTYPE
i686
$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。 $$ 变量在脚本中经常用来构造 “唯一的” 临时文件名
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} 表示的是数组中第一个元素的长度。
例外情况:
语法:
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'.
${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 值的时候, 多出来的:才会引起这两种形式的不同。
declare 或者 typeset 内建命令(这两个命令是完全一样的)允许指定变量的具体类型。 在某些编程语言中, 这是指定变量类型的一种很弱的形式。 declare 命令是从 Bash 2.0 之后才被引入的命令。 typeset 也可以用在 ksh 的脚本中。
declare/typeset 选项
declare -r var1
(declare -r var1 与 readonly var1 是完全一样的)
这和 C 语言中的 const 关键字一样, 都用来指定变量为只读。 如果你尝试修改一个只读变量的值,那么会产生错误信息。
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
declare -a indices
变量 indices 将被视为数组。
declare -f
如果在脚本中使用declare -f, 而不加任何参数的话, 那么将会列出这个脚本之前定义的所有函数。
declare -f function_name
如果在脚本中使用declare -f function_name这种形式的话, 将只会列出这个函数的名字。
declare -x var3
这句将会声明一个变量, 并作为这个脚本的环境变量被导出。
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 # 脚本也不会从此处退出。
假设一个变量的值是第二个变量的名字。 那么我们如何从第一个变量中取得第二个变量的值呢? 比如,如果 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 语言指针的功能, 比如, 在表格查找中的用法。
$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
与 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
☆
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。