[root@www ~]# sed [-nefr] [动作] 选项与参数： -n ：使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN 的数据一般都会被列出到终端上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来。 -e ：直接在命令列模式上进行 sed 的动作编辑； -f ：直接将 sed 的动作写在一个文件内， -f filename 则可以运行 filename 内的 sed 动作； -r ：sed 的动作支持的是延伸型正规表示法的语法。(默认是基础正规表示法语法) -i ：直接修改读取的文件内容，而不是输出到终端。  动作说明： [n1[,n2]]function n1, n2 ：不见得会存在，一般代表『选择进行动作的行数』，举例来说，如果我的动作是需要在 10 到 20 行之间进行的，则『 10,20[动作行为] 』  function： a ：新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)～ c ：取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行！ d ：删除，因为是删除啊，所以 d 后面通常不接任何咚咚； i ：插入， i 的后面可以接字串，而这些字串会在新的一行出现(目前的上一行)； p ：列印，亦即将某个选择的数据印出。通常 p 会与参数 sed -n 一起运行～ s ：取代，可以直接进行取代的工作哩！通常这个 s 的动作可以搭配正规表示法！例如 1,20s/old/new/g 就是啦！

sed -i 就是直接对文本文件进行操作的

sed -i 's/原字符串/新字符串/' /home/1.txt sed -i 's/原字符串/新字符串/g' /home/1.txt

这两条命令的区别就是，看示例吧

这是1.txt的内容

#cat 1.txt d ddd #ff

再看执行这两条命令的区别吧

sed -i 's/d/7523/' /home/1.txt 执行结果 7523 7523dd #ff  sed -i 's/d/7523/g' /home/1.txt 执行结果 7523 752375237523 #ff

去掉 “行首” 带“@”的首字母@

sed -i 's/^@//' file

特定字符串的行前插入新行

sed -i '/特定字符串/i 新行字符串' file

特定字符串的行后插入新行

sed -i '/特定字符串/a 新行字符串' file

特定字符串的删除

sed -i '/字符串/d' file

在使用sed对日志或者其它文本进行parse的过程当中，有时候我们需要引用外部变量的值，
 
或者获取一个shell命令执行的结果，以便达到更加可观的输出结果。这里介绍如何做到。
 
sed中使用变量替换
 
1.sed命令使用双引号的情况下，使用$var直接引用
 
$ echo|sed "s/^/$RANDOM.rmvb_/g"
 29328.rmvb_

如果替换的变量内容中含有/符号则会提示如下错误，如
查找当前目录下的目录文件并将相对路径替换为绝对路径
find . -type f | sed -n "s/\./$PWD/p"
sed: -e expression #1, char 19: unknown option to `s'
从语法上看，没有任何问题；但由于变量中包含有“/”作为分隔符，这会和sed的替换操作的分隔符“/”引起混淆；所以，只要不使用“/”做分隔符就可以解决这个问题，如果使用“%”而不是“/”来作为sed的替换操作的分隔符，就不会出错。其实使用#或%或;作为分隔符也是可以的，只要不会与替换中有相同的而且不是元字符的特殊符号都是可以的；使用时可以根据情况灵活选择。
find . -type f | sed -n "s%\.%$PWD%p"
find . -type f | sed -n "s#\.#$PWD#p"

# 上面例子引用了一个环境变量$RANDOM的值
 
2.sed命令使用单引号的情况下，使用'"$var"'引用
 
类似，我们可以看到
 
$ echo|sed 's/^/'"$RANDOM"'.rmvb_/g'
 31338.rmvb_
 
sed中执行外部命令
 
1.sed命令使用单引号的情况下使用'`shell command`'或者'$(shell command)'引用命令执行的结果
 
还是以上面案例分析，例子如下
 
$ echo|sed 's/^/'`echo $RANDOM`'.rmvb_/g'
 8063.rmvb_
 

# 上面的例子使用了旧式的命令替换，也可以采用新式的命令替换方法，如下
 
$ echo|sed 's/^/'$(echo $RANDOM)'.rmvb_/g'
 18554.rmvb_
 

# 下面例子取用当前日期作为结果的一部分，如下
 
$ echo|sed 's/^/'$(date +"%Y%m%d")'.rmvb_/g'
 20120108.rmvb_
 

2.sed命令使用双引号的情况下直接`shell command`或者$(shell command)引用命令执行的结果
 

类似的，双引号的情况，如下
 
$ echo|sed "s/^/$(date +"%Y%m%d").rmvb_/g"
 20120108.rmvb_
 

# 使用环境变量$RANDOM以及旧式命令替换的例子
 
$ echo|sed "s/^/`echo $RANDOM`.rmvb_/g"
 4988.rmvb_
 
总结
 
在sed语句里面，变量替换或者执行shell命令，双引号比单引号少绕一些弯子

[root@~]# diff -urNa dir1 dir2
　　-a Treat all files as text and compare them line-by-line, even if they do not seem to be text.
　　-N, --new-file
　　　　In directory comparison, if a file is found in only one directory, treat it as present but empty in the other directory.
　　-r When comparing directories, recursively compare any subdirectories found.

　　-u Use the unified output format.

比较文件夹diff，也可以比较文件MD5列表。下面命令可以获取文件夹中文件md5列表

find /home/ -type f -not \( -name '.*' \) -exec md5sum {} \;

说明：(1) /home/文件目录

　　   (2) -type f 文件类型为普通文件

　　   (3) -not \( -name '.*' \)  过滤掉隐藏文件。可以过滤掉不需要考虑的文件

         (4) -exec md5sum {} \;  对每个文件执行md5sum命令 

 用tar命令压缩后，比较文件的MD5是不行的。tar压缩会带上文件的时间

如果知道行号可以用下面的方法

sed -i '88 r b.file' a.file    #在a.txt的第88行插入文件b.txt awk '1;NR==88{system("cat b.file")}' a.file > a.file 

如果不知道行号，可以用正則匹配

sed -i '/regex/ r b.txt' a.txt # regex是正则表达式 awk '/target/{system("cat b.file")}' a.file > c.file 

sed的話如果不改变源文件，可以去掉-i开关，修改会输出到STDOUT

原文件：

[root@xiaowu shell]# cat -n file       1  aaaa      2  bbbb      3  cccc      4  dddd 

现在要在第二行即“bbbb”行的下面添加一行，内容为“xiaowu”

[root@xiaowu shell]# sed '/bbbb/a\xiaowu' file  aaaa bbbb xiaowu cccc dddd 

如果要加两行“xiaowu”可以用一下语句，注意用“\n”换行

[root@xiaowu shell]# sed '/bbbb/a\xiaowu\nxiaowu' file  aaaa bbbb xiaowu xiaowu cccc dddd 

如果要在第二行即“bbbb”行的上添加一行，内容为“xiaowu”，可以把参数“a”换成“i”

[root@xiaowu shell]# sed '/b/i\xiaowu' file  aaaa xiaowu bbbb cccc dddd 

