A=" B" # IFS被关闭了（请参考前面的quoting章节）
A1=B # 并非以数字开头
A=$B # $可用在变量值内
This_Is_A_Long_Name=b #可用_连接较长的名称或值，且大小写有别。

$ A=ls
$ B=la
$ C=/tmp
$ $A -$B $C

ls -la /tmp

$ echo $A -$B $C

ls -la /tmp

A=B
B=$A

A=B
B=C

A=B
B=$A
A=C

A=B:C:D
A=$A:E

A=BCD
A=$AE

A=BCD
A=${A}E

$ A=B
$ export A

$ export A=B

$ A=B
$ B=C
$ export $A

$ A=B
$ B=C
$ unset $A

$ A=
$ unset A

$ A=
$ echo $A

$ unset A
$ echo $A

$ str= #设为null
$ var=${str=expr} #定义var
$ echo $var

$ echo $str

$ unset str #取消
$ var=${str=expr} #定义var
$ echo $var
expr
$ echo $str
expr

var=expr
str=expr

var=
str=

var=xyz
str=xyz

./my.script

source ./my.script

../my.script

#!/bin/bash
A=B
echo "PID for 1.sh before exec/source/fork:$$"
export A
echo "1.sh: \$A is $A"
case $1 in
 exec)
  echo "using exec…"
  exec ./2.sh;;
 source)
  echo "using source…"
  ../2.sh;;
 *)
  echo "using fork by default…"
  ./2.sh;;
esac
echo "PID for 1.sh after exec/source/fork:$$"
echo "1.sh: \$A is $A"

#!/bin/bash
echo "PID for 2.sh: $$"
echo "2.sh get \$A=$A from 1.sh"
A=C
export A
echo "2.sh: \$A is $A"

$ ./1.sh fork
$ ./1.sh source
$ ./1.sh exec

function function_name {
command1
command2
command3
…
}

fuction_name() {
command1
command2
command3
…
}

$ echo the last sunday is $(date -d "last sunday" +%Y-%m-%d)

command1 `command2 `command3` `

command1 `command2 \`command3\` `

command1 $(command2 $(command3))

$ A=B
$ echo $AB

$ echo ${A}B
BB

file=/dir1/dir2/dir3/my.file.txt

