变量
简介
变量就是程序设计语言中的一个可以变化的量，当然，可以变化的是变量的值。变量几乎所有的程序设计语言中都有定义，并且其涵义也大同小异。从本质上讲，变量就是在程序中保存用户数据的一块内存空间，而变量名就是这块内存空间的地址。
在程序的执行过程中，保存数据的内存空间的内容可能会不断地发生变化，但是，代表内存地址的变量名却保持不变。
命名
在Shell中，变量名可以由字母、数字或者下划线组成，并且只能以字母或者下划线开头。对于变量名的长度，Shell并没有做出明确的规定。因此，用户可以使用任意长度的字符串来作为变量名。但是，为了提高程序的可读性，建议用户使用相对较短的字符串作为变量名。
在一个设计良好的程序中，变量的命名有着非常大的学问。通常情况下，用户应该尽可能选择有明确意义的英文单词作为变量名，尽量避免使用拼音或者毫无意义的字符串作为变量名。这样的话，用户通过变量名就可以了解该变量的作用。
例如，下面的变量名都是非常好的选择：
PATH=/sbin
UID=100
JAVA_HOME="/usr/lib/jvm/jre-1.6.0-openjdk.x86_64/bin/../.."
SSHD=/usr/sbin/sshd
1
2
3
4
变量的类型
Shell是一种动态类型语言和弱类型语言，即在Shell中，变量的数据类型毋需显示地声明，变量的数据类型会根据不同的操作有所变化。准确地讲，Shell中的变量是不分数据类型的，统一地按照字符串存储。 但是根据变量的上下文环境，允许程序执行一些不同的操作，例如字符串的比较和整数的加减等等。
【例1】演示Shell变量的数据类型
#!/bin/bash
x=123 #定义变量x，并且赋值为123
let "x += 1" #变量x加1
echo "x = $x" #输出变量x的值 124
echo #显示空行
y=${x/1/abc} #替换x中的1为abc，并且将值赋给变量y abc24
echo "y = $y" #输出变量y的值 abc24
declare -i y #声明变量y
echo "y = $y" #输出变量y的值
let "y += 1" #变量y的值加1 #abc24不是整形，便将y变为0,0自增为1
echo "y = $y" #输出变量y的值 1
echo #显示空行
z=abc22 #将字符串赋给变量z
echo "z = $z" #输出变量z的值
m=${z/abc/11} #替换变量z中的abc为数字11，并且将值赋给变量m
echo "m = $m" #输出变量m的值
let "m += 1" #变量m加1 #弱类型，自动变为int型
echo "m = $m" #输出变量m的值
echo
n="" #将空串赋给变量n
echo "n = $n" #输出变量n的值
let "n += 1" #变量n加1
echo "n = $n"
echo
echo "p = $p" #输出空变量p的值 #自动赋值为空
let "p += 1" # 变量p加1
echo "p = $p"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
上述代码运行结果
[root@localhost ~]# ./test.sh
x = 124
y = abc24
y = abc24
y = 1
z = abc22
m = 1122
m = 1123
n =
n = 1
p =
p = 1
1
2
3
4
5
6
7
8
9
10
11
12
在Shell中，通常情况下用户可以直接使用变量，而毋需先进行定义，当用户第一次使用某个变量名时，实际上就同时定义了这个变量，在变量的作用域内，用户都可以使用该变量。
【例2】演示通过直接使用变量来定义变量
#!/bin/bash
a=1 #定义变量a #类似于 int n=3 这种操作
b="hello" #定义变量b
c="hello world" #定义变量c
1
2
3
4
通过declare命令声明变量
declare attribute variable（声明变量属性）
-p：显示所有变量的值。
-i：将变量定义为整数。在之后就可以直接对表达式求值，结果只能是整数。如果求值失败或者不是整数，就设置为0。
declare -i t，把t设置为整型
-r：将变量声明为只读变量。只读变量不允许修改，也不允许删除。readonly，
-a：变量声明为数组变量。但这没有必要。所有变量都不必显式定义就可以用作数组。事实上，在某种意义上，似乎所有变量
都是数组，而且赋值给没有下标的变量与赋值给下标为0的数组元素相同. array，矩阵，变长数组
-f：显示所有自定义函数，包括名称和函数体。function
-x：将变量设置成环境变量，这样在随后的脚本和程序中可以使用。
1
2
3
4
5
6
7
8
【例3】演示使用不同的方法了声明变量，导致变量在不同的环境下表现出不同的行为
#!/bin/bash
x=6/3 #定义变量x，并将一个算术式赋给它
echo "$x"
declare -i x #定义变量x为整数
echo "$x" #仍为之前的x
x=6/3 #将算术式赋给变量x，自动转变为2
echo "$x" #
x=hello #将字符串赋给变量x
echo "$x" #给整型变量赋hello，不是整数，只能给x赋值为0
x=3.14 #将浮点数赋给变量x
echo "$x"
declare +i x #取消变量x的整数属性
x=6/3 #重新将算术式赋给变量x
echo "$x" #6/3
x=$[6/3] #求表达式的值
echo "$x" #2
x=$((6/3)) #求表达式的值
echo "$x" #2
declare -r x #声明只读变量x
echo "$x" #2
x=5 #尝试为只读变量赋值
echo "$x” #2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
运行以上程序
[root@localhost ~]# ./test.sh
6/3
6/3
2
0
./test.sh: line 10: 3.14: syntax error: invalid arithmetic operator (error token is ".14")
0
6/3
2
2
2
./test.sh: line 21: x: readonly variable
2
1
2
3
4
5
6
7
8
9
10
11
12
13
引用
Shell语言中一共有3种引号，分别为
单引号（’ '）单引号括起来的字符都作为普通字符出现
双引号（" "）双引号括起来的字符，除“$”、“\”、“ ’ ”和“ " ”这几个字符仍是特殊字符并保留其特殊功能外，其余字符仍作为普通字符对待，
反引号（` `）。反引号括起来的字串被Shell解释为命令，在执行时，Shell首先执行该命令，并以它的标准输出结果取代整个反引号（包括两个反引号）部分
【例4】演示反引号使用方法
#!/bin/bash
#输出当前目录
echo "current directory is `pwd`"
1
2
3
运行以上程序
[root@localhost ~]# ./test.sh
current directory is /root
1
2
【例5】演示单双引号使用方法
#!/bin/bash
a= demo
b='b- $a'
c="b- $a"
echo $a
echo $b
echo $c
运行结果如下：
demo
b- $a #单引号，所见即所得
b- demo
1
2
3
4
5
6
7
8
9
10
11
三种引号的理解：
1、单引号（弱引用）
所见即所得
例如：var=123
var2=’${var}123’
echo var2 var2结果为${var}123
2、双引号（强引用）
输出引号中的内容，若存在命令、变量等，会先执行命令解析出结果再输出
例如：var=123
var2="${var}123"
echo var2 var2结果为123123
3、反引号（键盘tab键上面一个键）
命令替换
例如：root用户登录系统
var=`whoami`
echo $var var结果为执行whoami命令的结果 显示root
备注：反引号和$()作用相同
对三种引号的建议：
1、简单变量，简单赋值可以不用""
2、脚本中声明变量最好用""
3、原样子输出用’’
4、执行命令赋值最好用$()或者``
变量的作用域
Shell中的变量也分为全局变量和局部变量2种
1．全局变量
全局变量可以在脚本中定义，也可以在某个函数中定义。在脚本中定义的变量都是全局变量，其作用域为从被定义的地方开始，一直到Shell脚本结束或者被显式地删除
【例6】 演示全局变量的使用方法
#!/bin/bash
func() #定义函数
{
echo "$v1" #输出变量x的值
v1=200 #修改变量x的值
}
v1=100 #在脚本中定义变量x
func #调用函数
echo "$v1" #输出变量x的值
1
2
3
4
5
6
7
8
9
运行以上程序
[root@localhost ~]# ./test.sh
100
200
1
2
3
【例7】演示在函数内部定义全局变量的方法
#!/bin/bash
func() #定义函数
{
v2=200 #在函数内部定义变量
}
func #调用函数
echo "$v2" #输出变量的值
1
2
3
4
5
6
7
8
运行以上程序
[root@localhost ~]# ./test.sh
200
1
2
2、局部变量
与全局变量相比，局部变量的使用范围较小，通常仅限于某个程序段访问，例如函数内部。在Shell语言中，可以在函数内部通过local关键字定义局部变量，另外，函数的参数也是局部变量。
【例8】演示使用local关键字定义局部变量
#!/bin/bash
func() #定义函数
{
local v2=200 #使用local关键字定义局部变量,仅在函数体内部起作用，函数调用完毕，就完了
}
func #调用函数
echo "$v2" #输出变量的值
1
2
3
4
5
6
7
运行以上程序
[root@localhost ~]# ./test.sh
//NULL
1
2
【例9】演示全局变量和局部变量的区别
#!/bin/bash
func() #定义函数
{
echo "global variable v1 is $v1" #输出全局变量v1的值
local v1=2 #定义局部变量v1
echo "local variable v1 is $v1" #输出局部变量v1的值
}
v1=1 #定义全局变量v1
func #调用函数
echo "global variable v1 is $v1" #输出全局变量v1的值
1
2
3
4
5
6
7
8
9
10
运行以上程序
[root@localhost ~]# ./test.sh
global variable v1 is 1
local variable v1 is 2
global variable v1 is 1
1
2
3
4
【例10】演示全局变量和局部变量的区别（二）
#!/bin/bash
function test() {
local a
a="hello world"
echo $a
}
test
echo $a
1
2
3
4
5
6
7
8
运行以上程序
[root@localhost ~]# ./test.sh
hello world
//全局变量a无值
1
2
3
对比如下：
#!/bin/bash
function test() {
a="hello world"
echo $a
}
test
echo $a
1
2
3
4
5
6
7
运行以上程序
[root@localhost ~]# ./test.sh
hello world
hello world
1
2
3
总结：
1、全局变量总结
环境变量即为全局变量，可以在定义它们的shell及其派生出来的任意子进程的shell中使用。局部变量只能在定义它们的函数/脚本中使用。还有一些变量是用户创建的，其他的则是专用的shell变量。环境变量可用于定义shell的运行环境，环境变量可以在配置文件中定义与修改，也可以在命令行中设置，但是命令行中的修改操作在终端重启时就会丢失，因此最好在配置文件中修改（用户家目录的“.bash_profile“文件或者全局配置“/etc/profile”、“/etc/bashrc”文件或者“/etc/profile.d”文件中定义。）将环境变量放在profile文件中，每次用户登录时这些变量值将被初始化。比如HOME、USER、SHELL、UID等再用户登录之前就已经被/bin/login程序设置好了。
常见的系统环境变量如下：
TMOUT： 设置自动退出的误操作等待时间
HOSTTYPE： 系统文件系统类型
HISTSIZE： 历史命令记录条数
HOME： 用户登录时进入的目录，家目录
UID： 当前用户的id
SHELL： 当前shell解释器
PWD： 当前所在路径(每改变一次目录，该值就会改变)
PATH： 可执行文件默认路径
可以用echo来显示查看全局变量(eg：echo $HOME)。env(或printenv)、set也可以用来查看系统的环境变量，但不是单独查看。而用unset临时取消环境变量(eg:unset USER)，要永久生效还是要写到配置文件中
自定义环境变量(采用export)：
①export 变量名=value
②变量名=value;export 变量名
③declare -x 变量名=value
这里依旧是临时生效，在shell终端关闭后就消失了，写到配置文件中则永久生效(注意：写到配置文件中后需要运行一遍配置文件的脚本才可生效，否则等重启时生效)
2.局部变量总结
局部变量即为本地变量，本地变量在用户当前的shell生存期的脚本中使用。在一个函数中将某个变量声明为local，则该变量就是一个局部变量，只在本函数中有效。
3.关于局部变量的一些其他问题：
①用反引号将命令的结果作为变量名是常用的方法，eg：cmd=`date +%F`
②用$符号将命令的结果作为变量名也比较常用，eg：cmd=$(date +%F)
③变量在大括号上的使用：在以时间、主机名等为包名一部分来打包的时候常用
【例11】用时间作为文件名的一部分打包：
#!/bin/bash
cmd=$(date +%F) #由于`date +%F`的反引号不容易辨认，就不太使用`date +%F`
tar -zcf code_$(date +%F)_young1.tar.gz /etc #没有问题
tar -zcf code_`date +%F`_young2.tar.gz /etc #没有问题
tar -zcf code_young3_$cmd.tar.gz /etc #没有问题
tar -zcf code_$cmd_young4.tar.gz /etc #会有歧义，因为系统会不清楚是应该解析$cmd还是cmd_young
tar -zcf code_${cmd}_young5.tar.gz /etc #不会有歧义
1
2
3
4
5
6
7
运行结果如下：
[root@localhost ~]# ./test.sh
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
tar: Removing leading `/' from member names
[root@localhost ~]# ls -l code*
-rw-r--r--. 1 root root 9166435 Jun 5 03:39 code_2019-06-05_young1.tar.gz
-rw-r--r--. 1 root root 9166435 Jun 5 03:39 code_2019-06-05_young2.tar.gz
-rw-r--r--. 1 root root 9166435 Jun 5 03:39 code_2019-06-05_young5.tar.gz
-rw-r--r--. 1 root root 9166435 Jun 5 03:39 code_.tar.gz //中间变量不存在，用null替换了
-rw-r--r--. 1 root root 9166435 Jun 5 03:39 code_young3_2019-06-05.tar.gz
1
2
3
4
5
6
7
8
9
10
11
12
【例12】用主机名与时间打包：
#!/bin/bash
cmd=$(date +%F)
host=$(hostname)
tar -zcf code_${cmd}_${host}.tar.gz /etc
1
2
3
4
运行结果如下：
[root@localhost ~]# ls -l code*
-rw-r--r--. 1 root root 9166435 Jun 5 04:10 code_2019-06-05_localhost.localdomain.tar.gz
因此，养成将字符串括起来使用的习惯防止不易发现的错误
1
2
3
关于$?的补充：
[root@localhost ~]# vim test.cpp
#include<iostream>
using namespace std;
int main()
{
return 256; //超过上限，返回值范围为0-255，所以后面echo $？为0
}
[root@localhost ~]# rm -rf test
[root@localhost ~]# make test
g++ test.cpp -o test
[root@localhost ~]# ./test
[root@localhost ~]# echo $?
0
[root@localhost ~]# vim test.cpp
#include<iostream>
using namespace std;
int main()
{
return 255; //此处255在合法范围内，第一个vim中，该值设为256，产生上溢，为0，即返回给父进程的值只能是0-255.
}
[root@localhost ~]# make test
g++ test.cpp -o test
[root@localhost ~]# ./test
[root@localhost ~]# echo $?
255
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
关于$?在脚本中的应用：
常用来判断上一步是否成功（压缩失败打印ERROR压缩成功打印OK）：
[root@foundation0 ~]# cat test.sh
#!/bin/bash
tar profile.tar.gz /etc/profile >& /dev/null
[ $? -eq 0 ] && echo "tar profile OK" || echo "tar profile ERROR"
tar -zcf profile.d.tar.gz /etc/profile.d >& /dev/null
[ $? -eq 0 ] && echo " tar profile.d OK" || echo "tar profile.d ERROR"
[root@localhost ~]# ./test.sh
tar profile ERROR
tar profile.d OK
1
2
3
4
5
6
7
8
9
10
系统变量
Shell语言的系统变量主要在对参数判断和命令返回值判断时使用，包括脚本和函数的参数以及脚本和函数的返回值
变量 说明
$n 表示传递给脚本的第n个参数，例如$1表示第1个参数，$2表示第2个参数…
$# 命令行参数的个数
$0 当前脚本的名称
$? 前一个命令或者函数的返回状态码
$* 以“参数1 参数2 参数3…”的形式返回所有参数的值
$@ 以“参数1” “参数2” “参数3”…的形式返回所有参数的值
$_ 保存之前执行的命令的最后一个参数
$$ 返回本程序的进程ID（PID）
【例13】演示常用系统变量的使用方法
#!/bin/bash
echo "the number of parameters is $#" #输出脚本的参数个数
echo "the return code of last command is $?" #输出上一个命令的退出状态码
echo "the script name is $0" #输出当前脚本名称
echo "the parameters are $*" #输出所有的参数
echo "\$1=$1;\$2=$2;\$11=${11}" #输出其中的几个参数
1
2
3
4
5
6
运行以上程序
[root@localhost ~]# ./test.sh a b c d e f g h i j k l m n
the number of parameters is 14
the return code of last command is 0
the script name is ./test.sh
the parameters are a b c d e f g h i j k l m n
$1=a;$2=b;$11=k
1
2
3
4
5
6
环境变量
Shell的环境变量是所有的Shell程序都可以使用的变量。Shell程序在运行时，都会接收一组变量，这组变量就是环境变量。环境变量会影响到所有的脚本的执行结果。
除了上表列出的环境变量之外，用户还可以使用set命令列出当前系统的环境变量。
【例14】通过环境变量来获取与当前Shell有关的一些环境变量的值
#!/bin/bash
echo "commands path is $PATH" #输出命令搜索路径
echo "current login name is $LOGNAME" #输出当前的登录名
echo "current user's home is $HOME" #输出当前用户的主目录
echo "current shell is $SHELL" #输出当前的Shell
echo "current path is $PWD" #输出当前工作目录
1
2
3
4
5
6
运行以上程序
[root@localhost ~]# ./test.sh
commands path is /usr/lib64/qt-3.3/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
current login is root
current user's home is /root
current shell is /bin/bash
current path is /root
1
2
3
4
5
6
变量赋值和清空
变量赋值
在Shell中，变量的赋值使用以下语法：
variable_name=value
其中，varibale_name表示变量名，value表示变量的值。
例如，下面都是有效的赋值语句：
v1=Linux
v2='RedHat Linux'
v3="RedHat Linux $HOSTTYPE"
v4=12345
1
2
3
4
5
引用变量的值
在Shell中，通过在变量名前面加上“$”，来获取该变量的值。相当于取该地址上的内容
【例15】演示Shell变量的
#!/bin/bash
v1=Linux
v2='RedHat Linux'
v3="RedHat Linux $HOSTTYPE"
v4=12345
echo "$v1" #输出变量v1的值
echo "$v2" #输出变量
echo "$v3" #输出变量v3的值
echo "$v4" #输出变量v4的值
1
2
3
4
5
6
7
8
9
运行以上程序
[root@localhost ~]# ./test.sh
Linux
RedHat Linux
RedHat Linux x86_64
12345
1
2
3
4
5
清除变量
当Shell变量不再需要时，使用unset语句可以将其清除。当变量被清除后，其所代表的值也会消失。基本语法如下：
unset variable_name
其中，参数varibale_name表示要清除的变量的名称。
【例16】演示Shell变量清除方法，并且观察在清除前后变量值的变化
#!/bin/bash
v1="Hello world" #定义变量v1
echo "$v1" #输出v1的值
unset v1 #清除变量
echo "the value of v1 has been reset"
echo "$v1" #再次输出变量的值
1
2
3
4
5
6
运行以上程序
[root@localhost ~]# ./test.sh
Hello world
the value of v1 has been reset
//NULL
1
2
3
4
引用和替换
变量的引用和替换是Shell对于变量功能的扩展。
引用
引用，是指将字符串用引用符号包括起来，以防止其中的特殊字符被Shell解释为其他涵义。特殊字符是指除了字面意思之外还可以解释为其他意思的字符。例如在Shell中，“$”符号的本身涵义是美元符号，其ASCII码值为十进制36。除了这个涵义之外，前面已经讲过，“$”符号还可以用了获取某个变量的值，即变量替换。星号“*”也是一个特殊的字符，星号可以用来作为通配符使用。
【例17】演示星号通配符的使用方法
[root@localhost chapter3]# ll ex*
-rwxr-xr-x 1 root root 179 Jan 7 11:51 ex3-10.sh
-rwxr-xr-x 1 root root 114 Jan 7 15:49 ex3-11.sh
-rwxr-xr-x 1 root root 100 Jan 7 16:15 ex3-12.sh
1
2
3
4
符号 说明
双引号 除美元符号、单引号、反引号和反斜线之外，其他所有的字符都将保持字面意义
单引号 所有的字符都将保持字面意义
反引号 反引号中的字符串将被解释为Shell命令
反斜线 转义字符，屏蔽后的字符的特殊意义
全引用（’’）
在Shell语句中，当一个字符串被单引号引用起来之后，其中所有的字符，除单引号本身之外，都将被解释为字面意义，即字符本身的涵义。这意味着被单引号引用起来的所有的字符都将被解释为普通的字符，这称为全引用。
【例18】演示全引用的使用方法
#!/bin/bash
v1="value" #定义变量v1
echo 'Hello, $v1' #输出含有变量名的字符串
1
2
3
运行以上程序
[root@localhost ~]# ./test.sh
hello,$v1
1
2
部分引用（""）
对于单引号来说， 被其引用起来的所有的字符都将被解释为字面意义。而对于双引号来说，情况会有所不同。如果用户使用双引号将字符串引用起来，则其中所包含的字符除美元符号（KaTeX parse error: Expected 'EOF', got '\）' at position 15: ）、反引号（`）以及反斜线（\̲）̲之外的所有的其他的字符，都将被…”、“`”和“\”仍然拥有特殊的涵义。
【例19】演示部分引用的使用方法
#!/bin/bash
v1="world" #定义变量
echo "Hello, $v1" #输出变量的值
1
2
3
运行以上程序
[root@localhost ~]# ./test.sh
hello,world
1
2
命令替换
所谓命令替换，是指在Shell程序中，将某个Shell命令的执行结果赋给某个变量。在bash中，有2种语法可以进行命令替换，分别使用反引号和圆括号，如下：
`command`
$(command)
以上2种语法时等价的，用户可以根据自己的习惯来选择使用。
【例20】演示反引号的使用方法
#!/bin/bash
v1=`pwd` #变量替换
echo "current working directory is $v1" #输出变量的值
1
2
3
运行以上程序
[root@localhost ~]# ./test.sh
current working directory is /root
1
2
转义（\）
转义的作用是转换某些特殊字符的意义。转义使用反斜线表示，当反斜线后面的一个字符具有特殊的意义时，反斜线将屏蔽该字符的特殊意义，使得Shell按照该字符的字面意义来解释。
[root@localhost ~]# echo $SHELL
/bin/bash
[root@localhost ~]# echo \$SHELL
$SHELL
[root@localhost ~]# echo \$$SHELL
$/bin/bash
1
2
3
4
5
6
例题
1、变量赋值和替换
#!/bin/bash
# 变量赋值和替换
a=375
hello=$a
#-------------------------------------------------------------------------
# 强烈注意,在赋值的前后一定不要有空格.
# 如果有空格会发生什么?
# 如果"VARIABLE =value", 脚本将尝试运行一个"VARIABLE"的命令,带着一个"=value"参数.
# 如果"VARIABLE= value",
# script tries to run "value" command with
#+ 脚本将尝试运行一个"value"的命令,带着the environmental variable "VARIABLE" set to "".
#+ 一个被赋成""值的环境变量"VARIABLE".
#-------------------------------------------------------------------------
echo hello # 没有变量引用,不过是个 hello 字符串
echo $hello #375
echo ${hello} # 同上
echo "$hello" #375
echo "${hello}" #375
echo
hello="A B C D"
echo $hello # A B C D
echo "$hello" # A B C D
# 就象你看到的 echo $hello 和 echo "$hello" 将给出不同的结果.
# ^ ^
# Quoting a variable preserves whitespace.
# 引用一个变量将保留其中的空白,当然,如果是变量替换就不会保留了.
echo
echo '$hello' # $hello
# ^ ^
# 全引用的作用
#+ 将导致"$"变成一个单独的字符.
# 注意两种引用不同的效果
hello= # 设置为空值
echo "\$hello (null value) = $hello" #$hello (null value) =
# 注意设置一个变量为空,与 unset 它,不是一回事,虽然看起来一样，
#unset,地址都擦除了，设置为空，保留地址
# --------------------------------------------------------------
# 可以在同一行上设置多个变量.
#+ 要以空白分隔
# 小心,这会降低可读性,和可移植性.
var1=21 var2=22 var3=$V3
echo
echo "var1=$var1 var2=$var2 var3=$var3"
# 在老版本的"sh"上,可能会有问题.
# --------------------------------------------------------------
echo; echo
numbers="one two three"
# ^ ^
other_numbers="1 2 3"
# ^ ^
# 如果变量中有空白,那么引用就必要了.
echo "numbers = $numbers"
echo "other_numbers = $other_numbers" # other_numbers = 1 2 3
echo
echo "uninitialized_variable = $uninitialized_variable" # Uninitialized 变量为空值(根本就没赋值).
uninitialized_variable= # 声明,但是没被初始化，其实和前边设置为空值得作用是一样的.
echo "uninitialized_variable = $uninitialized_variable" # 还是一个空值
uninitialized_variable=23 # 赋值
unset uninitialized_variable # Unset it.
echo "uninitialized_variable = $uninitialized_variable" # 还是空值
echo
exit 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
一个空值变量,或者是根本就没声明的变量,在赋值之前使用它可能会引起问题. 但是还是可以用来做算术运算
2、
echo "$uninitialized" # (blank line) #空
let "uninitialized += 5" # Add 5 to it. #5
echo "$uninitialized" # 5 #5
# 结论:
# 对于一个空值变量在做算术操作的时候,就好像它的值为 0 一样.
# This is undocumented (and probably non-portable) behavior.
# 这并没被文档化(可能是不可移植)的行为.
1
2
3
4
5
6
7
3、一般变量赋值
#!/bin/bash
# "裸体"变量
echo
# 变量什么时候是"裸体"的,比如前边少了$的时候.
# 当它被赋值的时候,而不是被引用的时候.
# 赋值
a=879
echo "The value of \"a\" is $a." #879
let a=16+5 # 使用 let 赋值 #21
echo "The value of \"a\" is now $a." #21
echo
# 在 for 循环中
echo -n "Values of \"a\" in the loop are: "
for a in 7 8 9 11
do
echo -n "$a "
done
echo
echo
# 在 read 命令状态中
echo -n "Enter \"a\" "
read a #屏幕输入的a
echo "The value of \"a\" is now $a."
echo
exit 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
运行以上程序
[root@localhost ~]# ./test.sh
The value of "a" is 879.
The value of "a" is now 21.
Values of "a" in the loop are: 7 8 9 11
Enter "a" 8
The value of "a" is now 8.
[root@localhost ~]#
1
2
3
4
5
6
7
8
9
10
11
4、变量赋值,一般的和比较特殊的
#!/bin/bash
a=23 # Simple case
echo $a #23
b=$a
echo $b #23
# 现在让我们来点小变化
a=`echo Hello!` # 把 echo 命令的结果传给变量 a
echo $a #hello!
# 注意,如果在命令扩展结构中使用一个(!)的话,在命令行中将不能工作
#+ 因为这触发了 Bash 的"历史机制".
# 但是,在校本里边使用的话,历史功能是被关闭的,所以就能够正常运行.
a=`ls-l` # 把 ls -l 的结果给 a
echo $a # 别忘了,这么引用的话,ls 的结果中的所有空白部分都没了(包括换行)
echo
echo "$a" # 这么引用就正常了,保留了空白
# (具体参阅章节"引用")
exit 0