Shell语言中的变量和引用

变量

简介

变量就是程序设计语言中的一个可以变化的量，当然，可以变化的是变量的值。变量几乎所有的程序设计语言中都有定义，并且其涵义也大同小异。从本质上讲，变量就是在程序中保存用户数据的一块内存空间，而变量名就是这块内存空间的地址。
在程序的执行过程中，保存数据的内存空间的内容可能会不断地发生变化，但是，代表内存地址的变量名却保持不变。

命名

在Shell中，变量名可以由字母、数字或者下划线组成，并且只能以字母或者下划线开头。对于变量名的长度，Shell并没有做出明确的规定。因此，用户可以使用任意长度的字符串来作为变量名。但是，为了提高程序的可读性，建议用户使用相对较短的字符串作为变量名。
在一个设计良好的程序中，变量的命名有着非常大的学问。通常情况下，用户应该尽可能选择有明确意义的英文单词作为变量名，尽量避免使用拼音或者毫无意义的字符串作为变量名。这样的话，用户通过变量名就可以了解该变量的作用。
例如，下面的变量名都是非常好的选择：

PATH=/sbin
UID=100
JAVA_HOME="/usr/lib/jvm/jre-1.6.0-openjdk.x86_64/bin/../.."
SSHD=/usr/sbin/sshd

变量的类型

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"

上述代码运行结果

[root@localhost ~]# ./test.sh
x = 124
y = abc24
y = abc24
y = 1
z = abc22
m = 1122
m = 1123
n =
n = 1
p =
p = 1

在Shell中，通常情况下用户可以直接使用变量，而毋需先进行定义，当用户第一次使用某个变量名时，实际上就同时定义了这个变量，在变量的作用域内，用户都可以使用该变量。
【例2】演示通过直接使用变量来定义变量

#!/bin/bash
a=1                #定义变量a    #类似于 int n=3 这种操作
b="hello"        #定义变量b
c="hello world"      #定义变量c

通过declare命令声明变量

declare attribute variable（声明变量属性）

-p：显示所有变量的值。
-i：将变量定义为整数。在之后就可以直接对表达式求值，结果只能是整数。如果求值失败或者不是整数，就设置为0。declare -i t，把t设置为整型
-r：将变量声明为只读变量。只读变量不允许修改，也不允许删除。readonly，
-a：变量声明为数组变量。但这没有必要。所有变量都不必显式定义就可以用作数组。事实上，在某种意义上，似乎所有变量都是数组，而且赋值给没有下标的变量与赋值给下标为0的数组元素相同. array，矩阵，变长数组
-f：显示所有自定义函数，包括名称和函数体。function
-x：将变量设置成环境变量，这样在随后的脚本和程序中可以使用。

【例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

运行以上程序