以上文件中只有一行匹配，如果文件中有两行或者多行匹配，结果有是如何呢？

[root@xiaowu shell]# cat -n file       1  aaaa      2  bbbb      3  cccc      4  bbbb      5  dddd 

[root@xiaowu shell]# sed '/bbbb/a\xiaowu' file  aaaa bbbb xiaowu cccc bbbb xiaowu dddd 

由结果可知，每个匹配行的下一行都会被添加“xiaowu”

那么如果指向在第二个“bbbb”的下一行添加内容“xiaowu”，该如何操作呢？
可以考虑先获取第二个“bbbb”行的行号，然后根据行号在此行的下一行添加“xiaowu”

获取第二个“bbbb”行的行号的方法：
方法一：

[root@xiaowu shell]# cat -n file |grep b |awk '{print $1}'|sed -n "2"p 4 

方法二：

[root@xiaowu shell]# sed -n '/bbbb/=' file |sed -n "2"p 4 

由结果可知第二个“bbbb”行的行号为4，然后再在第四行的前或后添加相应的内容:

[root@xiaowu shell]# sed -e '4a\xiaowu' file  aaaa bbbb cccc bbbb xiaowu dddd 

[root@xiaowu shell]# sed -e '4a\xiaowu\nxiaowu' file  aaaa bbbb cccc bbbb xiaowu xiaowu dddd 

向指定行的末尾添加指定内容，比如在“ccccc”行的行尾介绍“ eeeee”

[root@xiaowu shell]# cat file aaaaa bbbbb ccccc ddddd [root@xiaowu shell]# sed 's/cc.*/& eeeee/g' file aaaaa bbbbb ccccc eeeee ddddd 

原文链接

有两个特点：

1：使用-r参数

2：在目录后面使用"."号
 

这样的话就可以把/opt/merkle 目录和子目录里面的文件全部下载到本地了。

if [ $STATUS == "OK" ]; then     

echo "OK"

