shell中$(( ))与$( )还有${ }的区别

 开发  shell中$(( ))与$( )还有${ }的区别已关闭评论
1月 222018
 

学习了, 来自:http://blog.csdn.net/tg5156/article/details/19406275

$( )与` `(反引号)

在bash shell中,$( )与` `(反引号)都是用来做命令替换(command substitution)用的。
$ echo the last sunday is $(date -d “last sunday” +%Y-%m-%d)
得到上一星期天的日期

用$( )的理由

1. ` `很容易与’ ‘(单引号)搞混。有时在一些奇怪的字形显示中,两种符号是一模一样的(直竖两点)。
2. 在多层次的复合替换中,` `须要额外的跳脱(\`)处理,而$( )则比较直观。例如:
command1 `command2 `command3` `
原本的意图是在command2 `command3`中先将command3替换出来给command2处理,然后再将结果传给command1 `command2 …`来处理。
然而,真正的结果在命令行中却是分成了`command2`与` `两段。
正确的输入应该如下:
command1 `command2 \`command3\` `
换成$( )则一目了然:
command1 $(command2 $(command3))

$( )的不足

` `基本上可在全部的unix shell中使用,若写成shell script移植性比较高。而$( )并不是每一种shell都能使用。

${ }用来作变量替换

一般情况下,$var与${var}作用相同。但是用${ }会比较精确的界定变量名称的范围,例如:
$ A=B
$ echo $AB
原本是打算先将$A的结果替换出来,然后再补一个B字母于其后,但在命令行上,真正的结果却是只会替换变量名称为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?my.file.txt} :若 $file 未设定,则将 my.file.txt 输出至 STDERR。(空值及非空值时不作处理)
${file:?my.file.txt} :若 $file 未设定或为空值,则将 my.file.txt 输出至 STDERR。(非空值时不作处理)
以上的理解在于,一定要分清楚 unset 与 null 及 non-null 这三种赋值状态。
一般而言,与 null 有关,若不带 : 的话,null 不受影响,若带 : 则连 null 也受影响。
${#var} 可计算出变量值的长度:
${#file} 可得到 27,/dir1/dir2/dir3/my.file.txt 刚好是 27 个字节。

bash数组(array)处理方法

一般而言,A=”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 中,$(( ))的整数运算符号大致有这些:
+ – * / 加、减、乘、除
% 余数运算
& | ^ ! 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) 的返回值
常见的用于(( ))的测试符号有以下这些:
< 小于
> 大于
<= 小于或等于
>= 大于或等于
== 等于
!= 不等于

处理Apache日志的Bash脚本

 log  处理Apache日志的Bash脚本已关闭评论
12月 142016
 

来自阮一峰的博客,学习了, 转自:http://www.ruanyifeng.com/blog/2012/01/a_bash_script_of_apache_log_analysis.html

以往,我用的是AWStats日志分析软件。它可以生成很详细的报表,但是不太容易定制,得不到某些想要的信息。所以,我就决定自己写一个Bash脚本,统计服务器的日志,顺便温习一下脚本知识。

事实证明,这件事比我预想的难。虽然最终脚本只有20多行,但花了我整整一天,反复查看手册,确认用法和合适的参数。下面就是我的日志分析脚本,虽然它还不是通用的,但是我相信里面用到的命令,足以满足一般的日志分析需求,同时也是很好的学习Bash的实例。如果下面的每一个命令你都知道,我觉得可以堪称熟练使用Bash了。

一、操作环境

在介绍脚本之前,先讲一下我的服务器环境。

我的网络服务器软件是Apache,它会对每一个http请求留下记录,就像下面这一条:

203.218.148.99 – – [01/Feb/2011:00:02:09 +0800] “GET /blog/2009/11/an_autobiography_of_yang_xianyi.html HTTP/1.1” 200 84058 “http://www.ruanyifeng.com/blog/2009/11/freenomics.html” “Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-TW; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13”

它的意思是2011年2月1日,IP地址为203.218.148.99的访问者,向服务器请求访问网址/blog/2009/11/an_autobiography_of_yang_xianyi.html。

当天所有的访问记录,组成一个日志。过去一年,一共生成了365个日志文件。它们存放在12个目录中,每一个目录表示一个月(2011-01、2011-02、……2011-12),里面的日志文件依次为www-01.log、www-02.log、……www-31.log(假定该月有31天)。

在不压缩的情况下,365个日志文件加起来,要占掉10GB空间。我的目标就是分析这10GB日志,最后得到一个如下形式的访问量排名:

访问量 网址1
访问量 网址2
访问量 网址3
…… ……

二、为什么要用Bash

很多计算机语言,都可以用来完成这个任务。但是,如果只是简单的日志分析,我觉得Bash脚本是最合适的工具。

主要原因有两个:一是”开发快”,Bash脚本是各种Linux命令的组合,只要知道这些命令怎么用,就可以写脚本,基本上不用学习新的语法,而且它不用编译,直接运行,可以边写边试,对开发非常友好。二是”功能强”,Bash脚本的设计目的,就是为了处理输入和输出,尤其是单行的文本,所以非常合适处理日志文件,各种现成的参数加上管道机制,威力无穷。

前面已经说过,最终的脚本我只用了20多行,处理10GB的日志,20秒左右就得到了结果。考虑到排序的巨大计算量,这样的结果非常令人满意,充分证明了Bash的威力。

三、总体思路

我的总体处理思路是这样的:

第一步,处理单个日志。统计每一天各篇文章的访问量。

第二步,生成月度排名。将每一天的统计结果汇总,得到月度访问量。

第三步,生成年度排名。将12个月的统计结果汇总,进行年度访问量的排序。

四、处理单个日志

以2011年1月1日的日志为例,它在目录2011-01之中,文件名是www-01.log,里面有10万条如下格式的记录:

203.218.148.99 – – [01/Feb/2011:00:02:09 +0800] “GET /blog/2009/11/an_autobiography_of_yang_xianyi.html HTTP/1.1” 200 84058 “http://www.ruanyifeng.com/blog/2009/11/freenomics.html” “Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-TW; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13”

处理这个日志,我只用了一行代码:

awk ‘$9 == 200 {print $7}’ www-01.log | grep -i ‘^/blog/2011/.*\.html$’ | sort | uniq -c | sed ‘s/^ *//g’ > www-01.log.result

它用管道连接了5个命令,每一个都很简单,我们依次来看:

(1) awk ‘$9 == 200 {print $7}’ www-01.log

awk命令默认用空格,将每一行文本分割成若干个字段。仔细数一下,我们需要的只是第7个字段,即http请求的网址,{print $7}表示将第7个字段输出,结果就是:

/blog/2009/11/an_autobiography_of_yang_xianyi.html

考虑到我们只统计成功的请求,因此再加一个限制条件,服务器的状态代码必须是200(表示成功),写成”$9 == 200″,即第9个字段必须是200,否则不输出第7个字段。

更精细的统计,还应该区分网络蜘蛛和真实访问者,由于我想不出简单的分辨方法,这里只好忽略了。

(2)grep -i ‘^/blog/2011/.*\.html$’

在输出的所有记录的第7个字段之中,并不是每一条记录都需要统计的。根据我的文章的命名特点,它们的网址应该都以”/blog/2011/”开头,以”.html”结尾。所以,我用一个正则表达式”^/blog/2011/.*\.html$”,找出这些记录。参数i表示不区分大小写。

(3)sort

这时,所有需要统计的记录应该都列出来了,但是它们的次序是杂乱的。接着,使用sort命令,不过目的不是为了排序,而是把相同的网址排列在一起,为后面使用uniq命令创造条件。

(4)uniq -c

uniq的作用是过滤重复的记录,只保留一行。c参数的作用,是在每行的开头添加该记录的出现次数。处理之后的输出应该是这样的:

32 /blog/2011/01/guidelines_for_english_translations_in_public_places.html
32 /blog/2011/01/api_for_google_s_url_shortener.html
30 /blog/2011/01/brief_history_of_arm.html

它表示以上三篇文章,在1月1日的日志中,分别有32条、32条、30条的访问记录(即访问次数)。

(5)sed ‘s/^ *//g’ > www-01.log.result

上一步uniq命令添加的访问次数,是有前导空格的。也就是说,在上例的32、32、30之前有一连串空格,为了后续操作的方便,这里把前导空格删去。sed命令是一个处理行文本的编辑器,’s/^ *//g’是一个正则表达式(^和*之间有一个空格),表示将行首的连续空格替换为空(即删除)。接着,将排序结果重定向到文件www-01.result。单个日志分析就完成了。

五、月度汇总排名

经过上一步之后,1月份的31个日志文件,生成了31个对应的分析结果文件。为了汇总整个月的情况,必须把这31个结果文件合并。

(6)合并分析结果

for i in www-*.log.result 
do 
cat $i >> log.result
done

这是一个循环结构,把所有www-01.log.result形式的文件,都写进log.result文件。

然后,我用一行语句,计算月度排名。

sort -k2 log.result | uniq -f1 –all-repeated=separate |./log.awk |sort -rn > final.log.result

这行语句由3个命令和1个awk脚本组成:

(7)sort -k2 log.result

由于是31个文件汇总,log.result文件里面的记录是无序的,必须用sort命令,将相同网址的记录归类在一起。但是此时,访问次数是第一个字段,网址是第二个字段,因此参数k2表示根据第二个字段进行排序。

(8)uniq -f1 –all-repeated=separate

uniq的作用是过滤重复的记录,参数f1表示忽略第一个字段(访问次数),只考虑后面的字段(网址);参数表示all-repeated=separate,表示过滤掉所有只出现一次的记录,保留所有重复的记录,并且每一组之间用一个空行分隔。这一步完成以后,输出结果变成如下的形式:

617 /blog/2011/01/guidelines_for_english_translations_in_public_places.html
455 /blog/2011/01/guidelines_for_english_translations_in_public_places.html

223 /blog/2011/01/2010_my_blogging_summary.html
253 /blog/2011/01/2010_my_blogging_summary.html

相同网址都归在一组,组间用空行分割。为了简洁,上面的例子每一组只包含两条记录,实际上每一组都包含31条记录(分别代表当月每天的访问次数)。

(9)log.awk脚本

为了将31天的访问次数加总,我动了很多脑筋。最后发现,唯一的方法就是用awk命令,而且必须另写一个awk脚本。

#!/usr/bin/awk -f

BEGIN {
RS=”” #将多行记录的分隔符定为一个空行
}

{
sum=0 #定义一个表示总和的变量,初值为0
for(i=1;i<=NF;i++){ #遍历所有字段
if((i%2)!=0){ #判断是否为奇数字段
sum += $i #如果是的话,累加这些字段的值
}
}
print sum,$2 #输出总和,后面跟上对应的网址 
}

我已经对上面这个log.awk脚本加了详细注释。这里再说明几点:首先,默认情况下,awk将”\n”作为记录的分隔符,设置RS=””表示改为将空行作为分隔符,因此形成了一个多行记录;其次,NF是一个awk的内置变量,表示当前行的字段总数。由于输入文件之中,每一行都包含两个字段,第一个是访问数,第二个是网址,所以这里做一个条件判断,只要是奇数字段就累加,偶数字段则一律跳过。最后,每个记录输出一个累加值和网址,它们之间用空格分割。

(10)sort -rn > final.log.result

对awk脚本的处理结果进行排序,sort默认使用第一个字段,参数r表示逆序,从大往小排;参数n表示以数值形式排序,不以默认的字典形式排序,否则会出现10小于2的结果。排序结果重定向到final.log.result。至此,月度排名完成。

六、脚本文件

用一个脚本,包含上面两节所有的内容。

#!/bin/bash

if ls ./*.result &> /dev/null #判断当前目录中是否有后缀名为result的文件存在
then
rm *.result #如果有的话,删除这些文件
fi

touch log.result #创建一个空文件

for i in www-*.log #遍历当前目录中所有log文件
do 
echo $i … #输出一行字,表示开始处理当前文件
awk ‘$9 == 200 {print $7}’ $i|grep -i ‘^/blog/2011/.*\.html$’|sort|uniq -c|sed ‘s/^ *//g’ > $i.result #生成当前日志的处理结果
cat $i.result >> log.result #将处理结果追加到log.result文件
echo $i.result finished #输出一行字,表示结束处理当前文件
done

echo final.log.result … #输出一行字,表示最终统计开始

sort -k2 log.result | uniq -f1 –all-repeated=separate |./log.awk |sort -rn > final.log.result #生成最终的结果文件final.log.result

echo final.log.result finished #输出一行字,表示最终统计结束

shell中标准输出,标准错误>/dev/null 2>&1解释

 linux  shell中标准输出,标准错误>/dev/null 2>&1解释已关闭评论
8月 252016
 
shell中可能经常能看到:>/dev/null  2>&1

eg:sudo kill -9 `ps -elf |grep -v grep|grep $1|awk ‘{print $4}’` 1>/dev/null 2>/dev/null

命令的结果可以通过%>的形式来定义输出
/dev/null 代表空设备文件
> 代表重定向到哪里,例如:echo “123” > /home/123.txt
1 表示stdout标准输出,系统默认值是1,所以”>/dev/null”等同于”1>/dev/null”
2 表示stderr标准错误
& 表示等同于的意思,2>&1,表示2的输出重定向等同于1
那么本文标题的语句:
1>/dev/null 首先表示标准输出重定向到空设备文件,也就是不输出任何信息到终端,说白了就是不显示任何信息。
2>&1 接着,标准错误输出重定向等同于 标准输出,因为之前标准输出已经重定向到了空设备文件,所以标准错误输出也重定向到空设备文件。

/////////////////////

脚本只使用标准输入、标准输出和标准错误
    Shell会自动为我们打开和关闭0、1、2这三个文件描述符,我们不需要显式地打开或关闭它们。标准输入是命令的输入,默认指向键盘;标准输出是命令的输出,默认指向屏幕;标准错误是命令错误信息的输出,默认指向屏幕。
    如果没有显式地进行重定向,命令通过文件描述符0从屏幕读取输入,通过文件描述符1和2将输出和错误信息输出到屏幕。但如果我们想从其他文件(再次强调,I/O设备在Unix/Linux中也是文件)读取输入或产生输出,就需要对0、1、2使用重定向了。其语法如下:

command < filename                         把标准输入重定向到filename文件中
command 0< filename                       把标准输入重定向到filename文件中
command > filename                         把标准输出重定向到filename文件中(覆盖)
command 1> fielname                       把标准输出重定向到filename文件中(覆盖)
command >> filename                       把标准输出重定向到filename文件中(追加)
command 1>> filename                     把标准输出重定向到filename文件中(追加)
command 2> filename                       把标准错误重定向到filename文件中(覆盖)
command 2>> filename                     把标准输出重定向到filename文件中(追加)
command > filename 2>&1               把标准输出和标准错误一起重定向到filename文件中(覆盖)
command >> filename 2>&1             把标准输出和标准错误一起重定向到filename文件中(追加)
command < filename >filename2        把标准输入重定向到filename文件中,把标准输出重定向

                                                        到filename2文件中
command 0< filename 1> filename2   把标准输入重定向到filename文件中,把标准输出重定向

                                                        到filename2文件中
重定向的使用有如下规律:
1)标准输入0、输出1、错误2需要分别重定向,一个重定向只能改变它们中的一个。
2)标准输入0和标准输出1可以省略。(当其出现重定向符号左侧时)
3)文件描述符在重定向符号左侧时直接写即可,在右侧时前面加&。
4)文件描述符与重定向符号之间不能有空格!

