路漫漫其修远兮，吾将上下而求索。
‘s / \ . $ / / g’ 删除以句点结尾行
‘-e /abcd/d’ 删除包含a b c d的行
‘s / [ ] [ ] [ ] * / [ ] / g’ 删除一个以上空格，用一个空格代替
‘s / ^ [ ] [ ] * / / g’ 删除行首空格
‘s / \ . [ ] [ ] * / [ ] / g’ 删除句点后跟两个或更多空格，代之以一个空格
‘/ ^ $ / d’ 删除空行
‘s / ^ . / / g’ 删除第一个字符
‘s /CO L \ ( . . . \ ) / / g’ 删除紧跟C O L的后三个字母
‘s / ^ \ / / / g’ 从路径中删除第一个\
‘s / [ ] / [ ] / / g’ 删除所有空格并用t a b键替代
‘S / ^ [ ] / / g’ 删除行首所有t a b键
‘s / [ ] * / / g’ 删除所有t a b键
Vim，即Vi IMproved，是一个Vi的增强版，Linux下最为常用的编辑器之一。然而，它强大的功能是它不仅仅是一个编辑器。 花点时间学习一下Vim的使用，可以事半功倍。随着使用，就会发现Vim的强大。 Vim高级编辑要用到正则表达式的各种技巧，先简单介绍基本的原字符集及其含义： ^ --只匹配行首$ --只匹配行尾* --匹配0个或多个单字符[] --匹配[]内字符，可以是一个单字符，也可以是字符序列，可是用-表示[]内字符序列范围， 如用[1-5]表示[12345]。. --匹配任意单字符^$ --匹配空行 在vi中也可以使用这些正则表达式。它也有它自己的语法格式，不过匹配方式类似，比较一下很容易看出。下面给出几个常用的操作： 1、把文件内容反转，第一行成为最后一行，第二行成为倒数第二行，以此类推 :g/^/m02、在整个文件中替换特定字符串 :%s/原文件的内容/替换成的内容/g 例如：去掉文件中的"^M"等控制符 :1,$s/^M//g (或者:%s/^M//g)3、在每一行文本前加同样的字符 :%s/^/要加的内容/g4、在每一行文本后加同样的字符 :%s/$/要加的内容/g5、在第2行行首加入内容 :2s/^/要加的内容/g6、在第1，2行行首加入内容 :1,2s/^/要加的内容/g7、删除第1，2行行首的内容 :1,2s/^要删除的内容/g8、删除第2行行尾的内容 :2s/要删除的内容$/g9、删除第5行包含的字符串 :5s/要删除的字符串/g10、删除从当前行开始到最后一行的所有内容 :[dot][comma]$d【注意，冒号后面紧跟“点”（表示当前行），然后跟一个“逗号”，加“$”（表示最后一行），d表示删除。】 这些技巧要总结规律性，而且要在每天操作时使用，熟悉得成为手指的本能。只是看是不可能学会的。正如林锐博士所言，学了不一定懂了，懂了不一定会用。勤加练习！ 使用vi进行文本操作的技巧 1、基本操作 dd 删除当前行 ndd 删除当前行以下n行（包括当前行在内） p 粘贴 yy 复制当前行 nyy 复制当前行以下n行（包括当前行在内） dd和ndd也可以认为是“剪切”。 2、技巧 :n,m co k 复制n到m行，粘贴到k行处（从下一行开始） :n,m m k 剪切n到m行，粘贴到k行处（从下一行开始） :n,m d 删除n到m行 注意的是，m必须大于n，而且m、n、k都在正文行号之内。比如说，如果文件有10行，而你的操作中出现了11，就会出现错误。m可以用特殊符号$，代表到结尾处。 如果要处理的文本比较多，那么可以采用标号的方法。具体如下： 光标移到起始行，输入ma
光标移到结束行，输入mb
光标移到粘贴行，输入mc 然后 :'a,'b co 'c，就实现了复制粘贴。如果把co改为m，就实现了剪切粘贴。
1、查找定位技巧 在C语言基础训练中，往往会借鉴Linux源代码，于是少不了查找。Windows下面有sourceinsight，Linux也有相应的工具。但是，如果仅仅是查找一个宏的定义方式，比如ARRAY_SIZE，则只需要一行shell命令就可以了。举
例如下： [armlinux@lqm interview]$ find /usr/include -name "*.h" | xargs grep -n "[[:blank:]]ARRAY_SIZE"
/usr/include/libiberty.h:327:#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
[armlinux@lqm interview]$ 或者 [armlinux@lqm interview]$ find /usr/include -name "*.h" | xargs grep -n "\<ARRAY_SIZE"
/usr/include/libiberty.h:327:#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
[armlinux@lqm interview]$ 这样的定位信息还是比较准确的，不过对于匹配模式需要精心设计。 这里有两个比较好的习惯。
（1）find和xargs组合使用。 使用xargs工具作为筛选器，可以充分利用从find命令挑选的输出。find运行通常提供与某些条件匹配的文件列表。此列表被传递到xargs上，后者然后使用该文件列表作为参数来运行其他某些有用的命令。这与不使用xargs是完全不同的。 （2）停止对cat使用管道。 grep的一个常见的基本用法错误就是通过管道将cat的输出发送到grep以搜索单个文件的内容。这绝对是不必要的，纯粹是浪费时间，因为诸如grep这样的工具接受文件名作为参数。您根本不需要在这种情况下使用cat。 这两个习惯是《Unix高手的10个习惯》中的。我以前犯过第二个错误，就是使用了cat然后grep，现在的这行shell操作则纠正了这个错误，效率上也有所提高。另外，还使用了grep的-n选项，实现了对匹配行的准确定位。以后在查找中就方便多了。
一、概述
我们通过Shell可以实现简单的控制流功能，如：循环、判断等。但是对于需要交互的场合则必须通过人工来干预，有时候我们可能会需要实现和交互程序如telnet服务器等进行交互的功能。而Expect就使用来实现这种功能的工具。
Expect是一个免费的编程工具语言，用来实现自动和交互式任务进行通信，而无需人的干预。Expect的作者Don Libes在1990年开始编写Expect时对Expect做有如下定义：Expect是一个用来实现自动交互功能的软件套件(Expect [is a] software suite for automating interactive tools)。使用它系统管理员的可以创建脚本用来实现对命令或程序提供输入，而这些命令和程序是期望从终端（terminal）得到输入，一般来说这些 输入都需要手工输入进行的。Expect则可以根据程序的提示模拟标准输入提供给程序需要的输入来实现交互程序执行。甚至可以实现实现简单的BBS聊天机 器人。
Expect是不断发展的，随着时间的流逝，其功能越来越强大，已经成为系统管理员的的一个强大助手。Expect需要Tcl编程语言的支持，要在系统上运行Expect必须首先安装Tcl。
二、Expect工作原理
从最简单的层次来说，Expect的工作方式象一个通用化的Chat脚本工具。Chat脚本最早用于UUCP网络内，以用来实现计算机之间需要建立连接时进行特定的登录会话的自动化。
Chat脚本由一系列expect-send对组成：expect等待输出中输出特定的字符，通常是一个提示符，然后发送特定的响应。例如下面的 Chat脚本实现等待标准输出出现Login:字符串，然后发送somebody作为用户名；然后等待Password:提示符，并发出响应 sillyme。
引用：Login: somebody Password: sillyme
这个脚本用来实现一个登录过程，并用特定的用户名和密码实现登录。
Expect最简单的脚本操作模式本质上和Chat脚本工作模式是一样的。
例子：
1、实现功能
下面我们分析一个响应chsh命令的脚本。我们首先回顾一下这个交互命令的格式。假设我们要为用户chavez改变登录脚本，要求实现的命令交互过程如下：
引用：# chsh chavez
Changing the login shell for chavez
Enter the new value, or press return for the default
Login Shell [/bin/bash]: /bin/tcsh
#
可以看到该命令首先输出若干行提示信息并且提示输入用户新的登录shell。我们必须在提示信息后面输入用户的登录shell或者直接回车不修改登录shell。
2、下面是一个能用来实现自动执行该命令的Expect脚本：
#!/usr/bin/expect
# Change a login shell to tcsh
set user [lindex $argv 0]
spawn chsh $user
expect “]:”
send “/bin/tcsh ”
expect eof
exit
这个简单的脚本可以解释很多Expect程序的特性。和其他脚本一样首行指定用来执行该脚本的命令程序，这里是/usr/bin/expect。程序第一行用来获得脚本的执行参数(其保存在数组$argv中，从0号开始是参数)，并将其保存到变量user中。
第二个参数使用Expect的spawn命令来启动脚本和命令的会话，这里启动的是chsh命令，实际上命令是以衍生子进程的方式来运行的。
随后的expect和send命令用来实现交互过程。脚本首先等待输出中出现]:字符串，一旦在输出中出现chsh输出到的特征字符串(一般特征字 符串往往是等待输入的最后的提示符的特征信息)。对于其他不匹配的信息则会完全忽略。当脚本得到特征字符串时，expect将发送/bin/tcsh和一 个回车符给chsh命令。最后脚本等待命令退出(chsh结束)，一旦接收到标识子进程已经结束的eof字符，expect脚本也就退出结束。
3、决定如何响应
管理员往往有这样的需求，希望根据当前的具体情况来以不同的方式对一个命令进行响应。我们可以通过后面的例子看到expect可以实现非常复杂的条件响应，而仅仅通过简单的修改预处理脚本就可以实现。下面的例子是一个更复杂的expect-send例子：
expect -re “\[(.*)]:”
if {$expect_out(1,string)!=”/bin/tcsh”} {
send “/bin/tcsh” }
send ” ”
expect eof
在 这个例子中，第一个expect命令现在使用了-re参数，这个参数表示指定的的字符串是一个正则表达式，而不是一个普通的字符串。对于上面这个例子里是 查找一个左方括号字符(其必须进行三次逃逸(escape)，因此有三个符号，因为它对于expect和正则表达时来说都是特殊字符)后面跟有零个或多个 字符，最后是一个右方括号字符。这里.*表示表示一个或多个任意字符，将其存放在()中是因为将匹配结果存放在一个变量中以实现随后的对匹配结果的访问。
当发现一个匹配则检查包含在[]中的字符串，查看是否为/bin/tcsh。如果不是则发送/bin/tcsh给chsh命令作为输入，如果是则仅仅发送一个回车符。这个简单的针对具体情况发出不同相响应的小例子说明了expect的强大功能。
在一个正则表达时中，可以在()中包含若干个部分并通过expect_out数组访问它们。各个部分在表达式中从左到右进行编码，从1开始(0包含有整个匹配输出)。()可能会出现嵌套情况，这这种情况下编码从最内层到最外层来进行的。
4、使用超时
下一个expect例子中将阐述具有超时功能的提示符函数。这个脚本提示用户输入，如果在给定的时间内没有输入，则会超时并返回一个默认的响应。这个脚本接收三个参数：提示符字串，默认响应和超时时间(秒)。
#!/usr/bin/expect
# Prompt function with timeout and default.
set prompt [lindex $argv 0]
set def [lindex $argv 1]
set response $def
set tout [lindex $argv 2]
脚本的第一部分首先是得到运行参数并将其保存到内部变量中。
send_tty “$prompt: ”
set timeout $tout
expect ” ” {
set raw $expect_out(buffer)
# remove final carriage return
set response [string trimright “$raw” ” “]
}
if {”$response” == “} {set response $def}
send “$response ”
# Prompt function with timeout and default.
set prompt [lindex $argv 0]
set def [lindex $argv 1]
set response $def
set tout [lindex $argv 2]
这是脚本其余的内容。可以看到send_tty命令用来实现在终端上显示提示符字串和一个冒号及空格。set timeout命令设置后面所有的expect命令的等待响应的超时时间为$tout(-l参数用来关闭任何超时设置)。
然后expect命令就等待输出中出现回车字符。如果在超时之前得到回车符，那么set命令就会将用户输入的内容赋值给变脸raw。随后的命令将用户输入内容最后的回车符号去除以后赋值给变量response。
然后，如果response中内容为空则将response值置为默认值(如果用户在超时以后没有输入或者用户仅仅输入了回车符)。最后send命令将response变量的值加上回车符发送给标准输出。
一个有趣的事情是该脚本没有使用spawn命令。 该expect脚本会与任何调用该脚本的进程交互。
如果该脚本名为prompt，那么它可以用在任何C风格的shell中。
% set a=’prompt “Enter an answer” silence 10′
Enter an answer: test
% echo Answer was “$a”
Answer was test
prompt设定的超时为10秒。如果超时或者用户仅仅输入了回车符号，echo命令将输出
Answer was “silence”
5、一个更复杂的例子
下面我们将讨论一个更加复杂的expect脚本例子，这个脚本使用了一些更复杂的控制结构和很多复杂的交互过程。这个例子用来实现发送write命令给任意的用户，发送的消息来自于一个文件或者来自于键盘输入。
#!/usr/bin/expect
# Write to multiple users from a prepared file
# or a message input interactively
if {$argc<2} {
send_user "usage: $argv0 file user1 user2 ... "
exit
}
send_user命令用来显示使用帮助信息到父进程(一般为用户的shell)的标准输出。
set nofile 0
# get filename via the Tcl lindex function
set file [lindex $argv 0]
if {$file=="i"} {
set nofile 1
} else {
# make sure message file exists
if {[file isfile $file]!=1} {
send_user "$argv0: file $file not found. "
exit }}
这部分实现处理脚本启动参数，其必须是一个储存要发送的消息的文件名或表示使用交互输入得到发送消的内容的"i"命令。
变量file被设置为脚本的第一个参数的值，是通过一个Tcl函数lindex来实现的，该函数从列表/数组得到一个特定的元素。[]用来实现将函数lindex的返回值作为set命令的参数。
如果脚本的第一个参数是小写的"i"，那么变量nofile被设置为1，否则通过调用Tcl的函数isfile来验证参数指定的文件存在，如果不存在就报错退出。
可以看到这里使用了if命令来实现逻辑判断功能。该命令后面直接跟判断条件，并且执行在判断条件后的{}内的命令。if条件为false时则运行else后的程序块。
set procs {}
# start write processes
for {set i 1} {$i<$argc}
{incr i} {
spawn -noecho write
[lindex $argv $i]
lappend procs $spawn_id
}
最后一部分使用spawn命令来启动write进程实现向用户发送消息。这里使用了for命令来实现循环控制功能，循环变量首先设置为1，然后因此 递增。循环体是最后的{}的内容。这里我们是用脚本的第二个和随后的参数来spawn一个write命令，并将每个参数作为发送消息的用户名。 lappend命令使用保存每个spawn的进程的进程ID号的内部变量$spawn_id在变量procs中构造了一个进程ID号列表。
if {$nofile==0} {
setmesg [open "$file" "r"]
} else {
send_user "enter message,
ending with ^D: " }
最后脚本根据变量nofile的值实现打开消息文件或者提示用户输入要发送的消息。
set timeout -1
while 1 {
if {$nofile==0} {
if {[gets $mesg chars] == -1} break
set line "$chars "
} else {
expect_user {
-re " " {}
eof break }
set line $expect_out(buffer) }
foreach spawn_id $procs {
send $line }
sleep 1}
exit
上面这段代码说明了实际的消息文本是如何通过无限循环while被发送的。while循环中的 if判断消息是如何得到的。在非交互模式下，下一行内容从消息文件中读出，当文件内容结束时while循环也就结束了。(break命令实现终止循环) 。
在交互模式下，expect_user命令从用户接收消息，当用户输入ctrl+D时结束输入，循环同时结束。 两种情况下变量$line都被用来保存下一行消息内容。当是消息文件时，回车会被附加到消息的尾部。
foreach循环遍历spawn的所有进程，这些进程的ID号都保存在列表变量$procs中，实现分别和各个进程通信。send命令组成了 foreach的循环体，发送一行消息到当前的write进程。while循环的最后是一个sleep命令，主要是用于处理非交互模式情况下，以确保消息 不会太快的发送给各个write进程。当while循环退出时，expect脚本结束。
三、参考资源
Expect软件版本深带有很多例子脚本，不但可以用于学习和理解expect脚本，而且是非常使用的工具。一般可以在 /usr/doc/packages/expect/example看到它们，在某些linux发布中有些expect脚本保存在/usr/bin目录 下。
Don Libes, Exploring Expect, O'Reilly & Associates, 1995.
John Ousterhout, Tcl and the Tk Toolkit, Addison-Wesley, 1994.
一些有用的expect脚本
autoexpect:这个脚本将根据自身在运行时用户的操作而生成一个expect脚本。它的功能某种程度上类似于在Emacs编辑器的键盘宏工具。一个自动创建的脚本可能是创建自己定制脚本的好的开始。
kibitz:这是一个非常有用的工具。通过它两个或更多的用户可以连接到同一个shell进程。
tkpasswd: 这个脚本提供了修改用户密码的GUI工具，包括可以检查密码是否是基于字典模式。这个工具同时是一个学习expect和tk的好实例。Powered by ScribeFire.
使用 sed 编辑器
作者：Emmett Dulaney
sed 编辑器是 Linux 系统管理员的工具包中最有用的资产之一，
因此，有必要彻底地了解其应用
Linux 操作系统最大的一个好处是它带有各种各样的实用工具。存在如此之多不同的实用工具，几乎不可能知道并了解所有这些工具。可以简化关键情况下操作的一个实用工具是 sed。它是任何管理员的工具包中最强大的工具之一，并且可以证明它自己在关键情况下非常有价值。
sed 实用工具是一个“编辑器”，但它与其它大多数编辑器不同。除了不面向屏幕之外，它还是非交互式的。这意味着您必须将要对数据执行的命令插入到命令行或要处 理的脚本中。当显示它时，请忘记您在使用 Microsoft Word 或其它大多数编辑器时拥有的交互式编辑文件功能。sed 在一个文件（或文件集）中非交互式、并且不加询问地接收一系列的命令并执行它们。因而，它流经文本就如同水流经溪流一样，因而 sed 恰当地代表了流编辑器。 它可以用来将所有出现的 "Mr. Smyth" 修改为 "Mr. Smith"，或将 "tiger cub" 修改为 "wolf cub"。流编辑器非常适合于执行重复的编辑，这种重复编辑如果由人工完成将花费大量的时间。其参数可能和一次性使用一个简单的操作所需的参数一样有限， 或者和一个具有成千上万行要进行编辑修改的脚本文件一样复杂。sed 是 Linux 和 UNIX 工具箱中最有用的工具之一，且使用的参数非常少。
sed 的工作方式
sed 实用工具按顺序逐行将文件读入到内存中。然后，它执行为该行指定的所有操作，并在完成请求的修改之后将该行放回到内存中，以将其转储至终端。完成了这一行 上的所有操作之后，它读取文件的下一行，然后重复该过程直到它完成该文件。如同前面所提到的，默认输出是将每一行的内容输出到屏幕上。在这里，开始涉及到 两个重要的因素—首先，输出可以被重定向到另一文件中，以保存变化；第二，源文件（默认地）保持不被修改。sed 默认读取整个文件并对其中的每一行进行修改。不过，可以按需要将操作限制在指定的行上。
该实用工具的语法为：
sed [options] '{command}' [filename]
在这篇文章中，我们将浏览最常用的命令和选项，并演示它们如何工作，以及它们适于在何处使用。
替换命令
sed 实用工具以及其它任何类似的编辑器的最常用的命令之一是用一个值替换另一个值。用来实现这一目的的操作的命令部分语法是：
's/{old value}/{new value}/'
因而，下面演示了如何非常简单地将 "tiger" 修改为 "wolf"：
$ echo The tiger cubs will meet on Tuesday after school | sed 's/tiger/wolf/'The wolf cubs will meet on Tuesday after school$
注意如果输入是源自之前的命令输出，则不需要指定文件名—同样的原则也适用于 awk、sort 和其它大多数 Linux\UNIX 命令行实用工具程序。
多次修改
如果需要对同一文件或行作多次修改，可以有三种方法来实现它。第一种是使用 "-e" 选项，它通知程序使用了多条编辑命令。例如：
$ echo The tiger cubs will meet on Tuesday after school | sed -e 's/tiger/wolf/' -e 's/after/before/'The wolf cubs will meet on Tuesday before school$
这是实现它的非常复杂的方法，因此 "-e" 选项不常被大范围使用。更好的方法是用分号来分隔命令：
$ echo The tiger cubs will meet on Tuesday after school | sed 's/tiger/wolf/; s/after/before/'The wolf cubs will meet on Tuesday before school $
注 意分号必须是紧跟斜线之后的下一个字符。如果两者之间有一个空格，操作将不能成功完成，并返回一条错误消息。这两种方法都很好，但许多管理员更喜欢另一种 方法。要注意的一个关键问题是，两个撇号 (' ') 之间的全部内容都被解释为 sed 命令。直到您输入了第二个撇号，读入这些命令的 shell 程序才会认为您完成了输入。这意味着可以在多行上输入命令—同时 Linux 将提示符从 PS1 变为一个延续提示符（通常为 ">"）—直到输入了第二个撇号。一旦输入了第二个撇号，并且按下了 Enter 键，则处理就进行并产生相同的结果，如下所示：
$ echo The tiger cubs will meet on Tuesday after school | sed '> s/tiger/wolf/> s/after/before/'The wolf cubs will meet on Tuesday before school$
全局修改
让我们开始一次看似简单的编辑。假定在要修改的消息中出现了多次要修改的项目。默认方式下，结果可能和预期的有所不同，如下所示：
$ echo The tiger cubs will meet this Tuesday at the same timeas the meeting last Tuesday | sed 's/Tuesday/Thursday/'The tiger cubs will meet this Thursday at the same timeas the meeting last Tuesday $
与 将出现的每个 "Tuesday" 修改为 "Thursday" 相反，sed 编辑器在找到一个要修改的项目并作了修改之后继续处理下一行，而不读整行。sed 命令功能大体上类似于替换命令，这意味着它们都处理每一行中出现的第一个选定序列。为了替换出现的每一个项目，在同一行中出现多个要替换的项目的情况下， 您必须指定在全局进行该操作：
$ echo The tiger cubs will meet this Tuesday at the same timeas the meeting last Tuesday | sed 's/Tuesday/Thursday/g'The tiger cubs will meet this Thursday at the same timeas the meeting last Thursday$
请记住不管您要查找的序列是否仅包含一个字符或词组，这种对全局化的要求都是必需的。
sed 还可以用来修改记录字段分隔符。例如，以下命令将把所有的 tab 修改为空格：
sed 's/ / /g'
其 中，第一组斜线之间的项目是一个 tab，而第二组斜线之间的项目是一个空格。作为一条通用的规则，sed 可以用来将任意的可打印字符修改为任意其它的可打印字符。如果您想将不可打印字符修改为可打印字符—例如，铃铛修改为单词 "bell"—sed 不是适于完成这项工作的工具（但 tr 是）。
有时，您不想修改在一个文件中出现的所有指定项目。有时，您只想在满足某些条件时才作修改—例如，在与其它一些数据匹配之后才作修改。为了说明这一点，请考虑以下文本文件：
$ cat sample_oneone 1two 1three 1one 1two 1two 1three 1$
假定希望用 "2" 来替换 "1"，但仅在单词 "two" 之后才作替换，而不是每一行的所有位置。通过指定在给出替换命令之前必须存在一次匹配，可以实现这一点：
$ sed '/two/ s/1/2/' sample_oneone 1two 2three 1one 1two 2two 2three 1$
现在，使其更加准确：
$ sed '> /two/ s/1/2/> /three/ s/1/3/' sample_oneone 1two 2three 3one 1two 2two 2three 3$
请 再次记住唯一改变了的是显示。如果您查看源文件，您将发现它始终保持不变。您必须将输出保存至另一个文件，以实现永久保存。值得重复的是，不对源文件作修 改实际是祸中有福—它让您能够对文件进行试验而不会造成任何实际的损害，直到让正确命令以您预期和希望的方式进行工作。
以下命令将修改后的输出保存至一个新的文件：
$ sed '> /two/ s/1/2/> /three/ s/1/3/' sample_one > sample_two
该输出文件将所有修改合并在其中，并且这些修改通常将在屏幕上显示。现在可以用 head、cat 或任意其它类似的实用工具来进行查看。
脚本文件
sed 工具允许您创建一个脚本文件，其中包含从该文件而不是在命令行进行处理的命令，并且 sed 工具通过 "-f" 选项来引用。通过创建一个脚本文件，您能够一次又一次地重复运行相同的操作，并指定比每次希望从命令行进行处理的操作详细得多的操作。
考虑以下脚本文件：
$ cat sedlist/two/ s/1/2//three/ s/1/3/$
现在可以在数据文件上使用脚本文件，获得和我们之前看到的相同的结果：
$ sed -f sedlist sample_oneone 1two 2three 3one 1two 2two 2three 3$
注意当调用 "-f" 选项时，在源文件内或命令行中不使用撇号。脚本文件，也称为源文件，对于想重复多次的操作和从命令行运行可能出错的复杂命令很有价值。编辑源文件并修改一个字符比在命令行中重新输入一条多行的项目要容易得多。
限制行
编辑器默认查看输入到流编辑器中的每一行，且默认在输入到流编辑器中的每一行上进行编辑。这可以通过在发出命令之前指定约束条件来进行修改。例如，只在此示例文件的输出的第 5 和第 6 行中用 "2" 来替换 "1"，命令将为：
$ sed '5,6 s/1/2/' sample_oneone 1two 1three 1one 1two 2two 2three 1$
在这种情况下，因为要修改的行是专门指定的，所以不需要替换命令。因此，您可以灵活地根据匹配准则（可以是行号或一种匹配模式）来选择要修改哪些行（从根本上限制修改）。
禁止显示
sed 默认将来自源文件的每一行显示到屏幕上（或重定向到一个文件中），而无论该行是否受到编辑操作的影响，"-n" 参数覆盖了这一操作。"-n" 覆盖了所有的显示，并且不显示任何一行，而无论它们是否被编辑操作修改。例如：
$ sed -n -f sedlist sample_one$$ sed -n -f sedlist sample_one > sample_two$ cat sample_two$
在 第一个示例中，屏幕上不显示任何东西。在第二个示例中，不修改任何东西，因此不将任何东西写到新的文件中—它最后是空的。这不是否定了编辑的全部目的吗？ 为什么这是有用的？它是有用的仅因为 "-n" 选项能够被一条显示命令 (-p) 覆盖。为了说明这一点，假定现在像下面这样对脚本文件进行了修改：
$ cat sedlist/two/ s/1/2/p/three/ s/1/3/p$
然后下面是运行它的结果：
$ sed -n -f sedlist sample_onetwo 2three 3two 2two 2three 3$
保持不变的行全部不被显示。只有受到编辑操作影响的行被显示了。在这种方式下，可以仅取出这些行，进行修改，然后把它们放到一个单独的文件中：
$ sed -n -f sedlist sample_one > sample_two$$ cat sample_twotwo 2three 3two 2two 2three 3$
利用它的另一种方法是只显示一定数量的行。例如，只显示 2-6 行，同时不做其它的编辑修改：
$ sed -n '2,6p' sample_onetwo 1three 1one 1two 1two 1$
其它所有的行被忽略，只有 2-6 行作为输出显示。这是一项出色的功能，其它任何工具都不能容易地实现。Head 将显示一个文件的顶部，而 tail 将显示一个文件的底部，但 sed 允许从任意位置取出想要的任意内容。
删除行
用一个值替换另一个值远非流编辑器可以执行的唯一功能。它还具有许多的潜在功能，在我看来第二种最常用的功能是删除。删除与替换的工作方式相同，只是它删除指定的行（如果您想要删除一个单词而不是一行，不要考虑删除，而应考虑用空的内容来替换它—s/cat//）。
该命令的语法是：
'{what to find} d'
从 sample_one 文件中删除包含 "two" 的所有行：
$ sed '/two/ d' sample_oneone 1three 1one 1three 1$
从显示屏中删除前三行，而不管它们的内容是什么：
$ sed '1,3 d' sample_oneone 1two 1two 1three 1$
只显示剩下的行，前三行不在显示屏中出现。对于流编辑器，一般当它们涉及到全局表达式时，特别是应用于删除操作时，有几点要记住：
sed '/^two/ d' sample_one
将只删除该行。
sed '/two$/ d' sample_one
将只删除该行。
将这两者结合在一起的结果：
sed '/^$/ d' {filename}
删除文件中的所有空白行。例如，以下命令将 "1" 替换为 "2"，以及将 "1" 替换为 "3"，并删除文件中所有尾随的空行：
$ sed '/two/ s/1/2/; /three/ s/1/3/; /^$/ d' sample_oneone 1two 1three 1one 1two 2two 2three 1$
其通常的用途是删除一个标题。以下命令将删除文件中所有的行，从第一行直到第一个空行：
sed '1,/^$/ d' {filename}
添加和插入文本
可以结合使用 sed 和 "a" 选项将文本添加到一个文件的末尾。实现方法如下：
$ sed '$a\> This is where we stop\> the test' sample_oneone 1two 1three 1one 1two 1two 1three 1This is where we stopthe test$
在该命令中，美元符号 ($) 表示文本将被添加到文件的末尾。反斜线 (\) 是必需的，它表示将插入一个回车符。如果它们被遗漏了，则将导致一个错误，显示该命令是错乱的；在任何要输入回车的地方您必须使用反斜线。
要将这些行添加到第 4 和第 5 个位置而不是末尾，则命令变为：
$ sed '3a\> This is where we stop\> the test' sample_oneone 1two 1three 1This is where we stopthe testone 1two 1two 1three 1$
这将文本添加到第 3 行之后。和几乎所有的编辑器一样，您可以选择插入而不是添加（如果您希望这样的话）。这两者的区别是添加跟在指定的行之后，而插入从指定的行开始。当用插入来代替添加时，只需用 "i" 来代替 "a"，如下所示：
$ sed '3i\> This is where we stop\> the test' sample_oneone 1two 1This is where we stopthe testthree 1one 1two 1two 1three 1$
新的文本出现在输出的中间位置，而处理通常在指定的操作执行以后继续进行。
读写文件
重定向输出的功能已经演示过了，但需要指出的是，在编辑命令运行期间可以同步地读入和写出文件。例如，执行替换，并将 1-3 行写到名称为 sample_three 的文件中：
$ sed '> /two/ s/1/2/> /three/ s/1/3/> 1,3 w sample_three' sample_oneone 1two 2three 3one 1two 2two 2three 3$$ cat sample_threeone 1two 2three 3$
由于为 w (write) 命令指定了 "1,3"，所以只有指定的行被写到了新文件中。无论被写的是哪些行，所有的行都在默认输出中显示。
修改命令
除了替换项目之外，还可以将行从一个值修改为另一个值。要记住的是，替换是对字符逐个进行，而修改功能与删除类似，它影响整行：
$ sed '/two/ c\> We are no longer using two' sample_oneone 1We are no longer using twothree 1one 1We are no longer using twoWe are no longer using twothree 1$
修 改命令与替换的工作方式很相似，但在范围上要更大些—将一个项目完全替换为另一个项目，而无论字符内容或上下文。夸张一点讲，当使用替换时，只有字符 "1" 被字符 "2" 替换，而当使用修改时，原来的整行将被修改。在两种情况下，要寻找的匹配条件都仅为 "two"。
修改全部但……
对于大多数 sed 命令，详细说明各种功能要进行何种修改。利用感叹号，可以在除指定位置之外的任何地方执行修改—与默认的操作完全相反。
例如，要删除包含单词 "two" 的所有行，操作为：
$ sed '/two/ d' sample_oneone 1three 1one 1three 1$
而要删除除包含单词 "two" 的行之外的所有行，则语法变为：
$ sed '/two/ !d' sample_onetwo 1two 1two 1$
如果您有一个文件包含一系列项目，并且想对文件中的每个项目执行一个操作，那么首先对那些项目进行一次智能扫描并考虑将要做什么是很重要的。为了使事情变得更简单，您可以将 sed 与任意迭代例程（for、while、until）结合来实现这一目的。
比如说，假定您有一个名为 "animals" 的文件，其中包含以下项目：
pig
horse
elephant
cow
dog
cat
您希望运行以下例程：
#mcd.kshfor I in $*doecho Old McDonald had a $Iecho E-I, E-I-Odone
结 果将为，每一行都显示在 "Old McDonald has a" 的末尾。虽然对于这些项目的大部分这是正确的，但对于 "elephant" 项目，它有语法错误，因为结果应当为 "an elephant" 而不是 "a elephant"。利用 sed，您可以在来自 shell 文件的输出中检查这种语法错误，并通过首先创建一个命令文件来即时地更正它们：
#sublist/ a a/ s/ a / an // a e/ s/ a / an //a i/ s / a / an //a o/ s/ a / an //a u/ s/ a / an /
然后执行以下过程：
$ sh mcd.ksh 'cat animals' | sed -f sublist
现 在，在运行了 mcd 脚本之后，sed 将在输出中搜索单个字母 a （空格，"a"，空格）之后紧跟了一个元音的任意位置。如果这种位置存在，它将把该序列修改为空格，"an"，空格。这样就使问题更正后才显示在屏幕上， 并确保各处的编辑人员在晚上可以更容易地入睡。结果是：
Old McDonald had a pig
E-I, E-I-O
Old McDonald had a horse
E-I, E-I-O
Old McDonald had an elephant
E-I, E-I-O
Old McDonald had a cow
E-I, E-I-O
Old McDonald had a dog
E-I, E-I-O
Old McDonald had a cat
E-I, E-I-O
提前退出
sed 默认读取整个文件，并只在到达末尾时才停止。不过，您可以使用退出命令提前停止处理。只能指定一条退出命令，而处理将一直持续直到满足调用退出命令的条件。
例如，仅在文件的前五行上执行替换，然后退出：
$ sed '> /two/ s/1/2/> /three/ s/1/3/> 5q' sample_oneone 1two 2three 3one 1two 2$
在退出命令之前的项目可以是一个行号（如上所示），或者一条查找/匹配命令：
$ sed '> /two/ s/1/2/> /three/ s/1/3/> /three/q' sample_oneone 1two 2three 3$
您 还可以使用退出命令来查看超过一定标准数目的行，并增加比 head 中的功能更强的功能。例如，head 命令允许您指定您想要查看一个文件的前多少行—默认数为 10，但可以使用从 1 到 99 的任意一个数字。如果您想查看一个文件的前 110 行，您用 head 不能实现这一目的，但用 sed 可以：
sed 110q filename
处理问题
当使用 sed 时，要记住的重要事项是它的工作方式。它的工作方式是：读入一行，在该行上执行它已知要执行的所有任务，然后继续处理下一行。每一行都受给定的每一个编辑命令的影响。
如果您的操作顺序没有十分彻底地考虑清楚，那么这可能会很麻烦。例如，假定您需要将所有的 "two" 项目修改为 "three"，然后将所有的 "three" 修改为 "four"：
$ sed '> /two/ s/two/three/> /three/ s/three/four/' sample_oneone 1four 1four 1one 1four 1four 1four 1$
最初读取的 "two" 被修改为 "three"。然后它满足为下一次编辑建立的准则，从而变为 "four"。最终的结果不是想要的结果—现在除了 "four" 没有别的项目了，而本来应该有 "three" 和 "four"。
当执行这种操作时，您必须非常用心地注意指定操作的方式，并按某种顺序来安排它们，使得操作之间不会互相影响。例如：
$ sed '> /three/ s/three/four/> /two/ s/two/three/' sample_oneone 1three 1four 1one 1three 1three 1four 1$
这非常有效，因为 "three" 值在 "two" 变成 "three" 之前得到修改。
标签和注释
可以在 sed 脚本文件中放置标签，这样一旦文件变得庞大，可以更容易地说明正在发生的事情。存在各种各样与这些标签相关的命令，它们包括：
:HERE
以冒号开始的标签可以由 "b" 和 "t" 命令处理。
b HERE
将处理发送给行
:HERE
如果紧跟 b 之后没有指定任何标签，则处理转至脚本文件的末尾。
进一步的研究
sed 实用工具是 Linux 管理员拥有的最强大和灵活的工具之一。虽然本文覆盖了许多基础知识，但对于这一具有丰富功能的工具仅是蜻蜓点水。关于更多信息，最好的来源之一是 Dale Dougherty 和 Arnold Robbins 的著作 sed & awk，现在从 O'Reilly & Associates 出版社推出了其第二版（参加“接下来的步骤”）。该出版社还推出了一本可以随身携带的袖珍参考
AWK是Unix平台上一种可以对文本进行逐行处理的编程语言，它来源于3个创作者的名字：Aho、(Peter)Weinberg和(Brain)
Kernighan.与sed和grep很相似，awk是一种样式扫描与处理工具，但其功能却大大强于sed和grep。awk提供了极其强大的功能：它
几乎可以完成grep和sed所能完成的全部工作，同时，它还可以可以进行样式装入、流控制、数学运算符、进程控制语句甚至于内置的变量和函数。awk的
三位创建者已将它正式定义为：样式扫描和处理语言。AWK的调用方式1). 程序体直接写到AWK命令行中，适用较简单的情况awk 'program' input-file1 input-file2 ...2). 程序体写入文件中，用AWK命令调用该文件awk -f program-file input-file1 input-file2 ...3). C shell作为命令解释程序，调用AWK来执行AWK程序,写成的脚本#!/bin/csh -fawk '{ print $8, "\t", $3} \'4). AWK作为命令解释程序，写成的脚本#!/bin/awk -f{ print $8, "\t", $3}AWK的参数说明
awk [ -F re] [parameter...] ['prog'] [-f progfile][in_file...]
参数说明：
-F re: 允许awk更改其字段分隔符。
parameter: 该参数帮助为不同的变量赋值。
'prog': awk的程序语句段。必须用单引号：'和'括起，以防被shell解释。这个程序语句段的标准形式为： 'pattern {action}'
(1) pattern参数是匹配模式，跟Sed命令类似。
(2) action参数总是被大括号包围，由一系统awk语句组成，各语句间用";"分隔。
awk在pattern给定的样式匹配记录上执行其操作。 使用“#”作为注释符。
(3) 可以省略pattern和action之一，但不能两者同时省略，当省略pattern时没
有样式匹配，表示对所有行(记录)均执行操作，省略action时执行缺省的操作—在标准输出上显示。
(4) 可以包含多个pattern {action},如果一个记录满足多个pattern,其对应的action会被执行多次
-f progfile: 允许awk调用执行程序文件。progfile是一文本文件，必须符合awk语法。
in_file: awk的输入文件，awk允许对多个输入文件进行处理。
*awk不修改输入文件。如果未指定输入文件，awk将接受标准输入，并将结果显示在标准输出上。awk支持输入输出重定向。（跟SED类似）AWK的记录(Record)与字段(Field)awk
处理的工作与数据库的处理方式有相同之处，其相同处之一就是awk支持对记录和字段的处理，其中对字段的处理是grep和sed不能实现的。在awk中，
缺省的情况下总是将文本文件中的一行视为一个记录，而将一行中的某一部分作为记录中的一个字段。为了操作这些不同的字段，awk借用shell的方法，用
$1,$2,$3...这样的方式来顺序地表示行（记录）中的不同字段。特殊地，awk用$0表示整个行（记录）。不同的字段之间是用称作分隔符的字符分
隔开的。系统默认的分隔符是空格。awk允许在命令行中用-F
re的形式来改变这个分隔符。事实上，awk用一个内置的变量FS来记忆这个分隔符,可以在程序中进行修改。AWK的运算，判断与赋值运算do-while语句
do
{
语句
}while(条件判断语句）
2.4、for语句
for(初始表达式;终止条件;步长表达式)
{语句}
while、do-while和for语句中允许使用break, continue，exit来控制程序走向。运算符 用途
------------------
x^y x的y次幂
x**y 同上
x%y 计算x/y的余数（求模）
x+y x加y
x-y x减y
x*y x乘y
x/y x除y
-y 负y(y的开关符号);也称一目减
++y y加1后使用y(前置加）
y++ 使用y值后加1（后缀加）
--y y减1后使用y(前置减）
y-- 使用后y减1(后缀减）
x=y 将y的值赋给x
x+=y 将x+y的值赋给x
x-=y 将x-y的值赋给x
x*=y x*y的值赋给x
x/=y 将x/y的值赋给x x%=y 将x%y的值赋给x
x^=y 将x^y的值赋给x
x**=y 将x**y的值赋给x
判断：
操作符 含义
x==y x等于y
x!=y x不等于y
x>y x大于y
x>=y x大于或等于y
x
x<=y x小于或等于y?
x~re x匹配正则表达式re?
x!~re x不匹配正则表达式re?
赋值 (按优先级升序排列)
= 、+=、 -=、 *= 、/= 、 %=
|| &&
> >= < <= == != ~ !~
xy (字符串连结，'x''y'变成"xy"）
+ -
* / %
++ - - AWK的流程控制1、BEGIN和END:
在awk
中两个特别的表达式，BEGIN和END，这两者都可用于pattern中，提供BEGIN和END的作用是给程序赋予初始状态和在程序结束之后执行一些
扫尾的工作。任何在BEGIN之后列出的操作（在{}内）将在awk开始扫描输入之前执行，而END之后列出的操作将在扫描完所有输入之后执行。因此，通
常用BEGIN来显示变量和预置（初始化）变量，用END来输出最终结果。 例：累计销售文件xs中的销售金额（假设销售金额在记录的第三字段）：
$awk
>'BEGIN { FS=":";print "统计销售金额";total=0}
>{print $3;total=total+$3;}
>END {printf "销售金额总计：%.2f",total}' sx
>是shell提供的第二提示符，如要在shell程序awk语句和awk语言中换行，在行尾加反斜杠\
在这里，BEGIN预置了内部变量FS（字段分隔符）和自定义变量total,同时在扫描之前显示出输出行头。而END则在扫描完成后打印出总合计。
2、流程控制语句
2.1、if...else语句:
if(表达式)
语句1
else
语句2
格式中"语句1"可以是多个语句，如果你为了方便awk判断也方便你自已阅读，你最好将多个语句用{}括起来。awk分枝结构允许嵌套。
2.2、while语句
while(表达式、Break：中断当前正在执行的循环并跳到循环外执行下一条语句。Continue：从当前位置跳到循环开始处执行。Exit：当exit语句不在END中时，该命令表现得如同到了文件尾，所有模式或操作将停止，END模式中的操作被执行。而出现在END中的exit将导致程序终止。AWK的变量awk
提供两种变量，一种是awk内置的变量，在awk程序中引用内置变量不需要使用标志符"$"awk提供的另一种变量是自定义变量。当然这种变量不能与内置
变量及其它awk保留字相同，在awk中引用自定义变量必须在它前面加上标志符"$"。与C语言不同的是，awk中不需要对变量进行初始化，awk根据其
在awk中第一次出现的形式和上下文确定其具体的数据类型。当变量类型不确定时，awk默认其为字符串类型。这里有一个技巧：如果你要让你的awk程序知
道你所使用的变量的明确类型，你应当在在程序中给它赋初值。 AWK中的函数
AWK的函数同样包括内置函数和用户自定义的函数。原始的awk不提供函数功能，只有在nawk或较新的awk版本中才可以增加函数。
函数的使用包含两部分：函数的定义与函数调用。其中函数定义又包括要执行的代码（函数本身）和从主程序代码传递到该函数的临时调用。
awk函数的定义方法如下：
function 函数名(参数表){
函数体
}
函数名必须是一个合法的标志符，参数表中可以不提供参数（但在调用函数时函数名后的一对括号仍然是不可缺少的），也可以提供一个或多个参数。awk的参数也是通过值来传递的。
在awk
中调用函数比较简单，其方法与C语言相似，但awk比C语言更为灵活，它不执行参数有效性检查。换句话说，在你调用函数时，可以列出比函数预计（函数定义
中规定）的多或少的参数，多余的参数会被awk所忽略，而不足的参数，awk将它们置为缺省值0或空字符串，具体置为何值，将取决于参数的使用方式。
awk函数有两种返回方式：隐式返回和显式返回。当awk执行到函数的结尾时，它自动地返回到调用程序，这是函数是隐式返回的。如果需要在结束之前退出函数，可以明确地使用返回语句提前退出。方法是在函数中使用形如：return 返回值 格式的语句。例：下面的例子演示了函数的使用。
nawk
>'BEGIN{pageno=1;file=FILENAME
>pageno=print_header(file，pageno)；span lang="EN-US">#调用函数print_header
>printf("当前页页号是：%d\n",pageno);
}
#定义函数print_header
function print_header(FileName,PageNum){
printf("%s %d\n",FileName,PageNum); >PageNum++;return PageNUm;
}
}' myfileAWK的内置变量（预定义变量） 一些例子:
说明：表中v项表示第一个支持变量的工具：A=awk，N=nawk,P=POSIX awk,G=gawk
V 变量 含义 缺省值
--------------------------------------------------------
N ARGC 命令行参数个数
G ARGIND 当前被处理文件的ARGV标志符
N ARGV 命令行参数数组
G CONVFMT 数字转换格式 %.6g
P ENVIRON UNIX环境变量
N ERRNO UNIX系统错误消息
G FIELDWIDTHS 输入字段宽度的空白分隔字符串
A FILENAME 当前输入文件的名字
P FNR 当前记录数
A FS 输入字段分隔符 空格
G IGNORECASE 控制大小写敏感0（大小写敏感）
A NF 当前记录中的字段个数
A NR 已经读出的记录数
A OFMT 数字的输出格式 %.6g
A OFS 输出字段分隔符 空格
A ORS 输出的记录分隔符 新行
A RS 输入的记录他隔符 新行
N RSTART 被匹配函数匹配的字符串首
N RLENGTH 被匹配函数匹配的字符串长度
N SUBSEP 下标分隔符 "\034"
AWK的内置函数
V 函数 用途或返回值
------------------------------------------------
N gsub(reg,string,target) 每次常规表达式reg匹配时替换target中的string
N index(search,string) 返回string中search串的位置
A length(string) 求串string中的字符个数
N match(string,reg) 返回常规表达式reg匹配的string中的位置
N printf(format,variable) 格式化输出，按format提供的格式输出变量variable。
N split(string,store,delim) 根据分界符delim,分解string为store的数组元素
N sprintf(format,variable) 返回包含基于format的格式化数据，variables是要放到串中的数据
G strftime(format,timestamp) 返回format日期或时间串，timestmp是systime()函数返回的时间
N sub(reg,string,target) 第一次当常规表达式reg匹配，替换target串中的字符串
A substr(string,position,len) 返回一个以position开始len个字符的子串
P totower(string) 返回string中对应的小写字符
P toupper(string) 返回string中对应的大写字符
A atan(x,y) x的余切
N cos(x) x的余弦(弧度)
A exp(x) e的x幂
A int(x) x的整数部分
A log(x) x的自然对数值
N rand() 0-1之间的随机数
N sin(x) x的正弦(弧度)
A sqrt(x) x的平方根
A srand(x) 初始化随机数发生器。如果忽略x，则使用system()
G system() 返回自1970年1月1日以来经过的时间（按秒计算）
<!--[if !supportLists]-->1. 打印11月被修改的文件的字节数
ls –lg | awk ‘$6 == “NOV” {sum += $5} END {print sum}’
2. 文件result中包含FAILED的行数
awk ‘/FAILED/ {sum += 1} END {print sum}’ result
3. 打印file文件最长行的长度
awk ‘if (length($0) > max) max = length($0)} END {print max}’ file
4. 输出file文件的行数
awk ‘END {print NR} file
NR是内置变量,表示已经读出的记录数,在END后输出即是总行数
用cat file | wc –l 命令组合可以完成同样的功能
