阅读量:4
文章目录
1、变量和参数的介绍
（1）变量替换
$(…)
使用 $(…) 机制来进行变量赋值（这是一种比后置引用（反引号`）更新的一种方法）。 事实上这两种方法都是命令替换的一种形式。
arch=$(uname -m) （2）特殊的变量类型
export
一个脚本只能够 export 变量到这个脚本所产生的子进程， 也就是说只能够对这个脚本所产生的命令和进程起作用。 如果脚本是从命令行中调用的， 那么这个脚本所 export 的变量是不能影响命令行环境的。 也就是说， 子进程是不能够 export 变量来影响产生自己的父进程的环境的。
位置参数
从命令行传递到脚本的参数: $0， $1， $2， $3 . . .
$0 就是脚本文件自身的名字， $1 是第一个参数， $2 是第二个参数， $3 是第三个参数， 然后是第四个。 $9 之后的位置参数就必须用大括号括起来了， 比如， ${10}， ${11}， ${12} 。
两个比较特殊的变量 $* 和 $@ 表示所有的位置参数。
shift
shift 命令会重新分配位置参数， 其实就是把所有的位置参数都向左移动一个位置。
$1 <— $2， $2 <— $3， $3 <— $4， 等等。
原来的 $1 就消失了， 但是 $0 （脚本名） 是不会改变的。 如果传递了大量的位置参数到脚本中， 那么 shift 命令允许你访问的位置参数的数量超过 10 个， 当然 {} 标记法也提供了这样的功能。
2、引用
（1）引用变量
双引号中通过直接使用变量名的方法来引用变量。单引号 （’ '） 操作与双引号基本一样， 但是不允许引用变量， 因为 $ 的特殊意义被关闭了。
（2）转义
- \0xx
转换为八进制的 ASCII 码， 等价于 0xx
3、条件判断
（1）条件测试结构
test， /usr/bin/test， [ ]， 和 /usr/bin/[ 都是等价命令
[[ ]] 结构比 [ ] 结构更加通用。 这是一个扩展的 test 命令， 是从 ksh88 中引进的。
(( )) 结构扩展并计算一个算术表达式的值
（2）文件测试操作符
- -e
文件存在 - -a
文件存在。这个选项的效果与 -e 相同。 但是它已经被 “弃用” 了， 并且不鼓励使用。 - -f
表示这个文件是一个一般文件 （并不是目录或者设备文件） - -s
文件大小不为零 - -d
表示这是一个目录 - -b
表示这是一个块设备 （软盘， 光驱， 等等。） - -c
表示这是一个字符设备 （键盘， modem， 声卡， 等等。） - -p
这个文件是一个管道 - -h
这是一个符号链接 - -L
这是一个符号链接 - -S
表示这是一个 socket - -t
文件（描述符）被关联到一个终端设备上。这个测试选项一般被用来检测脚本中的 stdin([ -t 0 ]) 或者 stdout([ -t 1 ]) 是否来自于一个终端。 - -r
文件是否具有可读权限（指的是正在运行这个测试命令的用户是否具有读权限） - -w
文件是否具有可写权限（指的是正在运行这个测试命令的用户是否具有写权限） - -x
文件是否具有可执行权限（指的是正在运行这个测试命令的用户是否具有可执行权限） - -g
set-group-id(sgid) 标记被设置到文件或目录上。
如果目录具有 sgid 标记的话， 那么在这个目录下所创建的文件将属于拥有这个目录的用户组， 而不必是创建这个文件的用户组。 这个特性对于在一个工作组中共享目录非常有用。 - -u
set-user-id (suid) 标记被设置到文件上。
如果一个 root 用户所拥有的二进制可执行文件设置了 set-user-id 标记位的话， 那么普通用户也会以 root 权限来运行这个文件。 - -k
设置粘贴位
对于 “粘贴位” 的一般了解， save-text-mode 标志是一个文件权限的特殊类型。 如果文件设置了这个标志， 那么这个文件将会被保存到缓存中， 这样可以提高访问速度。 - -O
判断你是否是文件的拥有者 - -G
文件的 group-id 是否与你的相同 - -N
从文件上一次被读取到现在为止， 文件是否被修改过 - f1 -nt f2
文件 f1 比文件 f2 新 - f1 -ot f2
文件 f1 比文件 f2 旧 - f1 -ef f2
文件 f1 和文件 f2 是相同文件的硬链接 - !
“非” —— 反转上边所有测试的结果（如果没给出条件， 那么返回真）。
（3）其他比较操作符
二元比较操作符用来比较两个变量或数字。 注意整数比较与字符串比较的区别。
整数比较
-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” 。
compound comparison
-a
逻辑与
exp1 -a exp2 如果表达式 exp1 和 exp2 都为真的话， 那么结果为真。-o
逻辑或
exp1 -o exp2 如果表达式 exp1 和 exp2 中至少有一个为真的话， 那么结果为真。
4、数字常量
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 5、变量重游
（1） 内部变量
内建变量
这些变量将会影响 bash 脚本的行为。
- $BASH
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_VERSION
安装在系统上的 Bash 版本号
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。 $$ 变量在脚本中经常用来构造 “唯一的” 临时文件名
（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
☆