linux shell自定义函数(定义、返回值、变量作用域)介绍

 linux  linux shell自定义函数(定义、返回值、变量作用域)介绍已关闭评论
3月 302016
 

学习下shell中的自定义函数:

linux shell 可以用户定义函数,然后在shell脚本中可以随便调用。下面说说它的定义方法,以及调用需要注意那些事项。

一、定义shell函数(define function)

语法:

[ function ] funname [()]

{

action;

[return int;]

}

说明:

  • 1、可以带function fun() 定义,也可以直接fun() 定义,不带任何参数。
  • 2、参数返回,可以显示加:return 返回,如果不加,将以最后一条命令运行结果,作为返回值。 return后跟数值n(0-255

实例(testfun1.sh):

#!/bin/sh
 
 fSum 3 2;
 functionfSum()
 {
   echo$1,$2;
   return$(($1+$2));
 }
 fSum 5 7;
 total=$(fSum 3 2);
 echo$total,$?;
 
sh testfun1.sh
testfun1.sh: line 3: fSum:commandnot found
5,7
3,2
1
5


从上面这个例子我们可以得到几点结论:

  • 1、必须在调用函数地方之前,声明函数,shell脚本是逐行运行。不会像其它语言一样先预编译。一次必须在使用函数前先声明函数。
  • 2、total=$(fSum 3 2); 通过这种调用方法,我们清楚知道,在shell 中 单括号里面,可以是:命令语句。 因此,我们可以将shell中函数,看作是定义一个新的命令,它是命令,因此 各个输入参数直接用 空格分隔。 一次,命令里面获得参数方法可以通过:$0…$n得到。 $0代表函数本身。
  • 3、函数返回值,只能通过$? 系统变量获得,直接通过=,获得是空值。其实,我们按照上面一条理解,知道函数是一个命令,在shell获得命令返回值,都需要通过$?获得。

二、函数作用域,变量作用范围

先我们看一个实例(testfun2.sh ):

#!/bin/sh
 
echo$(uname);
declarenum=1000;
 
uname()
{
  echo”test!”;
  ((num++));
  return100;
}
testvar()
{
  localnum=10;
  ((num++));
  echo$num;
 
}
 
uname;
echo$?
echo$num;
testvar;
echo$num;
 
sh testfun2.sh
Linux
test!
100
1001
11
1001

我们一起来分析下上面这个实例,可以得到如下结论:

  • 1、定义函数可以与系统命令相同,说明shell搜索命令时候,首先会在当前的shell文件定义好的地方查找,找到直接执行。
  • 2、需要获得函数值:通过$?获得
  • 3、如果需要传出其它类型函数值,可以在函数调用之前,定义变量(这个就是全局变量)。在函数内部就可以直接修改,然后在执行函数就可以读出修改过的值。
  • 4、如果需要定义自己变量,可以在函数中定义:local 变量=值 ,这时变量就是内部变量,它的修改,不会影响函数外部相同变量的值 。

转自:http://www.jb51.net/article/33899.htm

linux shell “(())” 双括号运算符使用

 linux  linux shell “(())” 双括号运算符使用已关闭评论
3月 302016
 

在刚开始学习inux shell脚本编程时候,对于它的 四则运算以及逻辑运算。估计很多朋友都感觉比较难以接受。特变逻辑运算符”[]”使用时候,必须保证运算符与算数 之间有空格。 四则运算也只能借助:let,expr等命令完成。 今天讲的双括号”(())”结构语句,就是对shell中算数及赋值运算的扩展。

 

使用方法:

语法:

((表达式1,表达式2…))

特点:

1、在双括号结构中,所有表达式可以像c语言一样,如:a++,b–等。

2、在双括号结构中,所有变量可以不加入:“$”符号前缀。

3、双括号可以进行逻辑运算,四则运算

4、双括号结构 扩展了for,while,if条件测试运算

5、支持多个表达式运算,各个表达式之间用“,”分开

使用实例:

  • 扩展四则运算
1
2
3
4
5
6
7
8
9
10
11
#!/bin/sh
 
a=1;
b=2;
c=3;
 
((a=a+1));
echo $a;
 
a=$((a+1,b++,c++));
echo $a,$b,$c

 

运行结果:

sh testsh.sh
2
3,3,4

双括号结构之间支持多个表达式,然后加减乘除等c语言常用运算符都支持。如果双括号带:$,将获得表达式值,赋值给左边变量。

  • 扩展逻辑运算
1
2
3
4
5
6
7
8
9
10
#!/bin/sh
 
a=1;
b=”ab”;
 
 
echo $((a>1?8:9));
 
((b!=”a”))&&echo “err2”;
((a<2))&&echo “ok”;

 

运行结果:

sh testsh.sh
9
err2
ok

  • 扩展流程控制语句(逻辑关系式)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/bin/sh
 
num=100;
total=0;
 
for((i=0;i<=num;i++));
do
    ((total+=i));
done
echo $total;
 
total=0;
i=0;
while((i<=num));
do
    ((total+=i,i++));
done
echo $total;
 
if((total>=5050));then
    echo “ok”;
fi

 

运算结果:

sh testsh.sh
5050
5050
ok

 

有了双括号运算符:[[]],[],test 逻辑运算,已经let,expr 都可以抛到一边了。

转自:http://www.cnblogs.com/chengmo/archive/2010/10/19/1855577.html

shell中文件的判断(-d,-a, -e等)

 linux  shell中文件的判断(-d,-a, -e等)已关闭评论
3月 282016
 

[ -a FILE ] 如果 FILE 存在则为真。

[ -b FILE ] 如果 FILE 存在且是一个块特殊文件则为真。

[ -c FILE ] 如果 FILE 存在且是一个字特殊文件则为真。

[ -d FILE ] 如果 FILE 存在且是一个目录则为真。

[ -e FILE ] 如果 FILE 存在则为真。

[ -f FILE ] 如果 FILE 存在且是一个普通文件则为真。

[ -g FILE ] 如果 FILE 存在且已经设置了SGID则为真。

[ -h FILE ] 如果 FILE 存在且是一个符号连接则为真。

[ -k FILE ] 如果 FILE 存在且已经设置了粘制位则为真。

[ -p FILE ] 如果 FILE 存在且是一个名字管道(F如果O)则为真。

[ -r FILE ] 如果 FILE 存在且是可读的则为真。

[ -s FILE ] 如果 FILE 存在且大小不为0则为真。

[ -t FD ] 如果文件描述符 FD 打开且指向一个终端则为真。

[ -u FILE ] 如果 FILE 存在且设置了SUID (set user ID)则为真。

[ -w FILE ] 如果 FILE 如果 FILE 存在且是可写的则为真。

[ -x FILE ] 如果 FILE 存在且是可执行的则为真。

[ -O FILE ] 如果 FILE 存在且属有效用户ID则为真。

[ -G FILE ] 如果 FILE 存在且属有效用户组则为真。

[ -L FILE ] 如果 FILE 存在且是一个符号连接则为真。

[ -N FILE ] 如果 FILE 存在 and has been mod如果ied since it was last read则为真。

[ -S FILE ] 如果 FILE 存在且是一个套接字则为真。

[ FILE1 -nt FILE2 ] 如果 FILE1 has been changed more recently than FILE2, or 如果 FILE1 exists and FILE2 does not则为真。

[ FILE1 -ot FILE2 ] 如果 FILE1 比 FILE2 要老, 或者 FILE2 存在且 FILE1 不存在则为真。

[ FILE1 -ef FILE2 ] 如果 FILE1 和 FILE2 指向相同的设备和节点号则为真。

[ -o OPTIONNAME ] 如果 shell选项 “OPTIONNAME” 开启则为真。

[ -z STRING ] “STRING” 的长度为零则为真。

[ -n STRING ] or [ STRING ] “STRING” 的长度为非零 non-zero则为真。

[ STRING1 == STRING2 ] 如果2个字符串相同。 “=” may be used instead of “==” for strict POSIX compliance则为真。

[ STRING1 != STRING2 ] 如果字符串不相等则为真。

[ STRING1 < STRING2 ] 如果 “STRING1” sorts before “STRING2” lexicographically in the current locale则为真。

[ STRING1 > STRING2 ] 如果 “STRING1” sorts after “STRING2” lexicographically in the current locale则为真。

[ ARG1 OP ARG2 ] “OP” is one of -eq, -ne, -lt, -le, -gt or -ge. These arithmetic binary operators return true if “ARG1” is equal to, not equal to, less than, less than or equal to, greater than, or greater than or equal to “ARG2”, respectively. “ARG1” and “ARG2” are integers.

3月 102015
 

网上看到的关于linux命令使用的好文章,这篇是关于sort,分享下:

sort是在Linux里非常常用的一个命令,管排序的,集中精力,五分钟搞定sort,现在开始!

1 sort的工作原理

sort将文件的每一行作为一个单位,相互比较,比较原则是从首字符向后,依次按ASCII码值进行比较,最后将他们按升序输出。

[rocrocket@rocrocket programming]$ cat seq.txt
banana
apple
pear
orange
[rocrocket@rocrocket programming]$ sort seq.txt
apple
banana
orange
pear

2 sort的-u选项

它的作用很简单,就是在输出行中去除重复行。

[rocrocket@rocrocket programming]$ cat seq.txt
banana
apple
pear
orange
pear
[rocrocket@rocrocket programming]$ sort seq.txt
apple
banana
orange
pear
pear
[rocrocket@rocrocket programming]$ sort -u seq.txt
apple
banana
orange
pear

pear由于重复被-u选项无情的删除了。

3 sort的-r选项

sort默认的排序方式是升序,如果想改成降序,就加个-r就搞定了。

[rocrocket@rocrocket programming]$ cat number.txt
1
3
5
2
4
[rocrocket@rocrocket programming]$ sort number.txt
1
2
3
4
5
[rocrocket@rocrocket programming]$ sort -r number.txt
5
4
3
2
1

4 sort的-o选项

由于sort默认是把结果输出到标准输出,所以需要用重定向才能将结果写入文件,形如sort filename > newfile。

但是,如果你想把排序结果输出到原文件中,用重定向可就不行了。

[rocrocket@rocrocket programming]$ sort -r number.txt > number.txt
[rocrocket@rocrocket programming]$ cat number.txt
[rocrocket@rocrocket programming]$
看,竟然将number清空了。

就在这个时候,-o选项出现了,它成功的解决了这个问题,让你放心的将结果写入原文件。这或许也是-o比重定向的唯一优势所在。

[rocrocket@rocrocket programming]$ cat number.txt
1
3
5
2
4
[rocrocket@rocrocket programming]$ sort -r number.txt -o number.txt
[rocrocket@rocrocket programming]$ cat number.txt
5
4
3
2
1

5 sort的-n选项

你有没有遇到过10比2小的情况。我反正遇到过。出现这种情况是由于排序程序将这些数字按字符来排序了,排序程序会先比较1和2,显然1小,所以就将10放在2前面喽。这也是sort的一贯作风。

我们如果想改变这种现状,就要使用-n选项,来告诉sort,“要以数值来排序”!

[rocrocket@rocrocket programming]$ cat number.txt
1
10
19
11
2
5
[rocrocket@rocrocket programming]$ sort number.txt
1
10
11
19
2
5
[rocrocket@rocrocket programming]$ sort -n number.txt
1
2
5
10
11
19

6 sort的-t选项和-k选项

如果有一个文件的内容是这样:

[rocrocket@rocrocket programming]$ cat facebook.txt
banana:30:5.5
apple:10:2.5
pear:90:2.3
orange:20:3.4

这个文件有三列,列与列之间用冒号隔开了,第一列表示水果类型,第二列表示水果数量,第三列表示水果价格。

那么我想以水果数量来排序,也就是以第二列来排序,如何利用sort实现?

幸好,sort提供了-t选项,后面可以设定间隔符。(是不是想起了cut和paste的-d选项,共鸣~~)

指定了间隔符之后,就可以用-k来指定列数了。

[rocrocket@rocrocket programming]$ sort -n -k 2 -t : facebook.txt
apple:10:2.5
orange:20:3.4
banana:30:5.5
pear:90:2.3

我们使用冒号作为间隔符,并针对第二列来进行数值升序排序,结果很令人满意。

7 其他的sort常用选项

-f会将小写字母都转换为大写字母来进行比较,亦即忽略大小写

-c会检查文件是否已排好序,如果乱序,则输出第一个乱序的行的相关信息,最后返回1

-C会检查文件是否已排好序,如果乱序,不输出内容,仅返回1

-M会以月份来排序,比如JAN小于FEB等等

-b会忽略每一行前面的所有空白部分,从第一个可见字符开始比较。

转自:http://roclinux.cn/?p=1350

5月 192014
 

使用xargs真是太方便了,批量替换不再是问题,哈哈。

大多数 Linux 命令都会产生输出:文件列表、字符串列表等。但如果要使用其他某个命令并将前一个命令的输出作为参数该怎么办?例如,file 命令显示文件类型(可执行文件、ascii 文本等);您可以处理输出,使其仅显示文件名,现在您希望将这些名称传递给 ls -l 命令以查看时间戳记。xargs 命令就是用来完成此项工作的。它允许您对输出执行其他某些命令。记住下面这个来自于第 1 部分中的语法: 
file -Lz * | grep ASCII | cut -d”:” -f1 | xargs ls -ltr
让我们来剖析这个命令字符串。第一个,file -Lz *,用于查找是符号链接或者经过压缩的文件。它将输出传递给下一个命令 grep ASCII,该命令在其中搜索 “ASCII” 字符串并产生如下所示的输出: alert_DBA102.log:        ASCII English text
alert_DBA102.log.Z:      ASCII text (compress’d data 16 bits)
dba102_asmb_12307.trc.Z: ASCII English text (compress’d data 16 bits)
dba102_asmb_20653.trc.Z: ASCII English text (compress’d data 16 bits)
由于我们只对文件名感兴趣,因此我们应用下一个命令 cut -d”:” -f1,仅显示第一个字段: alert_DBA102.log
alert_DBA102.log.Z
dba102_asmb_12307.trc.Z
dba102_asmb_20653.trc.Z
现在,我们希望使用 ls -l 命令,将上述列表作为参数进行传递,一次传递一个。xargs 命令允许您这样做。最后一部分,xargs ls -ltr,用于接收输出并对其执行 ls -ltr 命令,如下所示:
ls -ltr alert_DBA102.log
ls -ltr alert_DBA102.log.Z
ls -ltr dba102_asmb_12307.trc.Z
ls -ltr dba102_asmb_20653.trc.Z
因此,xargs 本身虽然没有多大用处,但在与其他命令相结合时,它的功能非常强大。
下面是另一个示例,我们希望计算这些文件中的行数:
$ file * | grep ASCII | cut -d”:” -f1  | xargs wc -l
  47853 alert_DBA102.log
     1Array dba102_cjq0_144Array3.trc
  2Array053 dba102_mmnl_144Array7.trc
    154 dba102_reco_144Array1.trc
     43 dba102_rvwr_14518.trc
  77122 total
(注:上述任务还可用以下命令完成:)
$ wc -l ‘file * | grep ASCII | cut -d”:” -f1 | grep ASCII | cut -d”:” -f1‘
该 xargs 版本用于阐释概念。Linux 可以用几种方法来完成同一个任务;请使用最适合您的情况的方法。
使用该方法,您可以快速重命名目录中的文件。
$ ls | xargs -t -i mv {} {}.bak
-i 选项告诉 xargs 用每项的名称替换 {}。-t 选项指示 xargs 先打印命令,然后再执行。
另一个非常有用的操作是当您使用 vi 打开要编辑的文件时:
$ file * | grep ASCII | cut -d”:” -f1 | xargs vi
该命令使用 vi 逐个打开文件。当您希望搜索多个文件并打开它们进行编辑时,使用该命令非常方便。 
它还有几个选项。最有用的可能是 -p 选项,它使操作具有可交互性:
$ file * | grep ASCII | cut -d”:” -f1 | xargs -p vi
vi alert_DBA102.log dba102_cjq0_144Array3.trc dba102_mmnl_144Array7.trc 
  dba102_reco_144Array1.trc dba102_rvwr_14518.trc ?…
此处的 xarg 要求您在运行每个命令之前进行确认。如果您按下 “y”,则执行命令。当您对文件进行某些可能有破坏且不可恢复的操作(如删除或覆盖)时,您会发现该选项非常有用。
-t 选项使用一个详细模式;它显示要运行的命令,是调试过程中一个非常有帮助的选项。
如果传递给 xargs 的输出为空怎么办?考虑以下命令:
$ file * | grep SSSSSS | cut -d”:” -f1 | xargs -t wc -l
wc -l 
            0
$
在此处,搜索 “SSSSSS” 后没有匹配的内容;因此 xargs 的输入均为空,如第二行所示(由于我们使用 -t 这个详细选项而产生的结果)。虽然这可能会有所帮助,但在某些情况下,如果没有要处理的内容,您可能希望停止 xargs;如果是这样,可以使用 -r 选项: $ file * | grep SSSSSS | cut -d”:” -f1 | xargs -t -r wc -l
$
如果没有要运行的内容,该命令退出。
假设您希望使用 rm 命令(该命令将作为 xargs 命令的参数)删除文件。然而,rm 只能接受有限数量的参数。如果您的参数列表超出该限制怎么办?xargs 的 -n 选项限制单个命令行的参数个数。 
下面显示了如何限制每个命令行仅使用两个参数:即使向 xargs ls -ltr 传递五个文件,但每次向 ls -ltr 仅传递两个文件。
$ file * | grep ASCII | cut -d”:” -f1 | xargs -t -n2 ls -ltr  
ls -ltr alert_DBA102.log dba102_cjq0_144Array3.trc 
-rw-r—–    1 oracle   dba           738 Aug 10 1Array:18 dba102_cjq0_144Array3.trc
-rw-r–r–    1 oracle   dba       2410225 Aug 13 05:31 alert_DBA102.log
ls -ltr dba102_mmnl_144Array7.trc dba102_reco_144Array1.trc 
-rw-r—–    1 oracle   dba       5386163 Aug 10 17:55 dba102_mmnl_144Array7.trc
-rw-r—–    1 oracle   dba          6808 Aug 13 05:21 dba102_reco_144Array1.trc
ls -ltr dba102_rvwr_14518.trc 
-rw-r—–    1 oracle   dba          2087 Aug 10 04:30 dba102_rvwr_14518.trc
使用该方法,您可以快速重命名目录中的文件。 
$ ls | xargs -t -i mv {} {}.bak
-i 选项告诉 xargs 用每项的名称替换 {}。

转自:http://www.sudu.cn/info/html/edu/linux/20080102/290238.html

一行shell脚本解决问题汇总(持续更新中)

 linux  一行shell脚本解决问题汇总(持续更新中)已关闭评论
1月 072014
 

问题: 哪个进程打开了的文件句柄最多?

lsof -n |awk ‘{print $2}’|sort|uniq -c |sort -nr|more

问题: 如何查看tcp连接汇总统计信息?
sudo netstat -n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}’

