# 井号
这几乎是个shell满场都有的符号，用在shell脚本的开头，如"#!/bin/bash" 井号也常出现在一行的开头，或者位于完整指令之后，这类情况表示符号后面的是注解文字，不会被执行。
由于这个特性，当临时不想执行某行指令时，只需在该行开头加上 # 就行了。这常用在撰写过程中。
如果被用在指令中，或者引号双引号括住的话，或者在倒斜线的后面，那他就变成一般符号，不具上述的特殊功能。
~ 用户家目录
算是个常见的符号，代表使用者的 home 目录：cd ~；也可以直接在符号后加上某帐户的名称：cd ~user或者当成是路径的一部份：~/bin
~+ 当前的工作目录，这个符号代表当前的工作目录，她和内建指令 pwd的作用是相同的。
[root@VM_16_9_centos ~]# pwd
/root
[root@VM_16_9_centos ~]# echo ~+/var/log
/root/var/log
~- 上次的工作目录，这个符号代表上次的工作目录。
[root@VM_16_9_centos ~]# pwd
/root
[root@VM_16_9_centos ~]# echo ~+/var/log
/root/var/log
[root@VM_16_9_centos ~]# echo ~-/etc/httpd/logs
/root/test/etc/httpd/logs
; 分号
在 shell 中，担任"连续指令"功能的符号就是"分号"。譬如以下的例子：
[root@VM_16_9_centos ~]# mkdir test;cd test;echo "safd" >test1;cat test1;pwd
safd
/root/test
;; 连续分号
专用在 case 的选项，担任 Terminator 的角色。
[root@localhost ~]# cat a.sh
#!/bin/bash read -p "please write:" fop case ${fop} in
help)
echo "Usage: Command -help -version filename";;
version)
echo "version 0.1" ;;
esac [root@localhost ~]# sh a.sh
please write:help
Usage: Command -help -version filename
. 点号 (dot,就是“点”)
在 shell 中，使用者应该都清楚，一个 dot 代表当前目录，两个 dot 代表上层目录。
[root@ss-server ~]# cd /usr/local/src/
[root@bz3aomsmsap1002 src]# cd ../
[root@bz3aomsmsap1002 local]# pwd
/usr/local [root@ss-server ~]# cd /usr/local/src/
[root@bz3aomsmsap1002 src]# cd ../../
[root@bz3aomsmsap1002 usr]# pwd
/usr
如果档案名以 dot 开头，该档案就属特殊档案，用 ls指令必须加-a 选项才会显示(即查看隐藏文件)。除此之外，在 regularexpression 中，一个 dot 代表匹配一个字元。
' ' 单引号 (single quote)
被单引号用括住的内容，将被视为单一字串。在引号内的代表变数的$符号，没有作用，也就是说，他被视为一般符号处理，防止任何变量替换。
[root@localhost ~]# heyyou=homeecho
[root@localhost ~]# echo '$heyyou'
$heyyou
" " 双引号 (double quote)
被双引号用括住的内容，将被视为单一字串。它防止通配符扩展，但允许变量扩展。这点与单引数的处理方式不同。
[root@VM_16_9_centos ~]# heyyou=homeecho
[root@VM_16_9_centos ~]# echo ${heyyou}
homeecho
[root@VM_16_9_centos ~]# echo '${heyyou}'
${heyyou}
[root@VM_16_9_centos ~]# echo "${heyyou}"
homeecho
`` 倒引号，相当于$()，表示命令替换，将里面命令执行结果传给变量参数。
在前面的单双引号，括住的是字串，但如果该字串是一列命令列，会怎样？答案是不会执行。要处理这种情况，我们得用倒单引号``来做。
[root@VM_16_9_centos ~]# fdv=`date +%F`
[root@VM_16_9_centos ~]# echo "Today $fdv"
Today 2019-11-28
在倒引号内的 date +%F 会被视为指令，执行的结果会带入 fdv 变数中。
, 逗点 (标点中的逗号)
这个符号常运用在运算当中当做"区隔"用途。如下例:
[root@VM_16_9_centos ~]# cat a.sh
#!/bin/bash
let "t1 = ((a = 5 + 3, b = 7 - 1, c = 15 / 3))"
echo "t1= $t1, a = $a, b = $b"
[root@VM_16_9_centos ~]# sh a.sh
t1= 5, a = 8, b = 6
/ 斜线
在路径表示时，代表目录。
[root@VM_16_9_centos ~]# cd /etc/rc.d
[root@VM_16_9_centos rc.d]# cd ../..
[root@VM_16_9_centos /]#
通常单一的 / 代表 root 根目录的意思；在四则运算中，代表除法的符号。
[root@VM_16_9_centos ~]# let "num1 = ((a = 10 / 2, b = 25 / 5))"
[root@VM_16_9_centos ~]# echo ${num1}
5
\\ 双倒斜线 和 \ 单倒斜线
\\ 双倒斜线：放在指令前，有取消 aliases的作用
=======================================
[root@localhost ~]# alias kevin="ls"
[root@localhost ~]# kevin
a anaconda-ks.cfg
[root@localhost ~]# kevin -l
total 4
-rw-r--r-- 1 root root 0 Nov 28 22:56 a
-rw-------. 1 root root 1850 Oct 22 12:11 anaconda-ks.cfg [root@localhost ~]# \\kevin
-bash: \kevin: command not found [root@localhost ~]# \\kevin -l
-bash: \kevin: command not found \ 单倒斜线：放在特殊符号前，则该特殊符号的作用消失。即转义符号
=======================================
[root@VM_16_9_centos ~]# bkdir=/home
[root@VM_16_9_centos ~]# echo "this is ${bkdir}"
this is /home
[root@VM_16_9_centos ~]# echo "this is \${bkdir}"
this is ${bkdir}
[root@VM_16_9_centos ~]# echo \"this is ${bkdir}\"
"this is /home"
[root@VM_16_9_centos ~]# echo \"this is \${bkdir}\"
"this is ${bkdir}"
| 管道 (pipeline)
pipeline 是 Linux系统中基础且重要的观念。连结上个指令的标准输出，做为下个指令的标准输入。
[root@VM_16_9_centos ~]# who
root pts/0 2019-11-28 22:49 (115.171.60.14)
root pts/1 2019-11-28 23:01 (115.171.60.14)
[root@VM_16_9_centos ~]# who | wc -l
2
善用这个观念，对精简 script 有相当的帮助。
! 惊叹号(negate or reverse)
通常它代表反逻辑的作用，譬如条件侦测中，用 != 来代表"不等于"
[root@VM_16_9_centos ~]# cat a.sh
#!/bin/bash if [ "$?" != 0 ];then
echo "Executes error"
exit 1
fi
[root@VM_16_9_centos ~]# sh a.sh
"Executes error"
在规则表达式中她担任 "反逻辑" 的角色
[root@VM_16_9_centos ~]# touch bo{0,1,2,3,4,5,6,7,8,9}
[root@VM_16_9_centos ~]# ls
bo0 bo1 bo2 bo3 bo4 bo5 bo6 bo7 bo8 bo9
[root@VM_16_9_centos ~]# ls bo{0,1,2,3}
bo0 bo1 bo2 bo3
[root@VM_16_9_centos ~]# ls bo[0-3]
bo0 bo1 bo2 bo3
显示除了bo0-bo3之外的其他文件
[root@VM_16_9_centos ~]# ls bo[!0-3]
bo4 bo5 bo6 bo7 bo8 bo9
显示除了bo5-bo8之外的其他文件
[root@VM_16_9_centos ~]# ls bo[!5-8]
bo0 bo1 bo2 bo3 bo4 bo9
: 内奸指令
在 bash 中，这是一个内建指令："什么事都不干"，但返回状态值 0。
什么都不干，返回状态值 0
[root@VM_16_9_centos ~]# echo $?
0 [root@VM_16_9_centos ~]# : > a.txt
上面这一行，相当于
[root@VM_16_9_centos ~]# cat /dev/null >a.xtt
不仅写法简短了，而且执行效率也好上许多。
? 问号
在文件名扩展(Filename expansion)上扮演的角色是匹配一个任意的字元，但不包含 null 字元。
[root@VM_16_9_centos ~]# ls
a12e.txt aae_txt agte.txt akte.txt aste.txt
[root@VM_16_9_centos ~]# ls a?te.txt
agte.txt akte.txt aste.txt
[root@VM_16_9_centos ~]# ls a1?e.txt
a12e.txt
[root@VM_16_9_centos ~]# ls aae?txt
aae_txt
善用她的特点，可以做比较精确的档名匹配。
* 任意个任意字符。任意的单个或多个字符
相当常用的符号。在文件名扩展(Filename expansion)上，她用来代表任何字元，包含 null 字元。
[root@VM_16_9_centos ~]# ls
a12e.txt aae_txt agte.txt akte.txt a.sh aste.txt
[root@VM_16_9_centos ~]# ls a*e.txt
a12e.txt agte.txt akte.txt aste.txt
[root@VM_16_9_centos ~]# ls a*te.txt
agte.txt akte.txt aste.txt 在运算时，它则代表 "乘法"。
[root@VM_16_9_centos ~]# let "fmult=2*3"
[root@VM_16_9_centos ~]# echo ${fmult}
6 除了内建指令 let，还有一个关于运算的指令expr，星号在这里也担任"乘法"的角色。不过在使用上得小心，他的前面必须加上escape字元（即转义符）。
[root@VM_16_9_centos ~]# expr 2 \* 3
6
** 次方运算
[root@ss-server ~]# let sum=2**4
[root@ss-server ~]# echo ${sum}
16
[root@ss-server ~]# echo $((3*3))
9
[root@ss-server ~]# let sum=2**4
[root@ss-server ~]# echo ${sum}
16
[root@ss-server ~]# echo $((3**3))
27
[root@ss-server ~]# echo $[3**4]
81
$ 变量符号、正则里表示"行尾"
$是变量替换的代表符号。
[root@ss-server ~]# var="wang lao hu"
[root@ss-server ~]# echo $var
wang lao hu
[root@ss-server ~]# echo ${var}
wang lao hu 另外：
在Regular Expressions里被定义为 \"行\" 的最末端。这个常用在grep、sed、awk 以及 vim(vi) 当中。 ^ 表示行首
$ 表示行尾
${} 变量的正规表达式
bash 对 ${} 定义了不少用法，如下，具体说明可参考: https://www.cnblogs.com/kevingrace/p/5996133.html
${parameter:-word} ${parameter:=word} ${parameter:?word} ${parameter:+word} ${parameterffset} ${parameterffset:length} ${!prefix*} ${#parameter} ${parameter#word} ${parameter##word} ${parameter%word} ${parameter%%word} ${parameter/pattern/string} ${parameter//pattern/string}
$* 所有引用的变量
$* 引用script的执行引用变量，引用参数的算法与一般指令相同，指令本身为0，其后为1，然后依此类推。引用变量的代表方式如下：
$0, $1, $2, $3, $4, $5, $6, $7, $8, $9, ${10}, ${11}.....
个位数的，可直接使用数字，但两位数以上，则必须使用 {} 符号来括住。 具体使用含义后面有详细说明
$* 则是代表所有引用变量的符号。使用时，得视情况加上双引号。
[root@ss-server ~]# echo "$*"
""
[root@ss-server ~]# echo "$*" [root@ss-server ~]# cat test.sh
#!/bin/bash
USER=$1
AGE=$2
ADD=$3
HE=$4 echo "$1 is $2,come from $3,and $4"
echo "$*" [root@ss-server ~]# sh test.sh 张阳 20 安徽 帅气
张阳 is 20,come from 安徽,and 帅气
张阳 20 安徽 帅气
$@ 所有引用的变量
$@ 与 $* 具有相同作用的符号，不过它们两者有一个不同点。
符号 $* 将所有的引用变量视为一个整体。但符号 $@ 则仍旧保留每个引用变量的区段观念。 [ $@ 与 $* 二者的区别在下面会详细提到]
$# 参数变量的总数量
这也是与引用变量相关的符号，它的作用是告诉你，引用变量的总数量是多少。
[root@ss-server ~]# cat a.sh
#!/bin/bash
USER=$1
AGE=$2
ADD=$3
HE=$4 echo "$1 is $2,come from $3,and $4"
echo "$*"
echo "$@"
echo "$#"
[root@ss-server ~]# sh a.sh 黄涛 30 杭州
黄涛 is 30,come from 杭州,and
黄涛 30 杭州
黄涛 30 杭州
3
[root@ss-server ~]# echo "$#"
"0"
[root@ss-server ~]# echo "$#"
0
$? 状态值 (status variable)
一般来说，Linux 系统的进程以执行系统调用exit()来结束的。这个回传值就是status值。回传给父进程，用来检查子进程的执行状态。
一般指令程序倘若执行成功，其$?回传值为 0；若执行失败，则$?回传值为 1。
[root@ss-server ~]# ls a.sh
a.sh
[root@ss-server ~]# echo $?
0
[root@ss-server ~]# ls aa.sh
ls: cannot access aa.sh: No such file or directory
[root@ss-server ~]# echo $?
2
$$ 当前shell的PID
由于进程的ID是唯一的，所以在同一个时间，不可能有重复性的 PID。有时，script会需要产生临时文件，用来存放必要的资料。而此script亦有可能在同一时间被使用者们使用。在这种情况下，固定文件名在写法上就显的不可靠。唯有产生动态文件名，才能符合需要。符号$$或许可以符合这种需求。它代表当前shell 的 PID。
[root@ss-server ~]# echo "hello world"
hello world
[root@ss-server ~]# echo $$
78520
[root@ss-server ~]# echo "hello world" > aa.$$
[root@ss-server ~]# cat aa.78520
hello world [root@ss-server ~]# cat a.sh
#!/bin/bash
USER=$1
AGE=$2
ADD=$3
HE=$4 echo "$1 is $2,come from $3,and $4"
echo "$#"
echo "$*"
echo "$@"
echo "$$"
echo "$0"
[root@bz3aomsmsap1002 ~]sh a.sh 张阳 20 安徽 帅气
张阳 is 20,come from 安徽,and 帅气
4
张阳 20 安徽 帅气
张阳 20 安徽 帅气
90261
a.sh
使用它来作为文件名的一部份，可以避免在同一时间，产生相同文件名的覆盖现象。
基本上，系统会回收执行完毕的 PID，然后再次依需要分配使用。所以 script 即使临时文件是使用动态档名的写法，如果script 执行完毕后仍不加以清除，会产生其他问题。
( ) 指令群组 (command group)
用括号将一串连续指令括起来，这种用法对 shell 来说，称为指令群组。如下面的例子:
[root@ss-server ~]# (cd ~ ; pwstr=`pwd` ;echo ${pwstr})
/root
指令群组有一个特性，shell会以产生 subshell来执行这组指令。因此，在其中所定义的变数，仅作用于指令群组本身。来看个例子:
[root@ss-server ~]# cat a.sh
#!/bin/bash
a=wang
b=zhang
(a=han ; echo -e "\n $a \n")
(b=xiaoru; echo -e "this is $b")
echo $a
echo $b [root@ss-server ~]# sh a.sh han this is xiaoru
wang
zhang 由上面可知：shell的指令群组所定义的变数，仅作用于指令群组本身。 来看看echo的几个操作效果
=============================================================
[root@ss-server ~]# echo "aa"
aa
[root@ss-server ~]# echo \"aa\"
"aa"
[root@ss-server ~]# echo -e "\n wang \n" wang [root@ss-server ~]# echo -e \"\n wang \n\" # 这种情况下，\n就不是换行符了，因为双引号也被转义了。
"n wang n"
除了上述的指令群组，括号也用在 array数组变数的定义上；另外也应用在其他可能需要加上escape字元才能使用的场合，如运算式。
(( ))
这组符号的作用与 let 指令相似，用在算数运算上，是 bash 的内建功能。所以，在执行效率上会比使用 let指令要好许多。
[root@ss-server ~]# cat a.sh
#!/bin/bash (( a = 10 ))
echo -e "inital value, a = $a\n" (( a++))
echo "after a++, a = $a" [root@ss-server ~]# sh a.sh
inital value, a = 10 after a++, a = 11
请记住：
$(())、$[] 这两个效果是一样的，都是运算符号，显示运算结果。
let 也是运算符号，设置运算
[root@ss-server ~]# echo $((4*9))
36
[root@ss-server ~]# echo $[4*9]
36
[root@ss-server ~]# let a=4*9
[root@ss-server ~]# echo $a
36
[root@ss-server ~]# let "a=4*9"
[root@ss-server ~]# echo $a
36
[root@ss-server ~]# let a="3+5"
[root@ss-server ~]# echo $a
8 [root@ss-server ~]# a=10
[root@ss-server ~]# let a++ #表示变量a数值加1
[root@ss-server ~]# echo $a
11
{ } 大括号
这种大括号的组合，常用在字串的组合上，来看个例子
[root@ss-server ~]# mkdir aa{1,2,3}
[root@ss-server ~]# ls
aa1 aa2 aa3
[root@ss-server ~]# ll -d bb1*
drwxr-xr-x 2 root root 4096 Dec 5 11:37 bb1-k01
drwxr-xr-x 2 root root 4096 Dec 5 11:37 bb1-k02
drwxr-xr-x 2 root root 4096 Dec 5 11:37 bb1-k03
[root@ss-server ~]# ll -d cc1*
drwxr-xr-x 2 root root 4096 Dec 5 11:37 cc1-k01
drwxr-xr-x 2 root root 4096 Dec 5 11:37 cc1-k02
drwxr-xr-x 2 root root 4096 Dec 5 11:37 cc1-k03
[root@ss-server ~]# ll -d dd1*
drwxr-xr-x 2 root root 4096 Dec 5 11:37 dd1-k01
drwxr-xr-x 2 root root 4096 Dec 5 11:37 dd1-k02
drwxr-xr-x 2 root root 4096 Dec 5 11:37 dd1-k03
[root@ss-server ~]# touch {wan,han}_{1,2,3}
[root@ss-server ~]# ls wan*
wan_1 wan_2 wan_3
[root@ss-server ~]# ls han*
han_1 han_2 han_3
[root@ss-server ~]# chmod 755 /root/wan_{1,2,3}
[root@ss-server ~]# ll /root/wan_{1,2,3}
-rwxr-xr-x 1 root root 0 Dec 5 11:39 /root/wan_1
-rwxr-xr-x 1 root root 0 Dec 5 11:39 /root/wan_2
-rwxr-xr-x 1 root root 0 Dec 5 11:39 /root/wan_3
这组符号在适用性上相当广泛。能加以善用的话，回报是精简与效率。像下面的例子
?表示任意单个字符！！！
[root@ss-server ~]# chown app.app /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}
如果不是因为支援这种用法，我们得写几行重复几次呀！
[ ] 中括号
常出现在流程控制中，扮演括住判断式的作用。
[root@ss-server ~]# ls hahaha
ls: cannot access hahaha: No such file or directory
[root@ss-server ~]# echo $?
2 [root@ss-server ~]# cat a.sh
#!/bin/bash ls hahaha >/dev/null 2>&1
if [ "$?" != 0 ];then
echo "Executes error"
exit 1
fi [root@ss-server ~]# sh a.sh
Executes error
这个符号在正则表达式中担任类似 "范围" 或 "集合" 的角色
[root@ss-server ~]# touch aaa{1,2,3,4}
[root@ss-server ~]# ls aaa*
aaa1 aaa2 aaa3 aaa4
[root@ss-server ~]# rm -f aaa[1234]
[root@ss-server ~]# ls aaa*
ls: cannot access aaa*: No such file or directory
注意：
rm -f aaa[1234] 表示删除aaa1、aaa2、aaa3、aaa4
相当于
rm -f aaa{1,2,3,4}
注意：
只有在删除文件的时候，[]可以起到上面类似 "范围" 或 "集合" 的角色！
在其他操作都不会起到该作用！
如下，在touch的时候，[]并没有起到范围或集合的作用！
[root@ss-server ~]# touch aa[123]
[root@ss-server ~]# touch aa[123]_[xyz]
[root@ss-server ~]# ls aa*
aa[123] aa[123]_[xyz]
[[ ]]
这组符号与先前的 [] 符号，基本上作用相同，但它允许在其中直接使用 || 与&& 逻辑等符号。||表示"或"，&&表示"和" 。双中括号[[]]和单中括号[]的区别，在下面会详细提到。
[root@ss-server ~]# cat a.sh
#!/bin/bash
read -p "请输入一个数字: " num
if [[ ${num} > 10 && ${num}< 30 ]];then
echo "你输入的数字是${num}"
else
echo "输入的数字不符合要求"
fi [root@ss-server ~]# sh a.sh
请输入一个数字: 16
你输入的数字是16
[root@ss-server ~]# sh a.sh
请输入一个数字: 56
输入的数字不符合要求 上面脚本还可以改写为下面内容，效果是一样的！
[root@ss-server ~]# cat a.sh
#!/bin/bash #echo -n表示不换行
echo -n "输入一个数字: "
read num
if [[ ${num} > 10 && ${num}< 30 ]];then
echo "你输入的数字是${num}"
else
echo "输入的数字不符合要求"
fi [root@ss-server ~]# sh a.sh
输入一个数字: 19
你输入的数字是19
[root@ss-server ~]# sh a.sh
输入一个数字: 48
输入的数字不符合要求 ===============================================
需要注意：
if判断语句中如果使用[[]]，可以在[[]]中直接使用&&、||符号，表示"和"、"或"。可以用于字符串对比符号，也可以用于整数对比符号。
if判断语句中如果使用[]，在[]中可以使用-a、-o，表示"和"、"或"，但是这个用于整数比较时只能使用"-eq、-ne、-ge、-gt、-lt、-le",不能使用>、>=、<、<=、=、!=。 [root@ss-server ~]# cat a.sh
#!/bin/bash
read -p "请输入一个数字: " num
if [ ${num} -gt 10 -a ${num} -le 30 ];then
echo "你输入的数字是${num}"
else
echo "输入的数字不符合要求"
fi [root@ss-server ~]# sh a.sh
请输入一个数字: 12
你输入的数字是12
[root@ss-server ~]# sh a.sh
请输入一个数字: 45
输入的数字不符合要求 上面脚本中的[ ${num} -gt 10 -a ${num} -le 30 ]
不能改为：
[ ${num} -ge 10 ] -a [${num} -le 30 ]
也不能改为
[ ${num} > 10 -a ${num} < 30 ] [[]]的&&、||也可以用于整数对比。
[root@ss-server ~]# cat a.sh
#!/bin/bash
read -p "请输入一个数字: " num
if [[ ${num} -ge 10 && ${num} -le 30 ]];then
echo "你输入的数字是${num}"
else
echo "输入的数字不符合要求"
fi
[root@ss-server ~]# sh a.sh
请输入一个数字: 17
你输入的数字是17
[root@ss-server ~]# sh a.sh
请输入一个数字: 67
输入的数字不符合要求
|| 逻辑符号
这个会时常看到，代表 or 逻辑的符号，表示前一个命令执行成功，则就此结束，后一个命令就不执行；前一个命令执行失败，后一个命令才会执行。如 A || B 表示A执行成功后，B就不会再执行了；A执行失败或不执行，B才能执行。
&& 逻辑符号
这个也会常看到，代表 and 逻辑的符号，表示串行，即前一个命令执行成功，后一个命令才接着执行；前一个命令执行失败，则就此结束，后一个命令也不会执行。如 A && B 表示A执行成功后，B也会跟着执行了；A执行失败或不执行，B也不会执行了。
& 后台工作
单一个& 符号，且放在完整指令列的最后端，即表示将该指令列放入后台中工作。 放在几个指令中间时，表示并行，实质就是在后台并行执行，跟指令前后顺序无关。
[root@ss-server ~]# tar -zvcf test1.tar.gz test1 > /dev/null &
\<...\> 单字边界
这组符号在规则表达式中，被定义为\"边界\"的意思。如下想要在test文件中找寻 the 这个单字时，如果我们用
[root@ss-server ~]# cat test
the
there
this is a
123456
thee
[root@ss-server ~]# grep "the" test
the
there
thee
如上会发现，像 there、thee这类的单字，也会被当成是匹配的单字。因为 the 正巧是there、thee的一部份。如果要想必免这种情况，就得加上单字边界符号，进行精准匹配:
[root@ss-server ~]# cat test
the
there
this is a
123456
thee
[root@ss-server ~]# grep "the" test
the
there
thee
[root@ss-server ~]# grep "\<the\>" test
the 另外：上面在进行grep精准匹配时，除了使用\<str\>单字边界符号，还可以使用grep -w进行精准匹配！
[root@ss-server ~]# cat test
the
there
this is a
123456
thee
[root@ss-server ~]# grep -w "the" test
the 可以参考：https://www.cnblogs.com/kevingrace/p/9299232.html
+ 加号
在运算式中，她用来表示 "加法"。
[root@ss-server ~]# expr 10 + 11 + 12
33 注意：expr命令中的计算符号和数字中间一定要有空格！！否则无效！并且后面的运算两边不能有引号，否则也无效！ 下面都是错误的！！
[root@ss-server ~]# expr 10+11+12
10+11+12
[root@ss-server ~]# expr "10 + 11 + 12"
10 + 11 + 12 另外：注意expr使用*乘法的时候，需要在*前面加上转义符号\，否则无效！
[root@ss-server ~]# expr 2 * 3
expr: syntax error
[root@ss-server ~]# expr 2 \* 3
6
此外在正则表达式中，用来表示"很多个"的前面字元的意思。但是注意，正则里使用+符号表示"很多个"意思时，+号前面必须加上\\符号！！
[root@ss-server ~]# cat test
123456
10aaaahuihhhhh
s34eddddd
kkkhuan
[root@ss-server ~]# grep "10\\+a" test
10aaaahuihhhhh
[root@ss-server ~]# grep "e\\+d" test
s34eddddd
[root@ss-server ~]# grep "\\k" test
kkkhuan
- 减号
在运算式中，她用来表示 "减法"。
[root@ss-server ~]# expr 10 - 2
8
在 cd 指令中则比较特别，"cd -"表示变更工作目录到\"上一次\"工作目录。
[root@ss-server ~]# cd /usr/local/src/
[root@bz3aomsmsap1002 src]# cd
[root@ss-server ~]# cd -
/usr/local/src
[root@bz3aomsmsap1002 src]#
% 除法后的余数
在运算式中，用来表示 "除法"后的余数。 [运算式中的乘法*,用的时候需要在前面加一个转移符 expr 5 \* 10]
[root@ss-server ~]# expr 10 % 2
0
[root@ss-server ~]# expr 10 % 3
1
[root@ss-server ~]# expr 10 % 6
4
[root@ss-server ~]# expr 6 % 9
6
[root@ss-server ~]# expr 6 % 90
6
[root@ss-server ~]# expr 5 % 6
5 %表示余数，即整除后的余数是多少。
如果小除大，则%余数统一为前面那个小的数。
此外，也被运用在关于变量的规则表达式当中的下列
${parameter%word}
${parameter%%word}
一个 % 表示最短的 word 匹配，两个表示最长的 word 匹配。
可以参考上面"参数替换"部分有详细介绍
= 等号
常在设定变数时看到的符号。
[root@ss-server ~]# vara="hello world"
[root@ss-server ~]# echo "vara=${vara}"
vara=hello world
或者像是 PATH 的设定，甚至应用在运算或判断式等此类用途上。
== 等号
常在条件判断式中看到，代表 "等于" 的意思。
if [ $vara == $varb ]
...下略
!= 不等于
常在条件判断式中看到，代表 "不等于" 的意思。
if [ $vara != $varb ]
...下略
^
这个符号在正则表达式中，代表行的 "开头" 位置！
输出/输入重导向
> 、>>、< 、<< 、<>、>&、>&2
文件描述符(File Descriptor)，用一个数字（通常为0-9）来表示一个文件。
常用的文件描述符如下：
文件描述符 名称 常用缩写 默认值
0 标准输入 stdin 键盘
1 标准输出 stdout 屏幕
2 标准错误输出 stderr 屏幕
在简单地用<或>时，相当于使用 0< 或 1>。如下面说明：
# cmd > file
把cmd命令的输出重定向到文件file中。如果file已经存在，则清空原有文件，使用bash的noclobber选项可以防止复盖原有文件。[即>表示覆盖内容]
# cmd >> file
把cmd命令的输出重定向到文件file中，如果file已经存在，则把信息加在原有文件後面。 [即>>表示追加内容]
# cmd < file
使cmd命令从file读入
# cmd << text
从命令行读取输入，直到一个与text相同的行结束。除非使用引号把输入括起来，此模式将对输入内容进行shell变量替换。如果使用<<- ，则会忽略接下来输入行首的tab，结束行也可以是一堆tab再加上一个与text相同的内容，可以参考後面的例子。
# cmd <<< word
把word（而不是文件word）和後面的换行作为输入提供给cmd。
# cmd <> file
以读写模式把文件file重定向到输入，文件file不会被破坏。仅当应用程序利用了这一特性时，它才是有意义的。
# cmd >| file
功能同>，但即便在设置了noclobber时也会复盖file文件，注意用的是|而非一些书中说的!，目前仅在csh中仍沿用>!实现这一功能。
: > filename 把文件\"filename\"截断为0长度.# 如果文件不存在, 那么就创建一个0长度的文件(与'touch'的效果相同).
# cmd >&n 把输出送到文件描述符n
# cmd m>&n 把输出 到文件符m的信息重定向到文件描述符n
# cmd >&- 关闭标准输出
# cmd <&n 输入来自文件描述符n
# cmd m<&n m来自文件描述各个n
# cmd <&- 关闭标准输入
# cmd <&n- 移动输入文件描述符n而非复制它。（需要解释）
# cmd >&n- 移动输出文件描述符 n而非复制它。（需要解释）
注意： >&实际上复制了文件描述符，这使得cmd > file 2>&1与cmd 2>&1 >file的效果不一样。
关于EOF用法：https://www.cnblogs.com/kevingrace/p/6257490.html
通常在执行一个命令时，如果不想打印命令执行的结果(包括正确或错误的结果信息)，则通常使用"command >/dev/null 2>&1"
Shell中几种特殊的参数变量的引用
$1、$2、$3……${10}、${11}、${12}…… ：表示脚本传入的的各个参数，注意当需表示两位数以后的参数时数字要用花括号括起。
$@ 列出所有的参数，各参数用空格隔开
$* 列出所有的参数，各参数用环境变量的第一个字符隔开
$* 和 $@ 的区别
1）$* 将所有的引用变量视为一个整体。但$@则仍旧保留每个引用变量的区段观念。
2）当不加引号时,$*和$@二者都是返回传入的参数，但是当加了引号后,$*把参数作为一个字符串整体(单字符串)返回，$@把每个参数作为一个字符串返回！
1) 示例1
[root@ss-server ~]# cat a.sh
#!/bin/bash for i in $*
do
echo $i
done echo "++++++ \$*和\$@对比(不加双引号) ++++++" for j in $@
do
echo $j
done [root@ss-server ~]# sh a.sh aa bb cc
aa
bb
cc
++++++ $*和$@对比(不加双引号) ++++++
aa
bb
cc 2) 示例2
[root@ss-server ~]# cat a.sh
#!/bin/bash for i in "$*"
do
echo $i
done echo "++++++ \$*和\$@对比(加双引号) ++++++" for j in "$@"
do
echo $j
done
[root@ss-server ~]# sh a.sh aa bb cc
aa bb cc
++++++ $*和$@对比(加双引号) ++++++
aa
bb
cc 3）示例3，在一个shell函数里分别定义 加双引号和不加双引号 传参时，$@和$*的区别
[root@ss-server ~]# cat a.sh
#! /bin/bash function test() {
echo "未加引号,二者相同"
echo $*
echo $@
echo "加入引号后对比" echo "----"\$*----""
for N in "$*"
do
echo $N
done echo "----"\$@----""
for N in "$@"
do
echo $N
done
}
test 11 22 33
[root@ss-server ~]# sh a.sh
未加引号,二者相同
11 22 33
11 22 33
加入引号后对比
----$*----
11 22 33
----$@----
11
22
33 ====================================================================================
通过上面对比，可以发现：
不加引号时,$*和$@二者都是返回传入的参数；
加了引号后,$*把参数作为一个字符串整体(单字符串)返回,$@把每个参数作为一个字符串返回！
命令列表
and列表 statement1 && statement2 && ..... 表示只有在前面所有的命令都执行成功的情况下才执行后一条命令；即前面成功，后面继续执行；前面失败，后面也不执行！
or列表 statement1 || statement2 || ….. 表示允许执行一系列命令直到有一条命令成功为止，其后所有命令将不再被执行；即前面成功，后面不执行；前面失败，后面执行！！
[root@ss-server ~]# cat a.sh
#!/bin/bash touch file_one >/dev/null 2>&1
rm -f file_two >/dev/null 2>&1 if [ -f file_one ] && echo "hello" && [ -f file_two ] && echo " there";then
echo "in if"
else
echo "in else"
fi
exit 0
[root@ss-server ~]# sh a.sh
hello
in else
if逻辑判断语句中常用到的参数 以及 注意细节 （如[[]]和[]的区别）
[ -a file ] 如果 file 存在则为真。
[ -e file ] 如果 file 存在则为真。 [ -f file ] 如果 file 存在且是一个普通文件则为真。
[ -d file ] 如果 file 存在且是一个目录则为真。 [ -b file ] 如果 file 存在且是一个块特殊文件则为真。(即设备文件，如/dev/sda1、/dev/sda2) [ -h file ] 如果 file 存在且是一个符号文件则为真。（符号文件即是软链接文件）
[ -L file ] 如果 file 存在且是一个符号文件则为真。（符号文件即是软链接文件） [ -g file ] 如果 file 存在且已经设置了SGID则为真。
[ -u file ] 如果 file 存在且设置了SUID则为真。
[ -k file ] 如果 file 存在且已经设置了粘制位则为真。（即设置了t权限的目录，粘制位仅对目录有效） [ -r file ] 如果 file 存在且是可读的则为真。
[ -w file ] 如果 file 存在且是可写的则为真。
[ -x file ] 如果 file 存在且是可执行的则为真。 [ -s file ] 如果 file 存在且大小不为0则为真。 [ -O file ] 如果 file 存在且属有效用户ID则为真。
[ -G file ] 如果 file 存在且属有效用户组则为真。 [ file1 -nt file2 ] 如果 file1 比 file2 要老(即先创建), 或者 file1 存在且 file2不存在则为真。
[ file1 -ot file2 ] 如果 file1 比 file2 要老(即先创建), 或者 file2 存在且 file1 不存在则为真。 [ -z str ] 如果str字符串的长度为零则为真。 （即空串为真）
[ -n str ] or [ str ] 如果str字符串的长度为非零则为真。 （即非空串为真） [ str1 == str2 ] 如果2个字符串相同则为真。
[ str1 != str2 ] 如果字符串不相等则为真。 二、简单总结
===========================================================================
1）字符串判断
str1 = str2 当两个串有相同内容、长度时为真
str1 != str2 当串str1和str2不等时为真
-n str1 当串的长度大于0时为真(串非空)
-z str1 当串的长度为0时为真(空串)
str1 当串str1为非空时为真。等于"-n star1" 2）数字的判断
int1 -eq int2 两数相等为真
int1 -ne int2 两数不等为真
int1 -gt int2 int1大于int2为真
int1 -ge int2 int1大于等于int2为真
int1 -lt int2 int1小于int2为真
int1 -le int2 int1小于等于int2为真 3）文件的判断
-a file 文件存在为真
-z file 文件存在为真
-r file 用户可读为真
-w file 用户可写为真
-x file 用户可执行为真
-f file 文件为普通文件为真
-d file 文件为目录为真
-s file 文件大小非0时为真
-h file 文件为符号文件为真
-L file 文件为符号文件为真
-g file 文件为SGID权限文件为真
-u file 文件为SUID权限文件为真
-k file 文件为T权限文件为真 4）复杂逻辑判断
-a 与
-o 或
! 非 三、注意细节
===========================================================================
1）在if的中括号中，判断变量的值，加不加双引号的问题？
-z 判断变量的值，是否为空:
变量的值，为空，返回0，为true
变量的值，非空，返回1，为false
-n 判断变量的值，是否为空:
变量的值，为空，返回1，为false
变量的值，非空，返回0，为true
str="abc"
[ -z "$str" ] 单中括号，变量必须要加双引号！
[[ -z $str ]] 双中括号，变量不用加双引号 [ -n "$str" ] 单中括号，变量必须要加双引号！
[[ -n $str ]] 双中括号，变量不用加双引号 2）多个条件判断，[] 和 [[]] 的区别？？？？？？？？？？？？？？？？？？？？
&& 并且，相当于and
|| 或，相当于or -a 并且，相当于and
-o 或者，相当于or --------------------------------------------
2.1）双中括号[[]]的条件判断
[[ ]] 双中括号的条件判断用"&&" 和 "||" || 满足一个条件满足就成立;或者的关系
[[ $a -lt 3 || $a -gt 6 ]]
[[ $a -lt 3 ]] || [[ $a -gt 6 ]] # 写在外面也可以 && 必须同时满足两个条件同时;并且的关系。
[[ $a -gt 3 && $a -lt 10 ]]
[[ $a -gt 3 ]] && [[$a -lt 10 ]] # 写在外面也可以 这里需要注意的问题的是：
[[]]双中括号的判断语句中，只能使用&&和||，可以在[[]]内部使用，也可以在[[]]外面使用！
[[]]双中括号的判断语句中不能使用-a和-o参数！！！！！！ 如果使用下面写法就是错误的！！！！！！
[[ $a -lt 3 -o $a -gt 6 ]]
[[ $a -lt 3 ]] -o [[ $a -gt 6 ]]
[[ $a -gt 3 -a $a -lt 10 ]]
[[ $a -gt 3 ]] -a [[$a -lt 10 ]] --------------------------------------------
2.2）单中括号[]的条件判断
[ ] 单中括号的条件判断可以使用-a和-o的参数，但是必须在单[ ]中括号内判断条件！！不能在单中括号外面！！
[ $a -lt 10 -o $a -gt 20 ] 这个"或者"条件成立
[ $a -lt 10 ] -o [ $a -gt 20 ] 这个"或者"不成立，因为必须在中括号内判断!!!! 如果想在[]中括号外判断两个条件，必须用&& 和 || 比较！
[ $a -lt 10 ] || [ $a -gt 20 ] 这个"或者"条件成立
[ $a -lt 10 ] && [ $a -gt 20 ] 这个"并且"条件成立 同样需要注意：|| 和 && 不能在单中括号[]内使用，只能在单中括号[]外面使用！！！ 3) 当判断某个变量的值是否满足正则表达式的时候，必须使用[[ ]] 双中括号！！！！
示例：
[root@ss-server ~]# str=13611082178
[root@ss-server ~]# [[ ${str} =~ [0-9]{11} ]]
[root@ss-server ~]# echo $?
0 如果使用单中括号，会直接报错：
[root@ss-server ~]# str=13611082178
[root@ss-server ~]# [ ${str} =~ [0-9]{11} ]
-bash: [: =~: binary operator expected
shell脚本获取第10个参数 在Shell脚本中，可以用$n的方式获取第n个参数
[root@ansible-server ~]# cat a.sh
#!/bin/bash
echo $1 $2 $3 $4 $5 $6 $7 $8 $9 ${10} [root@ansible-server ~]# sh a.sh a b c d 1 2 3 4 8 ab
a b c d 1 2 3 4 8 ab 取第10个参数, 要用${10}, 不能使用$10(这个表示第1个参数加上0)。因为个位数的参数，可以直接使用数字。但两位以上数字的参数，必须使用{}符号!!!!
#!/bin/bash
echo $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 [root@ansible-server ~]# sh a.sh a b c d 1 2 3 4 8 ab
a b c d 1 2 3 4 8 a0 即上面脚本中$10 取的值为$1+0 再看几个例子
[root@ansible-server ~]# cat a.sh
#!/bin/bash
#echo $1 $2 $3 $4 $5 $6 $7 $8 $9 $10
echo $3 $12 [root@ansible-server ~]# sh a.sh a b c d 1 2 3 4 8 ab
c a2 [root@ansible-server ~]# cat a.sh
#!/bin/bash
#echo $1 $2 $3 $4 $5 $6 $7 $8 $9 $10
echo $3 ${12} [root@ansible-server ~]# sh a.sh a b c d 1 2 3 4 8 ab bo kevin
c kevin
$# 是传递给脚本的参数个数；
$0 是脚本本身的名字；
$1 是传递给该shell脚本的第一个参数；
$2 是传递给该shell脚本的第二个参数；
$@ 是传递给脚本的所有参数的列表(是多个字符串，每个参数为1个字符串)；
$* 是传递给脚本的所有参数的列表(以一个单字符串显示所有参数)，与位置变量不同，参数可超过9个；
$$ 是运行脚本的当前进程ID号；
$? 是显示执行上一条Shell命令的返回值，0表示没有错误，其他表示有错误。
如下，用一个简单的脚本来说明上面这些变量的含义
[root@kevin ~]# vim /root/path.sh
#!/bin/sh
echo "the number of parameters passed to the script: $#"
echo "the name of the script itself: $0"
echo "the first parameter passed to the shell script: $1"
echo "the second parameter passed to the shell script: $2"
echo "the list of all the parameters passed to the script(some string): $@"
echo "the list of all the parameters passed to the script(one string): $*"
echo "the current process ID number of the script which is running: $$"
echo "the return value of the last shell command performed: $?" [root@kevin ~]# chmod 755 /root/path.sh
[root@kevin ~]# ll /root/path.sh
-rwxr-xr-x. 1 root root 512 Jun 25 11:21 /root/path.sh [root@kevin ~]# sh /root/path.sh 10 20 30
the number of parameters passed to the script: 3
the name of the script itself: /root/path.sh
the first parameter passed to the shell script: 10
the second parameter passed to the shell script: 20
the list of all the parameters passed to the script(some string): 10 20 30
the list of all the parameters passed to the script(one string): 10 20 30
the current process ID number of the script which is running: 372
the return value of the last shell command performed: 0
Shell脚本常用命令 -exit 和 if
1、exit
exit 0 退出shell，成功
exit 1 退出shell，失败
exit 2 退出shell，用法不当 需要注意：
如果shell脚本中调用的子脚本的exit，那么会退出子脚本
如果是source一个子脚本，里面的exit会导致外面的脚本也退出 ==============================================================
2、if
1) if [-z "$name"]
判断name是否为空字符串，如果空，则为真，执行if的内容
等同于 if ["$name" = ""]
等同于[! "$name"] 2) if的几个参数
-z 字符串是否为空，空为真
-n 指定字符串是否不空，不空为真
-a 某东西不存在，则为真。不限定为字符串
-f 普通文件是否存在
-d 目录是否存在
-e 某东西是否存在，不限定为文件
Shell脚本中判断参数是否为空，如果为空就停止后续操作
注意下面的方法
if [ str1 = str2 ] 当两个串有相同内容、长度时为真
if [ str1 != str2 ] 当串str1和str2不等时为真
if [ -n str1 ] 当串的长度大于0时为真(串非空) 。 注意: 这个等同于if [ ! -n str1 ] ，前提是里面的str1不加上""，如果加上""就等同于if [ -z str1 ]了！
if [ -z str1 ] 当串的长度为0时为真(空串) 。 注意：这个等同于 if [ ! -n "str1" ]，前提是str1必须要加上""双引号！！ ==================================================================
[root@bz3aomsmsap1002 mnt]# cat test.sh
#!/bin/bash
AN=""
BN="sadf"
if [ -z ${AN} ];then
echo "没有变量AN,无法执行后续操作,请确认输入了AN参数"
exit 1
fi echo "结果为:${AN} is a good ${BN}" [root@bz3aomsmsap1002 mnt]# sh test.sh
没有变量AN,无法执行后续操作,请确认输入了AN参数 -----------------------------------------
[root@bz3aomsmsap1002 mnt]# cat test.sh
#!/bin/bash
AN="ha"
BN="sadf"
if [ -z ${AN} ];then
echo "没有变量AN,无法执行后续操作,请确认输入了AN参数"
exit 1
fi echo "结果为:${AN} is a good ${BN}" [root@bz3aomsmsap1002 mnt]# sh test.sh
结果为:ha is a good sadf ==================================================================
如果要想使用-n代替-z，则做法如下：
必须注意：
下面的if判断语句中的-n后面的变量必须要加上双引号""！否则就失效！
因为如果不加""的话，就等同于了效于if [ -n ]
[root@bz3aomsmsap1002 mnt]# cat test.sh
#!/bin/bash
AN=""
BN="sadf"
if [ ! -n "${AN}" ];then
echo "没有变量AN,无法执行后续操作,请确认输入了AN参数"
exit 1
fi echo "结果为:${AN} is a good ${BN}" [root@bz3aomsmsap1002 mnt]# sh test.sh
没有变量AN,无法执行后续操作,请确认输入了AN参数 -----------------------------------------
[root@bz3aomsmsap1002 mnt]# cat test.sh
#!/bin/bash
AN="ru"
BN="sadf"
if [ ! -n "${AN}" ];then
echo "没有变量AN,无法执行后续操作,请确认输入了AN参数"
exit 1
fi echo "结果为:${AN} is a good ${BN}" [root@bz3aomsmsap1002 mnt]# sh test.sh
结果为:ru is a good sadf -----------------------------------------
如果不加双引号，则if [ ! -n ] 就等同于了 -f [ -n ] [root@bz3aomsmsap1002 mnt]# cat test.sh
#!/bin/bash
AN=""
BN="sadf"
if [ ! -n ${AN} ];then
echo "没有变量AN,无法执行后续操作,请确认输入了AN参数"
exit 1
fi echo "结果为:${AN} is a good ${BN}" [root@bz3aomsmsap1002 mnt]# sh test.sh
结果为: is a good sadf -----------------------------------------
[root@bz3aomsmsap1002 mnt]# cat test.sh
#!/bin/bash
AN="ru"
BN="sadf"
if [ ! -n ${AN} ];then
echo "没有变量AN,无法执行后续操作,请确认输入了AN参数"
exit 1
fi echo "结果为:${AN} is a good ${BN}" [root@bz3aomsmsap1002 mnt]# sh test.sh
结果为:ru is a good sadf
$(( ))、$( )、${ }的区别
===================================================================
一、$( ) 与 ` ` (反引号)
在bash shell中，$( ) 与 ` `(反引号) 都是用来做命令替换用(command substitution)的。
[root@bobo tmp]# echo `hostname`
kevin-testserver
[root@bobo tmp]# echo $(hostname)
kevin-testserver 比如查看上一星期天的日期
[root@bobo tmp]# echo the last sunday is $(date -d "last sunday" +%Y-%m-%d)[/code]
the last sunday is 2019-10-27[/code] ===================================================================
二、${ } 用来作变量替换。
一般情况下，$var 与 ${var} 并没有什么不一样。但是用${ }会比较精确的界定变量名称的范围。
例如下面的例子，原本是打算先将$A的结果替换出来，然后再补一个B字母于其后。
如果使用$AB打印结果就为空，但是使用${A}B打印就不一样了。
[root@bobo tmp]# A=B
[root@bobo tmp]# echo $AB [root@bobo tmp]# echo ${A}B
BB
[root@bobo tmp]# 在bash中。${ }功能是十分强大的，不仅仅是用来界定变量名称，
--------------------------------------
1）${}可以灵活地用来截图变量中的字符串
具体可以参考：https://www.cnblogs.com/kevingrace/p/8868262.html 例如：var="http://www.kevin.com/shibo/anhuigrace"
我们可以用 ${ } 分别替换获得不同的值：
${var#*/}：拿掉第一条/及其左边的字符串：/www.kevin.com/shibo/anhuigrace
${var##*/}：拿掉最后一条/及其左边的字符串：anhuigrace
${var#*.}：拿掉第一个.及其左边的字符串：kevin.com/shibo/anhuigrace
${var##*.}：拿掉最后一个.及其左边的字符串：com/shibo/anhuigrace
${var%/*}：拿掉最后一条/及其右边的字符串：http://www.kevin.com/shibo
${var%%/*}：拿掉第一条/及其右边的字符串：http:
${var%.*}：拿掉最后一个.及其右边的字符串：http://www.kevin
${var%%.*}：拿掉第一个.及其右边的字符串：http://www 记忆的方法为：
# 是去掉左边(在键盘上 # 在 $ 之左边)
% 是去掉右边(在键盘上 % 在 $ 之右边)
单一符号是最小匹配﹔
两个符号是最大匹配。 --------------------------------------
2）${}可以对变量值里的字符串作替换
${file/dir/path}：将第一个 dir提换为path：
${file//dir/path}：将全部dir提换为path： 示例：
[root@bobo tmp]# cat test.sh
#!/bin/bash var="/data/web/kevin/www/web/ui/web/list" echo "${var}"
echo "${var/web/shi}"
echo "${var//web/shi}"
[root@bobo tmp]# sh test.sh
/data/web/kevin/www/web/ui/web/list
/data/shi/kevin/www/web/ui/web/list
/data/shi/kevin/www/shi/ui/shi/list --------------------------------------
3) 利用 ${ } 还可针对不同的变量状态赋值(没设定、空值、非空值)
${var-kevin.txt}：假如$var没有设定，则使用kevin.txt作传回值。(空值及非空值时不作处理)
${var:-kevin.txt}：假如$var没有设定或为空值，则使用kevin.txt作传回值。(非空值时不作处理)
${var+kevin.txt}：假如$var设为空值或非空值，均使用kevin.txt作传回值。(没设定时不作处理)
${var:+kevin.txt}：若$var为非空值，则使用kevin.txt作传回值。(没设定及空值时不作处理)
${var=kevin.txt}：若$var没设定，则使用kevin.txt作传回值，同时将$var赋值为kevin.txt。(空值及非空值时不作处理)
${var:=kevin.txt}：若$var没设定或为空值，则使用kevin.txt作传回值，同时将$var赋值为kevin.txt。(非空值时不作处理)
${var?kevin.txt}：若$var没设定，则将kevin.txt输出至STDERR。(空值及非空值时不作处理)
${var:?kevin.txt}：若$var没设定或为空值，则将kevin.txt输出至STDERR。(非空值时不作处理) 示例：
[root@bobo tmp]# cat test.sh
#!/bin/bash #var="/data/web/kevin/www/web/ui/web/list" echo "${var}"
echo "${var-my.txt}"
echo "${var:-my.txt}"
echo "${var+my.txt}"
echo "${var:+my.txt}"
echo "${var=my.txt}"
echo "${var:=my.txt}"
echo "${var?my.txt}"
echo "${var:?my.txt}" [root@bobo tmp]# sh test.sh my.txt
my.txt my.txt
my.txt
my.txt
my.txt 修改下脚本
[root@bobo tmp]# cat test.sh
#!/bin/bash var="/data/web/kevin/www/web/ui/web/list" echo "${var}"
echo "${var-my.txt}"
echo "${var:-my.txt}"
echo "${var+my.txt}"
echo "${var:+my.txt}"
echo "${var=my.txt}"
echo "${var:=my.txt}"
echo "${var?my.txt}"
echo "${var:?my.txt}" [root@bobo tmp]# sh test.sh
/data/web/kevin/www/web/ui/web/list
/data/web/kevin/www/web/ui/web/list
/data/web/kevin/www/web/ui/web/list
my.txt
my.txt
/data/web/kevin/www/web/ui/web/list
/data/web/kevin/www/web/ui/web/list
/data/web/kevin/www/web/ui/web/list
/data/web/kevin/www/web/ui/web/list 需要注意的是：
以上理解一定要分清楚unset 与 null 及 non-null 这三种赋值状态。一般而言：
: 与 null 有关；
若不带 : 的话, 则 null 不受影响,；
若带 : 的话，则连 null 也受影响. --------------------------------------
4）${#var} 可计算出变量值的长度
[root@bobo tmp]# cat test.sh
#!/bin/bash var="/data/web/kevin/www/web/ui/web/list" echo "${#var}" [root@bobo tmp]# sh test.sh
35 这里就引申出shell中的数组的概念了，数组的使用可以参考：https://www.cnblogs.com/kevingrace/p/5761975.html 这里简单说明下：
一般而言，var="haha hehe heihei houhou" 这样的变量只是将${var}替换为一个单一的字符串，
[root@bobo tmp]# var="haha hehe heihei houhou"
You have mail in /var/spool/mail/root
[root@bobo tmp]# echo ${var}
haha hehe heihei houhou 如果改为 var=(haha hehe heihei houhou) ，则是将${var}定义为组数。
[root@bobo tmp]# var=(haha hehe heihei houhou) bash 的组数替换方法可参考如下方法：
${var[@]} 或 ${var[*]} 可得到 haha hehe heihei houhou (全部组数)
${var[0]} 可得到 haha (第一个组数)，${var[1]} 则为第二个组数…
${#var[@]} 或 ${#var[*]} 可得到 4 (全部组数数量)
${#var[0]} 可得到4(即第一个组数(haha)的长度)，${#var[3]} 可得到6(第四个组数(houhou)的长度)
var[3]=xyz 则是将第四个组数重新定义为xyz … [root@bobo tmp]# echo ${var[@]}
haha hehe heihei houhou
[root@bobo tmp]# echo ${var[*]}
haha hehe heihei houhou
[root@bobo tmp]# echo ${var[0]}
haha
[root@bobo tmp]# echo ${var[1]}
hehe
[root@bobo tmp]# echo ${#var[@]}
4
[root@bobo tmp]# echo ${#var[*]}
4
[root@bobo tmp]# echo ${#var[0]}
4
[root@bobo tmp]# echo ${#var[3]}
6
[root@bobo tmp]# var[3]=xyz
[root@bobo tmp]# echo ${var[@]}
haha hehe heihei xyz ===================================================================
三、 $(( )) 的用途：
1）$(( ))是用来作整数运算的。
+ - * / ：分别为 "加、减、乘、除"。
% ：余数运算
& | ^ !：分别为 "AND、OR、XOR、NOT" 运算。 [root@bobo tmp]# a=5; b=7; c=2
[root@bobo tmp]# echo $(( a+b*c ))
19
[root@bobo tmp]# echo $(( (a+b)/c ))
6
[root@bobo tmp]# echo $(( (a*b)%c))
1 在 $(( )) 中的变量名称，可于其前面加 $ 符号来替换，也可以不用，如：
[root@bobo tmp]# echo $(( $a + $b * $c))
19
[root@bobo tmp]# echo $(( ($a * $b) % $c))
1
Shell 脚本中诸如查看目录大小并排序等技巧
=====================================================================
查看目录下的文件大小并排序 1. 查看/data目录下空间大小排在前10位的文件
# du -sh /data/* | sort -nr | head -10 查看目录下所有文件的大小并按照大小排序
# du -sh * | sort -rh 2. 查看/data目录下空间大小排在前10位的目录(单位为G)，并且只是在/data当前目录下查看，不轮询（用到参数"-maxdepth 1"）
# find /data/* -maxdepth 1 -type d -exec /usr/bin/du -sh {} \;|grep '[0-9]G'|sort -rh|head -5 [bxapp@bz6aomdepap1001 ~]$ find /data/ftp/ONLINE/* -maxdepth 1 -type d -exec /usr/bin/du -sh {} \;|grep '[0-9]G'|sort -rh|head -5
64G /data/ftp/ONLINE/CCS
13G /data/ftp/ONLINE/MPB
11G /data/ftp/ONLINE/ICS
9.5G /data/ftp/ONLINE/mysql
9.0G /data/ftp/ONLINE/EOB =====================================================================
Shell中求字符串中单词的个数的几种方法 方法一:
[root@VM_16_9_centos tmp]# echo 'wang shi kevin ruo bao' | wc -w
5 方法二:
[root@VM_16_9_centos tmp]# echo 'wang shi kevin ruo bao' | awk '{print NF}'
5 方法三:
[root@VM_16_9_centos tmp]# s='wang shi kevin ruo bao'
[root@VM_16_9_centos tmp]# set ${s}
[root@VM_16_9_centos tmp]# echo $#
5 方法四:
[root@VM_16_9_centos tmp]# s='wang shi kevin ruo bao'
[root@VM_16_9_centos tmp]# a=($s)
[root@VM_16_9_centos tmp]# echo ${#a[@]}
5 方法五:
[root@VM_16_9_centos tmp]# s='wang shi kevin ruo bao'
[root@VM_16_9_centos tmp]# echo $s | tr ' ' '\n' | wc -l
5 =====================================================================
linux 中wc 用法小结
wc命令用于统计给定文件中的字节数、字数、行数。
如果没有给出文件名，则从标准输入读取。
wc同时也给出所有指定文件的总统计数。字是由空格字符区分开的最大字符串。 wc命令各选项含义如下：
- c 统计字节数
- l 统计行数
- w 统计字数 1. 统计行数：
# wc -l file 2. 如果需要将stdin作为输入，使用下列命令：
#cat file | wc -l 3. 统计单词数：
# wc -w file
# cat file | wc -w 4. 统计字符数：
# wc -c file
# cat file | wc -c 可以按照下面的方法统计文本中的字符数：
-n用于避免echo添加额外的换行符。
[root@VM_16_9_centos tmp]# echo "CCS"|wc -c
4
[root@VM_16_9_centos tmp]# echo -n "CCS"|wc -c
3
4 5. 当不使用任何选项执行wc时：
# wc file
1435 15763 112200
它会分别打印出文件的行数、单词数和字符数。 6. 使用-L选项打印出文件中最长一行的长度：
# wc file -L
205 =====================================================================
shell求两个数相除后的百分比 [root@VM_16_9_centos tmp]#
[root@VM_16_9_centos tmp]# cat test.sh
#!/bin/bash
NUM1=78
NUM2=345 Percent_1=$(printf "%d%%" $((${NUM1}*100/${NUM2})))
#或者 #保留１位小数,四舍五入
Percent_2=`awk 'BEGIN{printf "%.1f%%\n",('${NUM1}'/'${NUM2}')*100}'` #保留3位小数,四舍五入
Percent_3=`awk 'BEGIN{printf "%.3f%%\n",('${NUM1}'/'${NUM2}')*100}'` echo $Percent_1
echo $Percent_2
echo $Percent_3
[root@VM_16_9_centos tmp]# sh test.sh
22%
22.6%
22.609%