fi

    在运行时出现了“ [: =: unary operator expected” 的错误，就一直找不到原因，尝试了删除等号两侧的空格和括号里的空格都不管用。最后baidu了一下，才找到原因，在条件表达式外再添加一层“[]”，就不会出错了，如下：

if [[ $STATUS = "OK" ]]; then    

echo "OK"

fi 

    究其原因，是因为如果变量STATUS值为空，那么条件表达式就成了 [ = "OK"] ，显然 [ 和 "OK" 不相等并且缺少了 [ 符号，所以报了这样的错误。当然不总是出错，如果变量STATUS值不为空，程序就正常了，所以这样的错误还是很隐蔽的。

    或者，用下面的方法也能避免这种错误：

if [ "$STATUS"x == "OK"x ]; then     

echo

"OK"

fi。

当然，x也可以是其他字符。顺便提一点，shell中有没有双引号在很多情况下是一致的。

转自：http://hi.baidu.com/vishare/blog/item/bd8ab9ee289753252cf53417.html

Bash中还可以使用数组变量,其赋值有两种:

(1) name = (value1 ... valuen) 此时下标从0开始
(2) name[index] = value

数组下标的范围没有任何限制,同时也不必使用连续的分量.

   echo ${arrDest[$i]}

   let i++

done

=======================示例： for循环===============================

arrSource=("/home/800hr/htdocs/login_jump.php")

arrDest=(ithr elehr buildhr bankhr healthr  ctvhr chenhr mechr clothr cneduhr 56hr tourhr foodhr greenhr cnlawhr waimaohr)

for outer in ${arrSource[*]}   

do

   for inner in ${arrDest[*]}

   do

      echo  "ln -s $outer /home/${inner}/campus/"

   done

done

本文出自 “licong” 博客，请务必保留此出处http://licong.blog.51cto.com/542131/204226

  $^[[A^[[A^[[A 

按删除键，出来的是这个：

  $ ^H^H^H^H^H^H^H 

只能用 Ctrl+BackSpace 才能删除光标左边的内容...用的那个不习惯啊~~~！！！ - -b

后来问到 Wells ，原来只需要做一个小小的设定，在Console中启用：

  $set -o emasc 

原因后来上网查了一下，暂且引用一下《FreeBSD使用大全》中的一段内容：

-----------------------------------------------------------------------------------------------

配置用戶shell
　　事實上sh與csh，并不是普通用戶的最佳選擇，因為這兩個shell在易用性方面做的不夠好，例如命令行編 輯功能不強、不能利用熱鍵重復執行命令等。較新的shell，如bash和tcsh都具有這些方便用戶使用的功能，但 必須安裝了這些shell程序之后，才能更改普通用戶的shell設置以使用這些shell程序。更改用戶的shell 可以使用pw、vipw或chsh。

　　這兩個shell分別遵照sh和csh的風格，因此喜好csh風格的可以選擇tcsh，而喜歡sh風格的選擇 bash。除了這兩種shell之外，還有ksh、zsh等shell可供選擇。如果對兩種shell沒有偏好，可以 選擇bash，它是一個GNU軟件，比標准sh功能強大的多。

　　使用了這兩些增強型shell之后，用戶就可以使用shell提供的命令行編輯功能。按照習慣的不同，可以選 擇vi風格的編輯方式或emacs風格的方式，缺省為emacs方式，這種方式使用方向鍵來回溯執行過的命令，并進行 修改，而vi風格使用字母命令作編輯鍵，例如使用h、j、k、l四個鍵來移動光標，vi風格的好處是不使用基本鍵盤之 外的控制鍵，因而可以適用于任何終端設備，并且進行編輯時手不需離開基本鍵盤，熟練操作之后最為快捷。emacs風格 比起vi風格更適合從個人計算機轉向Unix的使用者的習慣。bash, ksh ,zsh下使用下面的命令在emacs 風格和vi風格切換：

　　bash$ set -o emacs

　　bash$ set -o vi

　　tcsh中使用不同的命令：

　　% bind emacs

　　% bind vi

　　還可以為常用的命令設置別名，簡化用戶輸入，例如：

　　bash$ alias ec=”echo This is a alias”

　　bash$ ec

　　This is a alias

　　shell用于方便用戶操作的另一項能力是自動補全命令或文件名的功能，因為FreeBSD下的文件名可能很 長，將它們全部輸入比較麻煩。事實上可以輸入部分名字，然后按Tab鍵（在vi風格下是連續兩次按Esc鍵），shell 將自動補全文件名的剩余部分。如果已經輸入的這部分名字不能確定具體的命令或文件，那么shell只將能確定的部 分補上，然后響鈴通知使用者繼續輸入以明確具體的文件。

　　事實上即使在基本的sh或csh下，也可以使用 “*” 等特殊字符，用模式匹配的方式來簡化輸入。

　　bash$ cd /usr/loca*

　　bash$ pwd

　　/usr/local

　　Unix中的多數程序都具備模式匹配的處理能力，而shell的模式匹配功能最為常用。shell可以使用這 些特殊模式來配置多個文件，達到簡化操作的目的。如果要熟練掌握Unix，必須掌握模式匹配。

　　當試圖在bash下輸入漢字的時候，除了必須設置終端屬性能接受8位字符之外（執行stty pass8命令 ），還需要設置bash的輸入輸出轉換，可以在登錄腳本.profile文件中包括以下設置：

　　bind 'set convert-meta off'

　　bind 'set meta-flag on'

　　bind 'set output-meta on'

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/chenguoda/archive/2008/06/08/2524292.aspx

一个awk 程序是一对以模式(pattern) 与大括号框起来的操作(action) 组合而成的，或许，还会加上实现操作细节的函数(function ) 。针对每个匹配于输人数据的模式，操作会被执行，且所有模式都会针对每条输人记录而检查。模式或操作可省略其中一个。如果模式省略，则操作将被应用到每条输人记录; 如果操作省略，则默认操作为打印匹配之记录在标准输出上。以下是传统awk 程序的配置:

pattern  {action} 如模式匹配，则执行操作

pattern  {action} 如模式匹配，则打印记录

虽然，模式多半是数字或字符串表达式，不过awk 以保留字BEGIN 与END 提供两种特殊模式。

与BEG 工N 关联的操作只会执行一次，在任何命令行文件或一般命令行赋值被处理之前，但是在任何开头的一V 选项指定已经完成之后。

END 操作也是只执行一次，用于所有输入数据已被处理完之后。它多半用于产生摘要报告，或是执行清除操作。

BEGIN 与END 模式可以是任意顺序，可以存在于awk 程序内的任何位置。不过，为了方便，我们通常将BEGIN 模式放在程序的第一个位置，而将END 模式放在最后。

2. 注释与空白

awk 里的注释是从# 开始到该行结束，就像在Shell 里那样。空行等同于空的注释。

3. 字符串与字符串表达式

awk 字符串包含零至多个字符，且在字符串的长度上没有限制，视可用内存而定。

字符串的比较，用的是传统的关系运算符：==( 相等) 、!=( 不等) 、<( 小于) 、<=( 小于等于) 、>( 大于) ，以及>=( 大于等于》。比较后返回l 为真，0 为假。比较不同长度的字符串，且其中一个字符串为另一个的初始子字符串时，较短的会定义为小于较长的那个，因此，“A ”< “AA ”的值为真。

awk 并无特殊的字符串接续运算符。也就是说，两个连续字符串，会自动地连接在一起。以下每一组赋值设置标量变量。为相同的具有四个字符的字符串:

s = “ABCD ”

s = “AB ”“CD ”

s = “A ”“B ”“CD ”

s = “A ”“B ”“C ”“D ”

字符串不需要是常数，如果我们继续上述的赋值:

t= s s s

则t 的值为“ABCDABCDABCD “。.

将数字转换为字符串，通过数字连接空字符串即可

n =123 ，

接着是：

s = ““ n ，把值“123 ”赋给s 。

awk 功能强大的地方大多来自于它对正则表达式的支持。有两个运算符：~( 匹配) 与!~( 不匹配) 让awk 更容易使用正则表达式：”ABC ”~ ”^[A-Z]+$ “，结果为真。

4. 数值与数值表达式

所有awk 里的数字，都以双精确度的浮点值表示。浮点数可以包含一个末端以字母e( 或E) 所表示的10 次方指数以及可选地带正负号的一个整数。举例来说:0.03125, 3.125e-2, 3125e-5 与0.003125E1 ，同样都是表示1/32 。因为awk 里所有算术都是浮点算术。

awk 并没有提供字符串转数字的函数，不过awk 的做法很简单：只要加个零到字符串里，例如：s="123" ，接着是n=0+s ，便将数字123 赋值给n 了。

5. awk 的数值运算符

表9 一：awk 的数值运算符( 优先级由大到小排列)

运算符                   说明

  ++ --                    增加与减少( 前置或后置)

  ^ **                     指数( 右结合性)

  ! + -                     非、一元(unary) 加号、一元减号

  * / %                    乘、除、余数

  + -                      加、减

< <= == != > >=           比较

&&                         逻辑AND( 简写)

||                        逻辑OR( 简写)

?:                        三元条件式

= += -= *= /= %= ^= **=      赋值( 右结合性)

6. 标量变量

保存单一值的变量叫做标量变量。

a wk 的变量名称必须以ACSII 字母或下划线开始，然后选择性地接上字母、下划线及字。因此，变量名称要匹配正则表达式[A-Za-z-][A-Za-z_0-9]* 。变量名称在实际上并没有长度的限制。awk 的变量名称是与大小写有关的:foo, Fo 。与FOO 是完全不同的三个名称。一般使用上以及建议用法是: 养成习惯，将局部变量全设为小写、全局变量第一个字母为大写，而内建变量则全是大写。

7. 数组变量

awk 允许在数组名称之后，以方括号将任意数字或字符串表达式 括起来作为索引。例如:

telephone["Alice"]= “555-0134"

telephone["Bob"]= “555-0135"

telephone["Carol”]= “555-0136"

telephone["Don"]= “555-0141"

以任意值为索引的数组，称之为关联数组，因为它们的名称与值是相关联的。重要的是，awk 将其应用于数组中，允许查找( find ) 、插入(insert ) 以及删除( remove) 等操作，在一定的时间内完成，与存储多少项目无关。

一个变量不能同时用作标量变量和数组变量。当你应用delet 。语句删除数组的元素

(element] 的时候，不会删除它的名称。因此。像这样的代码:

x[1]=3

delete x

x=789

会引发awk 发出提示，告诉你不可以给数组名称赋值.

8. 命令行参数

awk 通过内建变量ARGC( 参数计数) 与ARGV( 参数向量，或参数值) ，让命令行参数

可用。下面简短的程序说明其用法;

[root@local~]#cat showargs.awk

BEGIN{

      print ”ARGC= ”，ARGC

      for (k=0;k<ARGC; k++)

          print "ARGV[”k”]=[”ARGV[k] “

}

再来看看将它用在一般awk 命令行上，会产生什么样的结果:

[root@local~]# awk -v One=1 -v Two=2 -f showargs.awk Three=3 file1 Four=4 filet2 file3

ARGC=6

ARGV[0]=[awk]

ARGV[1]=[Three=3]

ARGV[2]=[file1]

ARGV[3]=[Four=4]

ARGV[4]=[file2]

ARGV[5]=[file3]

9. 环境变量

awk 提供访问内建数组ENV 工RON 中所有的环境变量:

[root@local~]#awk 'BEGIN {print ENVIRON["HOME"];print ENVIRON["USER]} ‘

/home/Jones

hones

通常你应将ENVIRON 看成是一个只读数组。

10. 模式

模式由字符串与 / 或数值表达式构建而成。常用的模式如下：

NF==0    选定空记录

NF>3     选定拥有三个字段以上的记录

NR<5    选定第 1 到第 4 条记录

(FNR==3)&&(FILENAME~/[.] [ch]$/) 来源于 C 源文件中选定记录 3

$1~/Jones/   选定字段 1 里有 . ” jones “的记录

/[Xx][Mm][Ll]/ 选定含有‘ 'XML' 。的记录，并忽略大小写差异

$0~/[Xx][Mm][Ll]/ 同上

11. 操作

以最简单的形式来说，纯print 意指在标准输出上，打印当前的输入记录($0) ，接着是输出记录分隔字符)ORS 的值，默认为单一换行字符。因此，下面这些程序所做的全是相同的操作:

1    模式为真，默认操作为打印

NR>0 {print} 有记录时打印( 恒为真)

1    {print}  模式为真。则打印，这是默认值

{print}  无模式则视为真，明确的打印，这是默认值

{print $0}  相同，但打印明确的值

下面的例子已经是完整的awk 程序。在每一个中，我们都只显示前三个输入字段，并通过省略选定模式，选定所有的记录。awk 程序语句以分号分隔，而且我们会使用些略微不同的操作代码，以修改输出字段分隔字符:

[root@local~]#echo ‘one two three four'| awk ‘{print $1,$2,$3}’

one two three

[root@local~]#echo ‘one two three four'| awk ‘{OFS=”…”;print $1,$2,$3}’

one…two…three

[root@local~]#echo ‘one two three four'| awk ‘{OFS=”\n”;print $1,$2,$3}’

one

two

three

改变输出字段分隔字符而没有指定任何字段，不会改变$0:

[root@local~]#echo ‘one two three four'| awk ‘{OFS=”\n”;print $0}’

one two three four

不过，如果我们更改输出字段分隔字符，并指定至少一个字段( 即使我们未变更其值) ，

强制以新的字段分隔字符重新组合记录，则结果为:

[root@local~]#echo ‘one two three four'| awk ‘{OFS=”\n”;$1=$1;print $0}’

one

two

three

four

12. 在awk 中的单行程序

1.UNIX 单词计数程序wc;

[root@local~]#awk ‘{C+=length($0)+1;w+=NF} END {print NR, W, C}’

2. 撇开NUL 字符问题，awk 其实可以轻松取代cat ，下面这两个例子会产生相同输出:

[root@local~]# cat*.xml

[root@local~]# awk 1*.xml

3. 要将原始数据值及它们的对数打印为单栏的数据文件，可使用:

[root@local~]# awk ‘{print $1, log($1)}’file(s)

4. 在以空白分隔字段的表格中，报告第n 栏的和:

[root@local~]# awk -v COLUMN=n ‘{sum+=$COLUMN} END {print sum} ’file (s)

5. 微调上述报告，产生字段n 的平均值:

[root@local~]# awk -v COLUMN=n ‘{sum+=$COLUMN} END {print sum/NR } ’file (s)

6. 针对花费文件( 其记录包含描述与金额于最后一个字段) ，打印花费总数。可使用内建变量NF 计算总值:

[root@local~]# awk’{sum+=$NF; print $0, sum}’files)

7. 这里是三种查找文件内文本的方式:

[root@local~]#egrep ‘pattern|pattern’ file (s)

[root@local~]#awk ‘/pattern|pattern/’file (s)

[root@local~]#awk ‘/pattern}pattern/ {print FILENAME ”: ”FNR ”: ”$0} ’file(s)

8. 如果你要限制仅查找100 一150 行，可以通过两个工具程序，再搭配管道，不过这么做会漏掉位置信息:

[root@local~]#sed -n -e 100,150p -s file(s) | egrep 'pattern'

使用GNU sed 要搭配-s 选项，才能为每个文件重新开始行编号。另外，你也可以通过awk ，使用比较花哨的模式来做:

[root@local~]#awk ‘(100<=FNR) && (FNR <= 150) && /pattern/\

          {print FILENAME ”:” FNR ”:”$0}’file(s)

9. 要在一个四栏表格里，调换第二与第三栏，假设它们是以制表字符分隔，那么可以

使用下面三种方式的其中一种:

[root@local~]#awk -F'\t’-v OFS='\t’{print $1, $3, $2, $4}’old > new

[root@local~]#awk ‘BEGIN{FS=OFS="\t"}{print $1, $3 ，$2 ，$4} ’old>new

[root@local~]#awk –F ‘\t’{print $1"\t" $3"\t" $2"\t" $4}’old>new

10. 要将各栏分隔字符由制表字符( 在此以·显示) 转换成& ，可在以下两种方式择一:

[root@local~]#sed -e 's/ ·/&/g' file(s)

[root@local~]#awk ‘{BEGIN{FS="\t";OFS= “& ”}{$1=$1; print} ’file(s)

11. 下面这两个管道，都为删除已排序流里的重复行

[root@local~]#sort file(s)|uniq

[root@local~]# sort file(s)|awk ‘Last!=$0 { print }{Last=$0}’

12. 将回车字符/ 换行字符的行终结，一致转换为以换行字符作为行终结，可在下列方

式中选择一种:

[root@local~]#sed –e ‘s/\r$//’ file(s)

[root@local~]#sed –e ‘s/^M$//’ file(s)

[root@local~]# mawk ‘BEGIN {RS=“\r\n"} {print}’file(s)

13. 要将单空格的文本行，转换为双空格的行，可在下列方式选择一种

[root@local~]#sed –e ‘/s/$/\n/ ’file(s)

[root@local~]#awk ‘BEGTN{ ORS = "\n\n"){print}’file(s)

[root@local~]#awk ‘BEGIN{ ORS="\n\n" }1 ’ file(s)

[root@local~]#awk {print $0 “\n”} ’ file(s)

[root@local~]#awk ‘{print;print ” ”} ’ file(s)

13. 语句

13.1. 条件语句

if(expressionl)

      stateme 刀t1

else if(expression2)

      statement2

else if(expression3)

      statement3

else if(expressionk)

      statementk

else

        statementk+l

13.2. 重复执行

awk 提供了 4 种重复执行语句 ( 循环 ):

1. 循环在起始处使用结束测试 :

while(expression)

statement

2. 循环在结尾处使用结束测试 :

do

        statement

while (expression)

3. 循环执行可计数的次数 :

for(expr1;expr2; expr3)

statement

4. 循环处理关联数组里的元素 :

for(key in array)

statement

例如：

for （name in telephone)

print name“\t" telephone[name]

13.3 数组成员测试

成员测试key in array 是一个表达式: 如果key 为array 的一个索引元素，则计算为1( 真) 。如果key 不是array 的一个索引元素，则!(key in array) 为1 。

对于具有多下标(subscript) 的数组，在测试时，请使用圆括号，并以逗点分隔下标列表:(i ，j ，…，n)in array

成员测试不可能建立数组元素，然而引用元素时，如果元素不存在，便会建立它。因此你应该这么写:

if("Sally" in telephone)

print "Sally is in the directory"

而非:

if (telephone["Sally"]!= ””)

    print "Sally is in the directory"

因为第二种形式会在她(Sally) 不存在时，将其加入到目录里，并拥有一个空电话号码。

重点是: 你必须能够区分寻找索引(index) 与寻找特定值(value) 的差异。索引成员测试需要固定的时间，而值的查找时间是与数组里元素的个数成正比，这点我们在先前已通过break 语句内的for 循环解释过了。如果你需要时常用到这两种运算，那么构建反索引数组会比较实用:

for (name in telephone)

name_by_telephone[telephone[name]]=name

接下来，你就可以使用name_by_telephone ["555-0136"] 在一定时间内找到”Carol" 。当然，这里假定所有的值是唯一的: 如果这两人共享同一个电话，则name_by_telephone 数组只会记录最后一个名称。只要稍做修改就能解决这个问题:

for (name in telephone)

{

      if (telephone[name] in name_by_telephone)

        name_by_telephone[telephone[name]]=\

              name_by_telephone [telephone[name]) “\t”name

e1se

name_by_telephone[telephone[name]]=name

现在，name_by_telephone 即包含了以制表字符分隔的具有相同电话号码的人名列表。

14. 用户控制输入

awk 也可以通过的getline 语句做这件事。getline 会返回一个值，当输入被成功读取时，它的返回值为++I ，而返回值为0 时，则表示在文件结尾，而-1 则表示错误。它的用法很多，见表。

语法             说明

getline       从当前输入文件中，读取下一条记录，存入$0 ，并更新NF, NR 与FNR

getline var   从当前输入文件中，读取下一条记录，存入var ，并更新NR 与FNR

getline<file   从file 文件中，读取下一条记录，存入$0 ，并更新NF, NR 与FNR

getline var<file 从file 文件中，读取下一条记录，存入var ，并更新NF, NR 与FNR

cmd|getline    从外部命令cmd 读取下一条记录，存入$0 ，并更新NF

cmd|getline var 从外部命令cmd 读取下一条记录，存入var

命令管道在awk 里可以发挥强大的功能。管道可以在字符字符串中标明，也可以包含任

意的Shell 命令。这里是与getline 搭配使用，如下:

"date" I getline now

close("date")

print "The current time is".now

接下来说明的是: 如何在循环里使用命令管道:

command="head -n 15 /etc/hosts"

while((command I getline s)>0)

      print s

close(command)

15. 执行外部程序

这里是解决电话名录排序问题较短的程序方案，使用临时性文件与systemty ，而非awk 管道:

tmpfile= “/tmp/telephone.tmp^

for (name in telephone>

print name "\t" telephone[name]>tmpfile

close(tmpfilej

system("sort < tmpfile “)

临时性文件必须在调用system() 之前关闭，以确保任何缓冲区输出都正确地记录在文件内。

对于被system() 执行的命令并不需要调用close() ，因为close() 仅针对以I/O 重定向运算符所打开的文件或管道，还有getline, print 或printf 。

传递给system[f 的命令可包含数行

system("cat <<EOFILE\nuno\ndos\ntres\nEOFILE"

它产生的输出和从嵌入文件复制到标准输出一样

Un0

das

tres

16. 用户自定义函数

函数定义如下:

function name(argl, }rg2, …，argn

{

statements

}

指定的参数在函数体中用来当作局部变量，它们会隐藏任何相同名称的全局性变量。函数也可用于程序它处，调用的形式为:

name(exprl, expr2, …，expn)  忽略任何的返回值

result=name(exprl, expr2, …，exprn) 将返回值存储到result 中

在每个调用点上的表达式，都提供初始值给函数参数型变量。以圆括号框起来的参数，必须紧接于函数名称之后，中间没有任何空白。

对标量参数所做的变动，调用者无从得知，不过对数组的变动就可看见了。换句话说，标量为传值(by vaule ) ，而数组则为传引用(by reference): 这对C 语言也是这样。

函数体里的return expression 语句会终止主体的执行，并将expression 的值与控制权传给调用点。如果expression 省略，则返回值由实现期定义。我们测试过的所有系统，返回的不是数字零就是空字符串。

17. 字符串函数

17.1. 子字符串提取

提取子字符串的函数:substr(string, start, 1en) ，会返回一份由string 的start 字符开始，共len 个字符长度的子字符串副本。字符的位置，从1 开始编号:substr("abcde", 2, 3) 将返回。bcd" 。 len 参数可省略，省略时，则默认为length(string)-start+1 ，选出字符串的剩余部分。

17.2. 字符串大小写转换

tolower(string) 会返回将所有字母改为同义的小写的string 副本，而toupper(string) 则返回被改为大写字母的string 副本。所以tolower("aBcDeF123") 返回”abcdef123",toupper("aBcDeF123") 返回"ABCDEF123" 。

17.3. 字符串大小写转换

index(string,  find) 查找string 里是否有字符串find ，然后返回string 里find 字符串的起始位置，如果在string 里找不到find ，则返回0 。例如index("abcdef","de") 会返回4 。

17.4. 字符串匹配

match （string, regexp) 将string 与正则表达式regexp 匹配，如果匹配，则返回

匹配string 的索引，不匹配，则返回0 。这种方式提供了比表达式(string~regexp) 还多的信息，后者只能得到计算值1 或0 。另外match ( ) 也具有一个有用的副作用: 它会将全局变量RSTART 设为在string 中要开始匹配的索引值，而将RLENGTH 设为要匹配的长度。而匹配子字符串则以substr(string, RSTART, RLENGTH) 表示。

17.5. 字符串替换

awk 在字符串替换功能上，提供两个函数:sub(regexp, replacement, target) 与gsub(regexp, replacement, target), sub() 将target 与正则表达式regexp 进行匹配，将最左边最长的匹配部分替换为字符串replacement 。gsub() 的运行则有点类似，不过它会替换所有匹配的字符串( 前置g 表示global 全局之意) 。

17.6. 字符串替换

awk 针对当前输人记录$0 自动提供了方便的分割为字1,  $}, …、$NF ，也可以函数来做:split(string, array, regexp) 将string 切割为片段，并存储到array 里的连续元素。在数组里，片段放置在匹配正则表达式regexp 的子字符串之间。如果regexp 省略，则使用内建字段分隔字符FS 的当前默认值。函数会返回array 里的元素数量。

17.7. 字符串重建

join() 可确保参数数组不会被引用到，除非索引是在范围之内。否则，一个具有数组长度为0 的调用可能会建立arrayfl3 ，而修改了调用者的数组。插人的字段分隔字符为普通字符串，而非正则表达式，所以针对传递给split() 的一般正则表达式，join() 不会重建精确的原始字符串。

17.8. 字符串格式化

最后一个与字符串相关的函数是在用户控制下格式化数字与字符串:sprintf (format,expression1, expression2, …) ，它会返回已格式化的字符串作为其函数值。printf() 的运行方式也是这样，只不过它会在标准输出或重定向的文件上显示格式化后的字符串，而不是返回其函数值。较新的程序语言以更强大的格式化函数来取代格式控制字符串，但相对而言让代码变得很冗长。按照传统的文本处理应用来说，sprintf 与printf

18. 数值函数

函数           说明

atan2(y, x)   y 返回y/x 的反正切，值介于-pai 与+pai 之间。

cos(x)        返回x 的余弦值( 以弧度(radians) 计算) ，该值介于-1 与+1 之间

exp(x)        返回x 的指数，ex,

int(x)        返回x 的整数部分，截去前置的0

log(x)        返回x 的自然对数。

rand()        返回平均分布的虚拟随机r,O<=r<l

sin(x)        返回x 的正弦值( 以弧度(radians] 计算) ，该值介于-1 与+1 之间

sqrt(x)       返回x 的平方

srand(x)      设置虚拟随机产生器的种子为x ，并返回正确的种子。如果省略x ，则使用当前时间( 以秒计) 。如果。rand ( ) 未被调用，则awk 在每次执行时会从相同的默认种子开始;mawk 则不会。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wzhwho/archive/2010/04/21/5513791.aspx

awk 'BEGIN {system("echo \"Input your name:\\c\""); getline d;print "\nYour name is",d,"\b!\n"}'

用（""）和\"   \"   \\转义。

system - execute a shell command （）里面接入命令

awk程序中我们可以使用system() 函数去调用shell命令
如：awk 'BEGIN{system("echo abc")}' file
echo abc 就会做为“命令行”，由shell来执行，所以我们会得到以下结果：


root@ubuntu:~# awk 'BEGIN{system("echo abc")}'
abc
root@ubuntu:~#


root@ubuntu:~# awk 'BEGIN{v1="echo";v2="abc";system(v1" "v2)}'
abc
root@ubuntu:~#


root@ubuntu:~# awk 'BEGIN{v1="echo";v2="abc";system(v1 v2)}'
/bin/sh: echoabc: command not found
root@ubuntu:~#


root@ubuntu:~# awk 'BEGIN{v1=echo;v2=abc;system(v1" "v2)}'
root@ubuntu:~#

从上面的例子，我们简单的分析一下awk是怎样调用system的：
如果system（）括号里面的参数没有加上双引号的话，awk认为它是一个变量，它会从awk的变量里面把它们先置换为常量，然后再回传给shell

如果system（）括号里面的参数有加上双引号的话，那么awk就直接把引号里面的内容回传给shell，作为shell的“命令行”

二。使用print cmd | “/bin/bash”

root@ubuntu:~# awk 'BEGIN{print "echo","abc"| "/bin/bash"}'
abc
root@ubuntu:~#

root@ubuntu:~# awk 'BEGIN{print "echo","abc",";","echo","123"| "/bin/bash"}'
abc
123
root@ubuntu:~#


三。总结

无论使用system（）还是print cmd | “/bin/bash”
awk都是新开一个shell，在相应的cmdline参数送回给shell，所以要注意当前shell变量与新开shell变量问题

1.1
root@ubuntu:~# abc=12345567890
root@ubuntu:~# awk 'BEGIN{system("echo $abc")}'

root@ubuntu:~#


1.2
root@ubuntu:~# export abc=12345567890
root@ubuntu:~# awk 'BEGIN{system("echo $abc")}'
12345567890
root@ubuntu:~#

2.1
root@ubuntu:~# abc=1234567890
root@ubuntu:~# awk 'BEGIN{print "echo","$abc"| "/bin/bash"}'

root@ubuntu:~#


2.2
root@ubuntu:~# export abc=1234567890
root@ubuntu:~# awk 'BEGIN{print "echo","$abc"| "/bin/bash"}'
1234567890
root@ubuntu:~#


以上例子，没有export的话，那些变量都是只存在于当前shell变量中，所以都是echo不出来的 ，
而使用了 export的都是环境变量，所以awk调用新的shell时候，可以echo出来

split命令

语法:komy@komy-vmware:~$ split [-bl] 输入文件 输出文件

参数说明

-b :以文件大小来分

-l：以行数来分

例如split -l 100 test.txt out

就是把test.txt每100行输出一个文件outaa,outab,outcd以此类推。。。实现了文本文件的分割。

split -b 100k test.txt out

就是把test.txt每100KB输出一个文件outaa,outab,outcd以此类推。

这两个命令对于手机看小说有限制的情况下很受用。。。

不仅仅如此cat 命令可将这些分割后的文件合并为一个文件，并重定向到“largefile”文件中（largefile为自定的文件名）。

komy@komy-vmware:~$ cat out* > largeflie

       -k [ FStart [ .CStart ] ] [ Modifier ] [ , [ FEnd [ .CEnd ] ][ Modifier ] ]

       The sort key includes all characters beginning with the field specified by the FStart variable and the column specified by
       the CStart variable and ending with the field specified by the FEnd variable and the column specified by the CEnd variable.
       If Fend is not specified, the last character of the line is assumed. If CEnd is not specified the last character in the
       FEnd field is assumed. Any field or column number in the KeyDefinition variable may be omitted. The default values are:
       FStart
            Beginning of the line
       CStart
            First column in the field

       FEnd
            End of the line
       CEnd
            Last column of the field

       If there is any spaces between the fields, sort considers them as separate fields.

       The value of the Modifier variable can be one or more of the letters b, d, f, i, n, or r. The modifiers apply only to the
       field definition they are attached to and have the same effect as the flag of the same letter. The modifier letter b
       applies only to the end of the field definition to which it is attached. For example:

       -k 3.2b,3r

       specifies a sort key beginning in the second nonblank column of the third field and extending to the end of the third
       field, with the sort on this key to be done in reverse collation order. If the FStart variable and the CStart variable fall
       beyond the end of the line or after the FEnd variable and the CEnd variable, then the sort key is ignored.

       A sort key can also be specified in the following manner:

       [+[FSkip1] [.CSkip1] [Modifier] ] [-[FSkip2] [.CSkip2] [Modifier]]

       The +FSkip1 variable specifies the number of fields skipped to reach the first field of the sort key and the +CSkip
       variable specifies the number of columns skipped within that field to reach the first character in the sort key. The -FSkip
       variable specifies the number of fields skipped to reach the first character after the sort key, and the -CSkip variable
       specifies the number of columns to skip within that field. Any of the field and column skip counts may be omitted. The
       defaults are:
       FSkip1
            Beginning of the line
       CSkip1
            Zero
       FSkip2
            End of the line
       CSkip2
            Zero

       The modifiers specified by the Modifier variable are the same as in the -k flag key sort definition.

       The field and column numbers specified by +FSkip1.CSkip1 variables are generally one less than the field and column number
       of the sort key itself because these variables specify how many fields and columns to skip before reaching the sort key.
       For example:

       +2.1b -3r

       specifies a sort key beginning in the second nonblank column of the third field and extending to the end of the third
       field, with the sort on this key to be done in reverse collation order. The statement +2.1b specifies that two fields are
       skipped and then the leading blanks and one more column are skipped. If the +FSkip1.CSkip1 variables fall beyond the end of

       the line or after the -FSkip2.CSkip2 variables, then the sort key is ignored.

       Note: The maximum number of fields on a line is 10.

为了防止某些网站的恶性转载，特在每篇文章前加入此信息，还望读者体谅。

===

[正文开始]
有时候学习脚本，你会发现sort命令后面跟了一堆类似-k1,2，或者-k1.2 -k3.4的东东，有些匪夷所思。今天，我们就来搞定它—-k选项！

1 准备素材

$ cat facebook.txt
google 110 5000
baidu 100 5000
guge 50 3000
sohu 100 4500

第一个域是公司名称，第二个域是公司人数，第三个域是员工平均工资。（除了公司名称，其他的别信，都瞎写的^_^）

2 我想让这个文件按公司的字母顺序排序，也就是按第一个域进行排序：（这个facebook.txt文件有三个域）

$ sort -t ‘ ‘ -k 1 facebook.txt
baidu 100 5000
google 110 5000
guge 50 3000
sohu 100 4500

看到了吧，就直接用-k 1设定就可以了。（其实此处并不严格，稍后你就会知道）

3 我想让facebook.txt按照公司人数排序

$ sort -n -t ‘ ‘ -k 2 facebook.txt
guge 50 3000
baidu 100 5000
sohu 100 4500
google 110 5000

不用解释，我相信你能懂。

但是，此处出现了问题，那就是baidu和sohu的公司人数相同，都是100人，这个时候怎么办呢？按照默认规矩，是从第一个域开始进行升序排序，因此baidu排在了sohu前面。

4  我想让facebook.txt按照公司人数排序 ，人数相同的按照员工平均工资升序排序：

$ sort -n -t ‘ ‘ -k 2 -k 3 facebook.txt
guge 50 3000
sohu 100 4500
baidu 100 5000
google 110 5000

看，我们加了一个-k2 -k3就解决了问题。对滴，sort支持这种设定，就是说设定域排序的优先级，先以第2个域进行排序，如果相同，再以第3个域进行排序。（如果你愿意，可以一直这么写下去，设定很多个排序优先级）

5 我想让facebook.txt按照员工工资降序排序，如果员工人数相同的，则按照公司人数升序排序：（这个有点难度喽）

$ sort -n -t ‘ ‘ -k 3r -k 2 facebook.txt
baidu 100 5000
google 110 5000
sohu 100 4500
guge 50 3000

此处有使用了一些小技巧，你仔细看看，在-k 3后面偷偷加上了一个小写字母r。你想想，再结合我们上一篇文章，能得到答案么？揭晓：r和-r选项的作用是一样的，就是表示逆序。因为sort默认是按照升序排序的，所以此处需要加上r表示第三个域（员工平均工资）是按照降序排序。此处你还可以加上n，就表示对这个域进行排序时，要按照数值大小进行排序，举个例子吧：

$ sort -t ‘ ‘ -k 3nr -k 2n facebook.txt
baidu 100 5000
google 110 5000
sohu 100 4500
guge 50 3000

看，我们去掉了最前面的-n选项，而是将它加入到了每一个-k选项中了。

6 -k选项的具体语法格式

要继续往下深入的话，就不得不来点理论知识。你需要了解-k选项的语法格式，如下：

[ FStart [ .CStart ] ] [ Modifier ] [ , [ FEnd [ .CEnd ] ][ Modifier ] ]

这个语法格式可以被其中的逗号（“，”）分为两大部分，Start部分和End部分。

先给你灌输一个思想，那就是“如果不设定End部分，那么就认为End被设定为行尾”。这个概念很重要的，但往往你不会重视它。

Start部分也由三部分组成，其中的Modifier部分就是我们之前说过的类似n和r的选项部分。我们重点说说Start部分的FStart和C.Start。

C.Start也是可以省略的，省略的话就表示从本域的开头部分开始。之前例子中的-k 2和-k 3就是省略了C.Start的例子喽。

FStart.CStart，其中FStart就是表示使用的域，而CStart则表示在FStart域中从第几个字符开始算“排序首字符”。

同理，在End部分中，你可以设定FEnd.CEnd，如果你省略.CEnd，则表示结尾到“域尾”，即本域的最后一个字符。或者，如果你将CEnd设定为0(零)，也是表示结尾到“域尾”。

7 突发奇想，从公司英文名称的第二个字母开始进行排序：

$ sort -t ‘ ‘ -k 1.2 facebook.txt
baidu 100 5000
sohu 100 4500
google 110 5000
guge 50 3000

看，我们使用了-k 1.2，这就表示对第一个域的第二个字符开始到本域的最后一个字符为止的字符串进行排序。你会发现baidu因为第二个字母是a而名列榜首。sohu和google第二个字符都是o，但sohu的h在google的o前面，所以两者分别排在第二和第三。guge只能屈居第四了。

8 又突发奇想，，只针对公司英文名称的第二个字母进行排序，如果相同的按照员工工资进行降序排序：

$ sort -t ‘ ‘ -k 1.2,1.2 -k 3,3nr facebook.txt
baidu 100 5000
google 110 5000
sohu 100 4500
guge 50 3000

由于只对第二个字母进行排序，所以我们使用了-k 1.2,1.2的表示方式，表示我们“只”对第二个字母进行排序。（如果你问“我使用-k 1.2怎么不行？”，当然不行，因为你省略了End部分，这就意味着你将对从第二个字母起到本域最后一个字符为止的字符串进行排序）。对于员工工资进行排序，我们也使用了-k 3,3，这是最准确的表述，表示我们“只”对本域进行排序，因为如果你省略了后面的3，就变成了我们“对第3个域开始到最后一个域位置的内容进行排序”了。

9 在modifier部分还可以用到哪些选项？

可以用到b、d、f、i、n 或 r。

其中n和r你肯定已经很熟悉了。

b表示忽略本域的签到空白符号。

d表示对本域按照字典顺序排序（即，只考虑空白和字母）。

f表示对本域忽略大小写进行排序。

i表示忽略“不可打印字符”，只针对可打印字符进行排序。（有些ASCII就是不可打印字符，比如\a是报警，\b是退格，\n是换行，\r是回车等等）

10 思考思考关于-k和-u联合使用的例子：

$ cat facebook.txt
google 110 5000
baidu 100 5000
guge 50 3000
sohu 100 4500

这是最原始的facebook.txt文件。

$ sort -n -k 2 facebook.txt
guge 50 3000
baidu 100 5000
sohu 100 4500
google 110 5000

$ sort -n -k 2 -u facebook.txt
guge 50 3000
baidu 100 5000
google 110 5000

当设定以公司员工域进行数值排序，然后加-u后，sohu一行就被删除了！原来-u只识别用-k设定的域，发现相同，就将后续相同的行都删除。

$ sort  -k 1 -u facebook.txt
baidu 100 5000
google 110 5000
guge 50 3000
sohu 100 4500

$ sort  -k 1.1,1.1 -u facebook.txt
baidu 100 5000
google 110 5000
sohu 100 4500

这个例子也同理，开头字符是g的guge就没有幸免于难。

$ sort -n -k 2 -k 3 -u facebook.txt
guge 50 3000
sohu 100 4500
baidu 100 5000
google 110 5000

咦！这里设置了两层排序优先级的情况下，使用-u就没有删除任何行。原来-u是会权衡所有-k选项，将都相同的才会删除，只要其中有一级不同都不会轻易删除的:)（不信，你可以自己加一行sina 100 4500试试看）

11 最诡异的排序：

$ sort -n -k 2.2,3.1 facebook.txt
guge 50 3000
baidu 100 5000
sohu 100 4500
google 110 5000

以第二个域的第二个字符开始到第三个域的第一个字符结束的部分进行排序。

第一行，会提取0 3，第二行提取00 5，第三行提取00 4，第四行提取10 5。

又因为sort认为0小于00小于000小于0000….

因此0 3肯定是在第一个。10 5肯定是在最后一个。但为什么00 5却在00 4前面呢？（你可以自己做实验思考一下。）

答案揭晓：原来“跨域的设定是个假象”，sort只会比较第二个域的第二个字符到第二个域的最后一个字符的部分，而不会把第三个域的开头字符纳入比较范围。当发现00和00相同时，sort就会自动比较第一个域去了。当然baidu在sohu前面了。用一个范例即可证实：

$ sort -n -k 2.2,3.1 -k 1,1r facebook.txt
guge 50 3000
sohu 100 4500
baidu 100 5000
google 110 5000

12 有时候在sort命令后会看到+1 -2这些符号，这是什么东东？

关于这种语法，最新的sort是这么进行解释的：

On older systems, `sort’ supports an obsolete origin-zero syntax `+POS1 [-POS2]‘ for specifying sort keys.  POSIX 1003.1-2001 (*note Standards conformance::) does not allow this; use `-k’ instead.

原来，这种古老的表示方式已经被淘汰了，以后可以理直气壮的鄙视使用这种表示方法的脚本喽！

（为了防止古老脚本的存在，在这再说一下这种表示方法，加号表示Start部分，减号表示End部分。最最重要的一点是，这种方式方法是从0开始计数的，以前所说的第一个域，在此被表示为第0个域。以前的第2个字符，在此表示为第1个字符。明白？）

结束语：

本文是互联网上仅有的比较全的关于sort的k选项的论述文章，如需转载请务必注明“转自Linux大棚-Linux主题博客”，谢谢各位:)

sort的-k选项基本就是这堆内容了，如果大家有什么补充，就留言吧:) 欢迎交流！

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会忽略每一行前面的所有空白部分，从第一个可见字符开始比较。

未完待续，敬请期待：《sort命令的k选项大讨论》

#! /bin/bash
for file in *.log
do
        awk 'BEGIN{var=" ' "$file" ' "}END{print var;}' "$file"
done

在这里最让人混淆的是单引号和双引号

我们可以利用bash -x test.sh来执行脚本，其会将脚本中的shell变量展开，便于调试

’单引号中除（’）都为原本字符，没有特殊意义

"双引号中除（ $`"） 都为原本字符，没有特殊意义

因此，上述可以展开为:

第一次：

awk 'BEGIN{var="a.log"}END{print var;}‘ a.log

第二次：

awk 'BEGIN{var="b.log"}END{print var;}‘ b.log

如果将其写成 awk 'BEGIN{var=' "$file" '}END{print var;}' "$file"，则展开为：

第一次：

awk 'BEGIN{var=a.log}END{print var;}‘ a.log

第二次：

awk 'BEGIN{var=b.log}END{print var;}‘ b.log

会报错，因为awk中字符串要用双引号括起来

将其分解成以下这样，便于理解：

'BEGIN{var=" '    "$file"     ' "}END{print var;}'  这三部分为字符串连接关系

## eval用法三例 ##
## shell:/bin/sh ##
## yhc 2002.09.26 18:00 ##

#例一:
#寻找合符条件的变量名,然后将该变量的值赋予另一变量
v1=aaa
v2=bbb
c=1
if [ $c -eq 1 ]
then
  vname=v$c   #找到符合条件的变量名为v1
  eval vvv="$"$vname ; echo vvv: $vvv    #将变量v1的值赋予vvv,即,使vvv=aaa
  eval vvv='$'$vname ; echo vvv: $vvv    #将变量v1的值赋予vvv,即,使vvv=aaa
 #eval vvv=$$vname   ; echo vvv: $vvv    #错误用法
fi

#例二:#以变量v1的值aaa作为变量名,将变量vaaa的值赋予这一新定义的变量aaa
v1=aaa ; vaaa="This is aaa"
#eval $v1=$vaaa    ; echo aaa: $aaa    #错误用法
#eval $v1="$vaaa"  ; echo aaa: $aaa    #错误用法
eval $v1='$vaaa'   ; echo aaa: $aaa

#例三:
#以变量v1的值aaa作为变量名,并将变量名字串作为值赋予自身
v1=aaa ; vaaa="This is aaa"
eval $v1=$v1   ; echo aaa: $aaa    #与例二的错误用法不同,这一用法是正确的
eval $v1="$v1" ; echo aaa: $aaa    #与例二的错误用法不同,这一用法是正确的
eval $v1='$v1' ; echo aaa: $aaa

该文章转载自[程序人生]：<a href="http://www.procedurelife.com/technical/SHELL/content/lbkjf.html" target="_blank">http://www.procedurelife.com/technical/SHELL/content/lbkjf.html</a>

注意：

　　(1) 对信号11(段违例)不能捕捉，因为shell本身需要捕捉该信号去进行内存的转储。

　　(2) 在trap中可以定义对信号0的处理(实际上没有这个信号)， shell程序在其终止(如

　　执行exit语句)时发出该信号。

　　(3) 在捕捉到signal-list中指定的信号并执行完相应的命令之后， 如果这些命令没有

　　将shell程序终止的话，shell程序将继续执行收到信号时所执行的命令后面的命令，这样将

　　很容易导致shell程序无法终止。

　　另外，在trap语句中，单引号和双引号是不同的，当shell程序第一次碰到trap语句时，

　　将把commands中的命令扫描一遍。此时若commands是用单引号括起来的话，那么shell不会

　　对commands中的变量和命令进行替换， 否则commands中的变量和命令将用当时具体的值来

kill -l可以列出系统的信号

通常我们需要忽略的信号有四个，即：HUP, INT, QUIT, TSTP，也就是信号1, 2, 3, 24
使用这样的语句可以使这些中断信号被忽略：
trap "" 1 2 3 24 或 trap "" HUP INT QUIT TSTP
用 trap ：1 2 3 24 或 trap HUP INT QUIT TSTP使其回复默认值。
用stty -a可以列出中断信号与键盘的对应，分别执行上面的命令后，运行
tail -f /etc/passwd, 然后尝试用键盘中断，试试两种情况（默认和忽略）下有何不同。
更方便的是我们可以用在shell中用trap定义我们自己的信号处理程序