问题: 如何杀死所有应用相关进程?(以下以java进程举例)

ps -ef | grep java | grep -v grep | awk ‘{print $2}’ | xargs sudo kill -9

问题: LINUX查看进程开始时间、结束时间、运行时间?
ps -eo pid,tty,user,comm,stime,etime | more 

问题: 如何将文字进行转码?

使用iconv,如下面将中国有UTF-8转为GB2312

echo “中国” | iconv f UTF8 t GB2312


问题:redis中如何批量删除key?

redis-cli -n 0 KEYS “topic*” | xargs redis-cli -n 0 DEL

 注: redis-cli应该替换为redis完整路径 ; -n后面的0表示0切片。

问题:查看所有用户的crontab?

cut -d: -f1 /etc/passwd|xargs -i sudo crontab -u {} -l

问题:查找最新的一个目录/文件?

ls -t *.cpp | head -1    //查找当前目录下的.cpp结尾文件,从新到旧排列,取第一个

ls -t *.cpp | tail -1    //查找当前目录下的.cpp结尾文件,从排列,取最后一个

问题: 如何获取特征行间的内容

比如:文件aaa中:
.......
base x 
10
23
34
base y
ttt
zz
uu
base x
9443
1043
1132
base y
......
现在需要提取base x 和base y行中的内容,如何使用命令呢?