[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

引用

Shell语言中一共有3种引号，分别为
单引号（’ '）单引号括起来的字符都作为普通字符出现
双引号（" "）双引号括起来的字符，除“$”、“\”、“ ’ ”和“ " ”这几个字符仍是特殊字符并保留其特殊功能外，其余字符仍作为普通字符对待，
反引号（` `）。反引号括起来的字串被Shell解释为命令，在执行时，Shell首先执行该命令，并以它的标准输出结果取代整个反引号（包括两个反引号）部分
【例4】演示反引号使用方法

#!/bin/bash
#输出当前目录
echo "current directory is `pwd`"

运行以上程序

[root@localhost ~]# ./test.sh
current directory is /root

【例5】演示单双引号使用方法

#!/bin/bash
a= demo
b='b- $a'
c="b- $a"
echo $a
echo $b
echo $c
运行结果如下：
demo
b- $a   #单引号，所见即所得
b- demo

三种引号的理解：

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的值

运行以上程序

[root@localhost ~]# ./test.sh
100
200

【例7】演示在函数内部定义全局变量的方法

#!/bin/bashfunc()                    #定义函数
{v2=200                #在函数内部定义变量
}
func                    #调用函数
echo "$v2"                #输出变量的值

运行以上程序

[root@localhost ~]# ./test.sh
200

2、局部变量

与全局变量相比，局部变量的使用范围较小，通常仅限于某个程序段访问，例如函数内部。在Shell语言中，可以在函数内部通过local关键字定义局部变量，另外，函数的参数也是局部变量。
【例8】演示使用local关键字定义局部变量

#!/bin/bash
func()              #定义函数
{local v2=200      #使用local关键字定义局部变量,仅在函数体内部起作用，函数调用完毕，就完了
}
func                #调用函数
echo "$v2"            #输出变量的值

运行以上程序

[root@localhost ~]# ./test.sh//NULL

【例9】演示全局变量和局部变量的区别

#!/bin/bash
func()                                  #定义函数
{echo "global variable v1 is $v1"     #输出全局变量v1的值local v1=2                          #定义局部变量v1echo "local variable v1 is $v1"      #输出局部变量v1的值
}
v1=1                                   #定义全局变量v1
func                                    #调用函数
echo "global variable v1 is $v1"      #输出全局变量v1的值

运行以上程序

[root@localhost ~]# ./test.sh
global variable v1 is 1
local variable v1 is 2
global variable v1 is 1

【例10】演示全局变量和局部变量的区别（二）

#!/bin/bash
function test() {local a
a="hello world"
echo $a
}
test
echo $a

运行以上程序

[root@localhost ~]# ./test.sh
hello world//全局变量a无值

对比如下：

#!/bin/bash
function test() {a="hello world"
echo $a
}
test
echo $a

运行以上程序

[root@localhost ~]# ./test.sh
hello world
hello world

总结：

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  #不会有歧义

运行结果如下：

[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

【例12】用主机名与时间打包：

#!/bin/bash
cmd=$(date +%F)
host=$(hostname)
tar -zcf code_${cmd}_${host}.tar.gz /etc

运行结果如下：

[root@localhost ~]# ls -l code*
-rw-r--r--. 1 root root 9166435 Jun  5 04:10 code_2019-06-05_localhost.localdomain.tar.gz
因此，养成将字符串括起来使用的习惯防止不易发现的错误

关于$?的补充：

[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

关于$?在脚本中的应用：
常用来判断上一步是否成功（压缩失败打印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 ERRORtar profile.d OK

系统变量

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}"                    #输出其中的几个参数

运行以上程序

[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

环境变量

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"               #输出当前工作目录

运行以上程序

[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

变量赋值和清空

变量赋值

在Shell中，变量的赋值使用以下语法：
variable_name=value
其中，varibale_name表示变量名，value表示变量的值。

例如，下面都是有效的赋值语句：
v1=Linux
v2='RedHat Linux'
v3="RedHat Linux $HOSTTYPE"
v4=12345

引用变量的值

在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的值

运行以上程序

[root@localhost ~]# ./test.sh
Linux
RedHat Linux
RedHat Linux x86_64
12345

清除变量

当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"                                #再次输出变量的值

运行以上程序

[root@localhost ~]# ./test.sh
Hello world
the value of v1 has been reset//NULL

引用和替换

变量的引用和替换是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

符号	说明
双引号	除美元符号、单引号、反引号和反斜线之外，其他所有的字符都将保持字面意义
单引号	所有的字符都将保持字面意义
反引号	反引号中的字符串将被解释为Shell命令
反斜线	转义字符，屏蔽后的字符的特殊意义

全引用（’’）

在Shell语句中，当一个字符串被单引号引用起来之后，其中所有的字符，除单引号本身之外，都将被解释为字面意义，即字符本身的涵义。这意味着被单引号引用起来的所有的字符都将被解释为普通的字符，这称为全引用。

【例18】演示全引用的使用方法

#!/bin/bash
v1="value"           #定义变量v1
echo 'Hello, $v1' #输出含有变量名的字符串

运行以上程序

[root@localhost ~]# ./test.sh
hello,$v1

部分引用（""）

对于单引号来说，被其引用起来的所有的字符都将被解释为字面意义。而对于双引号来说，情况会有所不同。如果用户使用双引号将字符串引用起来，则其中所包含的字符除美元符号（KaTeX parse error: Expected 'EOF', got '\）' at position 15: ）、反引号（`）以及反斜线（\̲）̲之外的所有的其他的字符，都将被…”、“`”和“\”仍然拥有特殊的涵义。
【例19】演示部分引用的使用方法

#!/bin/bash
v1="world"           #定义变量
echo "Hello, $v1" #输出变量的值

运行以上程序

[root@localhost ~]# ./test.sh
hello,world

命令替换

所谓命令替换，是指在Shell程序中，将某个Shell命令的执行结果赋给某个变量。在bash中，有2种语法可以进行命令替换，分别使用反引号和圆括号，如下：
`command`
$(command)
以上2种语法时等价的，用户可以根据自己的习惯来选择使用。

【例20】演示反引号的使用方法

#!/bin/bash
v1=`pwd`     #变量替换
echo "current working directory is $v1"       #输出变量的值

运行以上程序

[root@localhost ~]# ./test.sh
current working directory is /root

转义（\）

转义的作用是转换某些特殊字符的意义。转义使用反斜线表示，当反斜线后面的一个字符具有特殊的意义时，反斜线将屏蔽该字符的特殊意义，使得Shell按照该字符的字面意义来解释。

[root@localhost ~]# echo $SHELL
/bin/bash
[root@localhost ~]# echo \$SHELL
$SHELL
[root@localhost ~]# echo \$$SHELL
$/bin/bash

例题

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

一个空值变量,或者是根本就没声明的变量,在赋值之前使用它可能会引起问题. 但是还是可以用来做算术运算
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.
# 这并没被文档化(可能是不可移植)的行为.

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

运行以上程序

[root@localhost ~]# ./test.shThe 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 ~]#

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