${file#*/} # 拿掉第一条/及其左边的字串：dir1/dir2/dir3/my.file.txt
${file##*/} # 拿掉最后一条/及其左边的字串：my.file.txt
${file#*.} # 拿掉第一个.及其左边的字串：file.txt
${file##*.} # 拿掉最后一个.及其左边的字串：txt
${file%/*} # 拿掉最后条/及其右边的字串：/dir1/dir2/dir3
${file%%/*} # 拿掉第一条/及其右边的字串：（空值）
${file%.*} # 拿掉最后一个.及其右边的字串：/dir1/dir2/dir3/my.file
${file%%.*} #拿掉第一个.及其右边的字串：/dir1/dir2/dir3/my

${file:0:5} # 提取最左边的5个字节：/dir1

${file:5:5} # 提取第5个字节右边的连续5个字节：/dir2

${file/dir/path} # 将第一个dir提换为path:/path1/dir2/dir3/my.file.txt
${file//dir/path} # 将全部dir提换为path:/path1/path2/path3/my.file.txt

${file-my.file.txt} # 假如$file没有设定，则使用my.file.txt作传回值。（空值及非空值时不作处理）
${file:-my.file.txt} # 假如$file没有设定或为空值，则使用my.file.txt作传回值。（非空值时不作处理）
${file+my.file.txt} # 假如$file设为空值或非空值，均使用my.file.txt作传回值。（没设定时不作处理）
${file:+my.file.txt} # 若$file为非空值，则使用my.file.txt作传回值。（没设定及空值时不作处理）
${file=my.file.txt} # 若$file没设定，则使用my.file.txt作传回值，同时将$file赋值为my.file.txt。（空值及非空值时不作处理）
${file:=my.file.txt} # 若$file没设定或为空值，则使用my.file.txt作传回值，同时将$file赋值为my.file.txt。（非空值时不作处理）
${file"a b c def"这样的变量只是将$A替换为一个单一的字串，但是改为A=(a b c def)，则是将$A定义为数组…bash的数组替换方法可参考如下方法：


  
${A[@]}或${A[*]} # 可得到a b c def（全部组数）
  
${A[0]} # 可得到a（第一个组数），${A[1]}则为第二个组数…
  
${#A[@]}或${#A[*]} #可得到4（全部组数数量）
  
${#A[0]} #可得到1（即第一个组数（a）的长度），${#A[3]}可得到3（第四个组数（def）的长度）
  
A[3]=xyz # 则是将第四个组数重新定义为xyz…
  
能够善用bash的$()与${}可大大提高及简化shell在变量上的处理能力哦~~~ ^_^

好了，最后为大家介绍$(())的用途吧：它是用来作整数运算的。在bash中，$(())的整数运算符号大致有这些：+ - * /：分别为“加、减、乘、除”。%：余数运算。& | ^！：分别为“AND、OR、XOR、NOT”运算。
例：


$ a=5;b=7;c=2
$ echo $((a+b*c))
19
$ echo $(((a+b)/c))
6
$ echo $(((a*b)%c))
1



在$(())中的变量名称，可于其前面加$符号来替换，也可以不用，如：

$(($a + $b * $c))也可得到19的结果
此外，$(())还可作不同进位（如二进位、八进位、十六进位）作运算呢，只是，输出结果皆为十进制而已：
echo $((16#2a)) # 结果为42（16进位转十进制）

以一个实用的例子来看看吧：假如当前的umask是022，那么新建文件的权限即为：




$ umask 022
$ echo "obase=8;$((8#666 & (8#777 ^ 8#$(umask))))" | bc
644



事实上，单纯用(())也可重定义变量值，或作testing：
a=5；((a++)) #可将$a重定义为6

a=5；((a--)) 则为a=4

a=5；b=7；((a < b)) 会得到0（true）的返回值。
常见的用于(())的测试符号有如下这些：

  
<：小于
  
\>：大于
  
<=：小于或等于
  
\>=：大于或等于
  
==：等于
  
!=：不等于

不过，使用(())作整数测试时，请不要跟[ ]的整数测试搞混乱了。（更多的测试我将于第十章为大家介绍）怎样？好玩吧..^_^ okay，这次暂时说这么多…
上面的介绍，并没有详列每一种可用的状态，更多的，就请读者参考手册文件啰…
第9问：$@ 與 $* 差在哪？

要说$@与$*之前，需得先从shell script的positional parameter谈起…
我们都已经知道变量（variable）是如何定义及替换的，这个不用再多讲了。但是，我们还需要知道有些变量是shell内定的，且其名称是我们不能随意修改的，其中就有positional parameter在内。在shell script中，我们可用$0，$1，$2，$3…这样的变量分别提取命令行中的如下部份：


script_name parameter1 parameter2 parameter3…



我们很容易就能猜出$0就是代表shell script名称（路径）本身，而$1就是其后的第一个参数，如此类推… 须得留意的是IFS的作用，也就是，若IFS被quoting处理后，那么positional parameter也会改变。如下例：


my.sh p1 "p2 p3" p4



由于在p2与p3之间的空白键被soft quote所关闭了，因此my.sh中的$2是"p2 p3"而$3则是p4…
还记得前两章我们提到fucntion时，我不是说过它是script中的script吗？^_^ 是的，function一样可以读取自己的（有别于script的）postitional parameter，惟一例外的是$0而已。举例而言：假设my.sh里有一个fucntion叫my_fun，若在script中跑my_fun fp1 fp2 fp3，那么，function内的$0是my.sh，而$1则是fp1而非p1了…不如写个简单的my.sh script看看吧：


#!/bin/bash
my_fun() {
echo '$0 inside function is '$0
echo '$1 inside function is '$1
echo '$2 inside function is '$2
}
echo '$0 outside function is '$0
echo '$1 outside function is '$1
echo '$2 outside function is '$2
my_fun fp1 "fp2 fp3"



然后在command line中跑一下script就知道了：


chmod +x my.sh
./my.sh p1 "p2 p3"
$0 outside function is ./my.sh
$1 outside function is p1
$2 outside function is p2 p3
$0 inside function is ./my.sh
$1 inside function is fp1
$2 inside function is fp2 fp3



然而，在使用positional parameter的时候，我们要注意一些陷井哦：
$10不是替换第10个参数，而是替换第一个参数（$1）然后再补一个0于其后!

也就是，my.sh one two three four five six seven eigth nine ten这样的command line，my.sh里的$10不是ten而是one0哦…小心小心!要抓到ten的话，有两种方法：
方法一是使用我们上一章介绍的${ }，也就是用${10}即可。
方法二，就是shift了。用通俗的说法来说，所谓的shift就是取消positional parameter中最左边的参数（$0不受影响）。其预设值为1，也就是shift或shift 1都是取消$1，而原本的$2则变成$1、$3变成$2…若shift 3则是取消前面三个参数，也就是原本的$4将变成$1…
那，亲爱的读者，你说要shift掉多少个参数，才可用$1取得${10}呢？^_^
okay，当我们对positional parameter有了基本概念之后，那再让我们看看其他相关变量吧。
首先是$#：它可抓出positional parameter的数量。以前面的my.sh p1 "p2 p3"为例：由于p2与p3之间的IFS是在soft quote中，因此$#可得到2的值。但如果p2与p3没有置于quoting中话，那$#就可得到3的值了。同样的道理在function中也是一样的…
因此，我们常在shell script里用如下方法测试script是否有读进参数：
[ $# = 0 ]

假如为0，那就表示script没有参数，否则就是有带参数…
接下来就是$@与$*：精确来讲，两者只有在soft quote中才有差异，否则，都表示“全部参数”（$0除外）。举例来说好了：若在command line上跑my.sh p1 "p2 p3" p4的话，不管是$@还是$*，都可得到p1 p2 p3 p4就是了。但是，如果置于soft quote中的话：

  
"$@" 则可得到"p1" "p2 p3" "p4"这三个不同的词段（word）
  
"$*" 则可得到"p1 p2 p3 p4"这一整串单一的词段。

我们可修改一下前面的my.sh，使之内容如下：


#!/bin/bash
my_fun() {
echo "$#"
}
echo 'the number of parameter in "$@" is '$(my_fun "$@")
echo 'the number of parameter in "$*" is '$(my_fun "$*")



然后再执行./my.sh p1 "p2 p3" p4就知道$@与$*差在哪了…^_^


the number of parameter in "$@" is 3
the number of parameter in "$*" is 1



第10问：&& 與 || 差在哪？

好不容易，进入两位数的章节了…一路走来，很辛苦吧？也很快乐吧？^_^ 在解答本章题目之前，先让我们了解一个概念：return value!
我们在shell下跑的每一个command或function，在结束的时候都会传回父行程一个值，称为return value。在shell command line中可用$"新"的一个return value，也就是刚结束的那个行程传回的值。Return Value（RV）的取值为0-255之间，由程序（或script）的作者自行定议：
若在script里，用exit RV来指定其值，若没指定，在结束时以最后一道命令之RV为值。

若在function里，则用return RV来代替exit RV即可。

Return Value的作用，是用来判断行程的退出状态（exit status），只有两种：

  
0的话为“真”（true）
  
非0的话为“假”（false）

举个例子来说明好了：假设当前目录内有一份my.file的文件，而no.file是不存在的：


$ touch my.file
$ ls my.file
$ echo $"专门"用来测试某一条件而送出return value以供true或false的判断，它就是test命令了!

若你用的是bash，请在command line下打man test或man bash来了解这个test的用法。这是你可用作参考的最精确的文件了，要是听别人说的，仅作参考就好…下面我只简单作一些辅助说明，其余的一律以man为准：
首先，test的表示式我们称为expression，其命令格式有两种：


test expression 
or:
[ expression ]



（请务必注意[ ]之间的空白键﹗）
用哪一种格式没所谓，都是一样的效果。（我个人比较喜欢后者…）其次，bash的test目前支持的测试对像只有三种：
string：字串，也就是纯文字。

integer：整数（0或正整数，不含负数或小数点）。

file：文件。

请初学者一定要搞清楚这三者的差异，因为test所用的expression是不一样的。
以A=123这个变量为例：


[ "$A" = 123 ] # 是字串的测试，以测试$A是否为1、2、3这三个连续的“文字”。
[ "A" -eq 123 ] # 是整数的测试，以测试$A是否等于“一百二十三”。
[ -e "$A" ]  # 是关于文件的测试，以测试123这份“文件”是否存在。



第三，当expression测试为“真”时，test就送回0（true）的return value，否则送出非0（false）。若在expression之前加上一个!（感叹号），则是当expression为“假时”才送出0，否则送出非0。
同时，test也允许多重的复合测试：


expression1 -a expression2 # 当两个exrepssion都为true，才送出0，否则送出非0。
expression1 -o expression2 # 只需其中一个exrepssion为true，就送出0，只有两者都为false才送出非0。



例如：


[ -d "$file" -a -x "$file" ]



是表示当$file是一个目录、且同时具有x权限时，test才会为true。
第四，在command line中使用test时，请别忘记命令行的“重组”特性，也就是在碰到meta时会先处理meta再重新组建命令行。（这个特性我在第二及第四章都曾反复强调过）比方说，若test碰到变量或命令替换时，若不能满足expression格式时，将会得到语法错误的结果。举例来说好了：关于[ string1 = string2 ]这个test格式，在=号两边必须要有字串，其中包括空（null）字串（可用soft quote或hard quote取得）。
假如$A目前没有定义，或被定议为空字串的话，那如下的写法将会失败：


$ unset A
$ [ $A = abc ]
[：=：unary operator expected



这是因为命令行碰到$这个meta时，会替换$A的值，然后再重组命令行，那就变成了：[ = abc ]
如此一来=号左边就没有字串存在了，因此造成test的语法错误﹗但是，下面这个写法则是成立的：


$ [ "$A" = abc ]
$ echo $"" = abc ]。由于=左边我们用soft quote得到一个空字串，而让test语法得以通过…读者诸君请务必留意这些细节哦，因为稍一不慎，将会导至test的结果变了个样!

若您对test还不是很有经验的话，那在使用test时不妨先采用如下这一个"法则"：
假如在test中碰到变量替换，用soft quote是最保险的﹗若你对quoting不熟的话，请重新温习第四章的内容吧…^_^

okay，关于更多的test用法，老话一句：请看man page吧！^_^ 虽然洋洋洒洒讲了一大堆，或许你还在嘀咕….那…那个return value有啥用啊？！问得好﹗
告诉你：return value的作用可大了﹗若你想让你的shell变“聪明”的话，就全靠它了：
有了return value，我们可以让shell跟据不同的状态做不同的时情…

这时候，才让我来揭晓本章的答案吧~~~ ^_^ && 与 || 都是用来“组建”多个command line用的：
command1 && command2：其意思是command2只有在RV为0（true）的条件下执行。

command1 || command2：其意思是command2只有在RV为非0（false）的条件下执行。

来，以例子来说好了：


$ A=123
$ [ -n "$A" ] && echo "yes!it's ture."
yes!it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes!it's ture."
$ [ -n "$A" ] || echo "no,it's NOT ture."
no,it's NOT ture.



（注：[ -n string ]是测试string长度大于0则为true。）
上例的第一个&&命令行之所以会执行其右边的echo命令，是因为上一个test送回了0的RV值﹔但第二次就不会执行，因为test送回非0的结果…同理，||右边的echo会被执行，却正是因为左边的test送回非0所引起的。
事实上，我们在同一命令行中，可用多个&&或||来组建呢：


$ A=123
$ [ -n "$A" ] && echo "yes！it's ture." || echo "no，it's NOT ture."
yes!it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes!it's ture." || echo "no,it's NOT ture."
no,it's NOT ture.



怎样，从这一刻开始，你是否觉得我们的shell是“很聪明”的呢？^_^ 好了，最后，布置一道习题给大家做做看...
下面的判断是：当$A被赋与值时，再看是否小于100，否则送出too big!：


$ A=123
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!



若我将A取消，照理说，应该不会送文字才对啊（因为第一个条件就不成立了）…


$ unset A
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!





                                
                                

                                    Linux,shell,bash 
                                
DDR爱好者之家 Design By 杰米