使用下面命令: awk 'BEGIN{FS="base x";RS="base y"} {printf("%s", $2)}' aaa

解释:

RS:Record Separator,记录分隔符

FS:Field Separator,字段分隔符

问题: 如何获取某字符串MD5/BASE64值
MD5:     echo -n "test" | md5sum                // echo -n  参数表示不打印换行符
BASE64:  echo -n "test测试" | base64


问题:查询最大的10个文件或文件夹

du -a /var | sort -n -r | head -n 10    // var为查询目录

shell脚本中一些特殊符号(` $ ! # ; |)

 linux  shell脚本中一些特殊符号(` $ ! # ; |)已关闭评论
10月 122013
 
在shell中常用的特殊符号罗列如下: 



# ;   ;; . , / 'string'| !   $   ${}   $? $$   $* 



"string"* **   ? : ^ $#   $@ `command`{}   [] [[]] ()   (()) 



||   && {xx,yy,zz,…}~   ~+   ~-   &   <…>   + – %=   ==   != 



   

# 井号 (comments) 

这几乎是个满场都有的符号,除了先前已经提过的"第一行" 

#!/bin/bash 

井号也常出现在一行的开头,或者位于完整指令之后,这类情况表示符号后面的是注解文字,不会被执行。 

# This line is comments. 

echo "a = $a" # a = 0 

由于这个特性,当临时不想执行某行指令时,只需在该行开头加上 # 就行了。这常用在撰写过程中。 

#echo "a = $a" # a = 0 

如果被用在指令中,或者引号双引号括住的话,或者在倒斜线的后面,那他就变成一般符号,不具上述的特殊功能。 





~ 帐户的 home 目录 

算是个常见的符号,代表使用者的 home 目录:cd ~;也可以直接在符号后加上某帐户的名称:cd ~user或者当成是路径的一部份:~/bin 

~+ 当前的工作目录,这个符号代表当前的工作目录,她和内建指令 pwd的作用是相同的。 

# echo ~+/var/log 

~- 上次的工作目录,这个符号代表上次的工作目录。 

# echo ~-/etc/httpd/logs 





; 分号 (Command separator) 

在 shell 中,担任"连续指令"功能的符号就是"分号"。譬如以下的例子:cd ~/backup ; mkdir startup ;cp ~/.* startup/. 





;; 连续分号 (Terminator) 

专用在 case 的选项,担任 Terminator 的角色。 

case "$fop" inhelp) echo "Usage: Command -help -version filename";;version) echo "version 0.1" ;;esac 





. 逗号 (dot,就是“点”) 

在 shell 中,使用者应该都清楚,一个 dot 代表当前目录,两个 dot 代表上层目录。 

CDPATH=.:~:/home:/home/web:/var:/usr/local 

在上行 CDPATH 的设定中,等号后的 dot 代表的就是当前目录的意思。 

如果档案名称以 dot 开头,该档案就属特殊档案,用 ls 指令必须加上 -a 选项才会显示。除此之外,在 regularexpression 中,一个 dot 代表匹配一个字元。 





'string' 单引号 (single quote) 

被单引号用括住的内容,将被视为单一字串。在引号内的代表变数的$符号,没有作用,也就是说,他被视为一般符号处理,防止任何变量替换。 

heyyou=homeecho '$heyyou' # We get $heyyou 





"string" 双引号 (double quote) 

被双引号用括住的内容,将被视为单一字串。它防止通配符扩展,但允许变量扩展。这点与单引数的处理方式不同。 

heyyou=homeecho "$heyyou" # We get home 



`command` 倒引号 (backticks) 

在前面的单双引号,括住的是字串,但如果该字串是一列命令列,会怎样?答案是不会执行。要处理这种情况,我们得用倒单引号来做。 

fdv=`date +%F`echo "Today $fdv" 

在倒引号内的 date +%F 会被视为指令,执行的结果会带入 fdv 变数中。 





, 逗点 (comma,标点中的逗号) 

这个符号常运用在运算当中当做"区隔"用途。如下例 

#!/bin/bashlet "t1 = ((a = 5 + 3, b = 7 – 1, c = 15 / 3))"echo "t1= $t1, a = $a, b = $b" 





/ 斜线 (forward slash) 

在路径表示时,代表目录。 

cd /etc/rc.dcd ../..cd / 

通常单一的 / 代表 root 根目录的意思;在四则运算中,代表除法的符号。 

let "num1 = ((a = 10 / 2, b = 25 / 5))" 





倒斜线 

在交互模式下的escape 字元,有几个作用;放在指令前,有取消 aliases的作用;放在特殊符号前,则该特殊符号的作用消失;放在指令的最末端,表示指令连接下一行。 

# type rmrm is aliased to `rm -i'# rm ./*.log 

上例,我在 rm 指令前加上 escape 字元,作用是暂时取消别名的功能,将 rm 指令还原。 

# bkdir=/home# echo "Backup dir, $bkdir = $bkdir"Backup dir,$bkdir = /home 

上例 echo 内的 $bkdir,escape 将 $ 变数的功能取消了,因此,会输出 $bkdir,而第二个 $bkdir则会输出变数的内容 /home。 





| 管道 (pipeline) 

pipeline 是 UNIX 系统,基础且重要的观念。连结上个指令的标准输出,做为下个指令的标准输入。 

who | wc -l 

善用这个观念,对精简 script 有相当的帮助。 





! 惊叹号(negate or reverse) 

通常它代表反逻辑的作用,譬如条件侦测中,用 != 来代表"不等于" 

if [ “$?” != 0 ]thenecho "Executes error"exit 1fi 

在规则表达式中她担任 "反逻辑" 的角色 

ls a[!0-9] 

上例,代表显示除了a0, a1 …. a9 这几个文件的其他文件。 





: 冒号 

在 bash 中,这是一个内建指令:"什么事都不干",但返回状态值 0。 



echo $? # 回应为 0 

: > f.$$ 

上面这一行,相当于 cat /dev/null >f.$$。不仅写法简短了,而且执行效率也好上许多。 

有时,也会出现以下这类的用法 

: ${HOSTNAME?} ${USER?} ${MAIL?} 

这行的作用是,检查这些环境变数是否已设置,没有设置的将会以标准错误显示错误讯息。像这种检查如果使用类似 test 或 if这类的做法,基本上也可以处理,但都比不上上例的简洁与效率。 





? 问号 (wild card) 

在文件名扩展(Filename expansion)上扮演的角色是匹配一个任意的字元,但不包含 null 字元。 

# ls a?a1 

善用她的特点,可以做比较精确的档名匹配。 





* 星号 (wild card) 

相当常用的符号。在文件名扩展(Filename expansion)上,她用来代表任何字元,包含 null 字元。 

# ls a*a a1 access_log 

在运算时,它则代表 "乘法"。 

let "fmult=2*3" 

除了内建指令 let,还有一个关于运算的指令expr,星号在这里也担任"乘法"的角色。不过在使用上得小心,他的前面必须加上escape 字元。 





** 次方运算 

两个星号在运算时代表 "次方" 的意思。 

let "sus=2**3"echo "sus = $sus" # sus = 8 





$ 钱号(dollar sign) 

变量替换(Variable Substitution)的代表符号。 

vrs=123echo "vrs = $vrs" # vrs = 123 

另外,在 Regular Expressions 里被定义为 "行" 的最末端 (end-of-line)。这个常用在grep、sed、awk 以及 vim(vi) 当中。 





${} 变量的正规表达式 

bash 对 ${} 定义了不少用法。以下是取自线上说明的表列 

   ${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}….. 

个位数的,可直接使用数字,但两位数以上,则必须使用 {} 符号来括住。 

$* 则是代表所有引用变量的符号。使用时,得视情况加上双引号。 

echo "$*" 

还有一个与 $* 具有相同作用的符号,但效用与处理方式略为不同的符号。 





$@ 

$@ 与 $* 具有相同作用的符号,不过她们两者有一个不同点。 

符号 $* 将所有的引用变量视为一个整体。但符号 $@ 则仍旧保留每个引用变量的区段观念。 



$# 

这也是与引用变量相关的符号,她的作用是告诉你,引用变量的总数量是多少。 

echo "$#" 





$? 状态值 (status variable) 

一般来说,UNIX(linux) 系统的进程以执行系统调用exit()来结束的。这个回传值就是status值。回传给父进程,用来检查子进程的执行状态。 

一般指令程序倘若执行成功,其回传值为 0;失败为 1。 

tar cvfz dfbackup.tar.gz /home/user > /dev/nullecho"$?"$$ 

由于进程的ID是唯一的,所以在同一个时间,不可能有重复性的 PID。有时,script会需要产生临时文件,用来存放必要的资料。而此script亦有可能在同一时间被使用者们使用。在这种情况下,固定文件名在写法上就显的不可靠。唯有产生动态文件名,才能符合需要。符号$$或许可以符合这种需求。它代表当前shell 的 PID。 

echo "$HOSTNAME, $USER, $MAIL" > ftmp.$$ 

使用它来作为文件名的一部份,可以避免在同一时间,产生相同文件名的覆盖现象。 

ps: 基本上,系统会回收执行完毕的 PID,然后再次依需要分配使用。所以 script 即使临时文件是使用动态档名的写法,如果script 执行完毕后仍不加以清除,会产生其他问题。 



(   ) 指令群组 (command group) 

用括号将一串连续指令括起来,这种用法对 shell 来说,称为指令群组。如下面的例子:(cd ~ ; vcgh=`pwd` ;echo $vcgh),指令群组有一个特性,shell会以产生 subshell来执行这组指令。因此,在其中所定义的变数,仅作用于指令群组本身。我们来看个例子 

# cat ftmp-01#!/bin/basha=fsh(a=incg ; echo -e "n $a n")echo $a#./ftmp-01incgfsh 

除了上述的指令群组,括号也用在 array 变数的定义上;另外也应用在其他可能需要加上escape字元才能使用的场合,如运算式。 





(( )) 

这组符号的作用与 let 指令相似,用在算数运算上,是 bash 的内建功能。所以,在执行效率上会比使用 let指令要好许多。 

#!/bin/bash(( a = 10 ))echo -e "inital value, a = $an"(( a++))echo "after a++, a = $a" 



{ } 大括号 (Block of code) 

有时候 script 当中会出现,大括号中会夹着一段或几段以"分号"做结尾的指令或变数设定。 

# cat ftmp-02#!/bin/basha=fsh{a=inbc ; echo -e "n $a n"}echo $a#./ftmp-02inbcinbc 

这种用法与上面介绍的指令群组非常相似,但有个不同点,它在当前的 shell 执行,不会产生 subshell。 

大括号也被运用在 "函数" 的功能上。广义地说,单纯只使用大括号时,作用就像是个没有指定名称的函数一般。因此,这样写 script也是相当好的一件事。尤其对输出输入的重导向上,这个做法可精简 script 的复杂度。 



此外,大括号还有另一种用法,如下 

{xx,yy,zz,…} 

这种大括号的组合,常用在字串的组合上,来看个例子 

mkdir {userA,userB,userC}-{home,bin,data} 

我们得到 userA-home, userA-bin, userA-data, userB-home, userB-bin,userB-data, userC-home, userC-bin,userC-data,这几个目录。这组符号在适用性上相当广泛。能加以善用的话,回报是精简与效率。像下面的例子 

chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}} 

如果不是因为支援这种用法,我们得写几行重复几次呀! 





[   ] 中括号 

常出现在流程控制中,扮演括住判断式的作用。if [ “$?” != 0 ]thenecho "Executes error"exit1fi 

这个符号在正则表达式中担任类似 "范围" 或 "集合" 的角色 

rm -r 200[1234] 

上例,代表删除 2001, 2002, 2003, 2004 等目录的意思。 





[[ ]] 

这组符号与先前的 [] 符号,基本上作用相同,但她允许在其中直接使用 || 与&& 逻辑等符号。 

#!/bin/bashread akif [[ $ak > 5 || $ak< 9 ]]thenecho $akfi 





|| 逻辑符号 

这个会时常看到,代表 or 逻辑的符号。 





&& 逻辑符号 

这个也会常看到,代表 and 逻辑的符号。 





& 后台工作 

单一个& 符号,且放在完整指令列的最后端,即表示将该指令列放入后台中工作。 

tar cvfz data.tar.gz data > /dev/null& 



<…> 单字边界 

这组符号在规则表达式中,被定义为"边界"的意思。譬如,当我们想找寻 the 这个单字时,如果我们用 

grep the FileA 

你将会发现,像 there 这类的单字,也会被当成是匹配的单字。因为 the 正巧是 there的一部份。如果我们要必免这种情况,就得加上 "边界" 的符号 

grep '' FileA 





+ 加号 (plus) 

在运算式中,她用来表示 "加法"。 

expr 1 + 2 + 3 

此外在规则表达式中,用来表示"很多个"的前面字元的意思。 

# grep '10+9' fileB109100910000910000931010009#这个符号在使用时,前面必须加上escape 字元。 





– 减号 (dash) 

在运算式中,她用来表示 "减法"。 

expr 10 – 2 

此外也是系统指令的选项符号。 

ls -expr 10 – 2 

在 GNU 指令中,如果单独使用 – 符号,不加任何该加的文件名称时,代表"标准输入"的意思。这是 GNU指令的共通选项。譬如下例 

tar xpvf – 

这里的 – 符号,既代表从标准输入读取资料。 

不过,在 cd 指令中则比较特别 

cd – 

这代表变更工作目录到"上一次"工作目录。 





% 除法 (Modulo) 

在运算式中,用来表示 "除法"。 

expr 10 % 2 

此外,也被运用在关于变量的规则表达式当中的下列 

${parameter%word}${parameter%%word} 

一个 % 表示最短的 word 匹配,两个表示最长的 word 匹配。 





= 等号 (Equals) 

常在设定变数时看到的符号。 

vara=123echo " vara = $vara" 

或者像是 PATH 的设定,甚至应用在运算或判断式等此类用途上。 





== 等号 (Equals) 

常在条件判断式中看到,代表 "等于" 的意思。 

if [ $vara == $varb ] 

…下略 



!= 不等于 

常在条件判断式中看到,代表 "不等于" 的意思。 

if [ $vara != $varb ] 

…下略 





^ 

这个符号在规则表达式中,代表行的 "开头" 位置,在[]中也与"!"(叹号)一样表示“非” 





输出/输入重导向 

> >>   <   <<   :>   &>   2&>   2<>>&   >&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的效果不一样。
 

 

 http://hi.baidu.com/hellosimple/blog/item/559483f1f1c0e95e352acc89.html

 

 http://blog.csdn.net/mqboss/article/details/6549176

1、{} 大括号:

用法一:通配符扩展 

代码: 
ls my_{finger,toe}s



这条命令相当于如下命令的组合:

代码: 
ls my_fingers my_toes

mkdir {userA,userB,userC}-{home,bin,data}



我们将得到 userA-home, userA-bin, userA-data, userB-home, userB-bin,userB-data,userC-home, userC-bin, userC-data,这几个目录

用法二:可用于语句块的构造,语句之间用回车隔开。如果你想在某些使用单个语句的地方(比如在AND或OR列表中)使用多条语句,你可以把它们括在花括号{}中来构造一个语句块。

代码: 
grep -v "$cdcatnum" $strack_file > $temp_file

cat $temp_file > $strack_file

echo

cat -n file1



(注:以上大括号中的四句命令够成了一个语句块)

用法三:参数扩展

代码: 
${name:-default} 使用一个默认值(一般是空值)来代替那些空的或者没有赋值的变量name;

${name:=default}使用指定值来代替空的或者没有赋值的变量name;

${name:?message}如果变量为空或者未赋值,那么就会显示出错误信息并中止脚本的执行同时返回退出码1。

${#name} 给出name的长度

${name%word} 从name的尾部开始删除与word匹配的最小部分,然后返回剩余部分

${name%%word} 从name的尾部开始删除与word匹配的最长部分,然后返回剩余部分

${name#word} 从name的头部开始删除与word匹配的最小部分,然后返回剩余部分

${name##word} 从name的头部开始删除与word匹配的最长部分,然后返回剩余部分



(注,name为变量名,word为要匹配的字符串)

用法三在处理字符串和未知变量时,是很有用的。



2、[] 中括号: 

用法一:通配符扩展:

允许匹配方括号中任何一个单个字符

代码: 
ls /[eh][to][cm]*



相当于执行 ls /etc /home(若有/eom目录,就相当于会执行ls /etc /home /eom)

注:在mkdir命令下不能扩展

用法二:用于条件判断符号:

[]符号可理解为指向test命令的一个软链接,所以其用法可完全参照test,将test位置替换为[便可。

代码: 
if [ "$?" != 0 ] 等价于 if test "$?" != 0

then echo "Executes error"





3、`command` 反引号:

`command`与$(command)的含义相同,都是返回当前执行命令的结果 

代码: 
#!/bin/sh

for file in $(ls f*.sh);do

    lpr $file

done

exit 0



该例实现了扩展f*.sh给出所有匹配模式的文件的名字。



4、'string' 单引号 和 "string" 双引号 

双引号:如果想在定义的变量中加入空格,就必须使用单引号或双引号,

单、双引号的区别在于双引号转义特殊字符而单引号不转义特殊字符

代码: 
$ heyyou=home

$ echo '$heyyou'

$ $heyyou ($没有转义)

eg: $ heyyou=home

$ echo "$heyyou"

$ home (很明显,$转义了输出了heyyou变量的值)





5、$# 它的作用是告诉你引用变量的总数量是多少; 

代码: 
$$ 它的作用是告诉你shell脚本的进程号;

$* 以一个单字符串显示所有的脚本传递的参数。等价于$1 $2 $3.......;

$@ 与$*基本类似(参见序号7),但在数组赋值时有些不同;

$? 前一个命令的退出码;

$- 显示shell使用的当前选项;

$! 最后一个后台运行的进程ID号。





6、$((…))语法:对括号内的表达式求值 

代码: 
#!/bin/sh

x=0

hile [ "$x" -ne 10 ];do

echo $x

x=$(($x+1))

done

exit 0





7、shell中几种特殊的参数变量的引用 

代码: 
$1、$2、$3……${10}、${11}、${12}…… :表示脚本传入的的各个参数,注意当需表示两位数以后的参数时数字要用花括号括起。

$@ 列出所有的参数,各参数用空格隔开

$*: 列出所有的参数,各参数用环境变量IFS的第一个字符隔开





8、命令列表: 

AND列表 statement1 && statement2 && statement3 && …:只有在前面所有的命令都执行成功的情况下才执行后一条命令

OR列表 statement1 || statement2 || statement3 || …:允许执行一系列命令直到有一条命令成功为止,其后所有命令将不再被执行

#!/bin/sh

代码: 
touch file_one

rm -f file_two

if [ -f file_one ] && echo "hello" && [ -f file_two ] && echo " there"

then

echo "in if"

else

echo "in else"

fi

exit 0



上例的输出为:

代码: 
hello

in else



关于AND列表与OR列表,在逻辑判断中很使用,下面就举一个其最常用的例子:

代码: 
[ condition ] && command for true || command for false:



当条件为真时,执行commandfor true ,当条件为假时,执行command for false



9、: 冒号:内建空指令,返回值为0 

代码: 
$ :

$ echo $?

$ 0

while: (该语句结构可实现一个无限循环)





10、; 分号: 在 shell 中,担任"连续指令"功能的符号就是"分号" 

代码: 
cd ~/backup ; mkdir startup ; cp ~/.* startup/.





11、# 井号:表示符号后面的是注解文字,不会被执行; 

代码: 
* 匹配文件名中的任何字符,包括字符串;

? 匹配文件名中的任何单个字符。

~ 代表使用者的 home 目录





12、/ 倒斜线:

放在指令前,有取消 aliases(别名) 的作用;

放在特殊符号前,则该特殊符号的作用消失;

放在指令的最末端,表示指令连接下一行(使得回车符无效,只起换行作用)



13、! 感叹号:

通常它代表反逻辑的作用,譬如条件侦测中,用 != 来代表"不等于" 



14、** 次方运算:两个星号在运算时代表 "次方" 的意思 

代码: 
let "sus=2**3"

echo "sus = $sus"

$ sus = 8
转自:http://www.cnblogs.com/xuxm2007/archive/2011/10/20/2218846.html