首页 > 程序脚本 > shell

screen命令想必linuxer都知道并用过,对于那些想要放在前台跑又不想在terminal关掉的时候退出的应用很有用,最近wenzi就遇到一个新需求,我在用aws的cloud-config配置服务器自启动执行脚本的时候,希望在机器初始化之后,紧接着就跑一个脚本。

而且这个脚本我又不想使用nohup的方式跑,于是乎我就想到了screen,经过查看manpage,果然找到了好办法,既能使用screen多次连接的功能,又可以用screen命令直接运行命令并自动退出会话 继续阅读→

阅读全文

这次我们来讨论一下变量的求值运算。变量求值运算的结果取决于该变量的值是null还是一个数值。shell的这个特性被称为参数替换。Bourne shell也有这个特性。变量求值运算的一般形式为:

${<var>:<opt><stg>}

上式中,<var>表示一个变量,后面跟一个冒号(:),冒号后面的<opt>是可选项,它是+、-、=、?四个符号中的任一个;符号后面又跟一个字符串<stg>。除了一种例外情况外,参数替换不会改变变量本身的值,但会影响变量的求值运算结果。变量的求值运算有四种方式:

+可选项

这种方式下,如果变量var已经定义且是一个非空字符串,则对变量var的求值运算结果为stg。常利用这个可选项,当变量值为非空时,把命令的结果赋给这个变量,并回显一个消息:

如果ls命令找不到任何文件,则它不会回显任何消息,在这种情况下,变量found为一个空值。当然当ls命令至少找到一个文件时,则回显”This directory is not empty”信息。 继续阅读→

阅读全文

前几天逛51cto,看到一篇《Linux 基本系统初始化脚本第一版》的文章,颇受启发,同时该脚本也正是我最近想要实现的,本着开源的精神加上对作者的负责,先将自己改版后的放出,也希望能借此带个更多人不同的思路。

蚊子本版改动也不是很大,加入了几个我常用的,软件更新很快的yum源,及epel源。

脚本如下

继续阅读→

阅读全文

最近蚊子把公司的台式机装上了ubuntu,从此开始了linux做桌面环境的旅程。很多以前windows下的习惯要有所改变呢。而且很多顺手的软件也要抛弃了。比如securtcrt。

不过,linux自己本身就带ssh的client端,所以,干脆就自己打造一个和这个类似呗。

securtcrt也是支持expect,我何不自己用expect也打造一个。于是利用下午的一点时间写了一组脚本。用来实现自动登录。

这组脚本由三个文件组成。一个配置文件,一个shell文件,一个expect文件

配置文件用来登记服务器别名,ip地址,用户名和密码。

shell文件用来读取配置文件中的内容

expect文件用来完成自动登录的功能。具体代码如下面所示。
继续阅读→

阅读全文

晚上没事,用shell写了个递归遍历目录的脚本,本脚本实现递归遍历指定目录,打印目录下的文件名(全路径)。不为别的,就为了以后用着方便。

阅读全文

作为运维人员来讲,当程序员对程序有了更新或修改后,发布新版程序是在所难免的,既然要发布备份就更是关键的一步了,当然如果只有一台web或者只改动零星的几个文件,那备份起来还算容易。

但如果web是一组集群,十几台或者几十台,更新的文件很多,而且分放在不同的目录下,如果只靠人为更新,那工作量就很大了,而且还很容易出错,下面蚊子就分享一下自己写出来的备份更新脚本,有需要的朋友请根据自己的环境自行更改。

简单介绍一下我的脚本,首先我的web主目录是放在/data/wwwroot下,更新文件是一个zip的压缩包,放在/tmp/update/目录下,包中的内容我会要求程序员严格按照web主目录下的结构存放,便于脚步自动执行。

脚本会先把包中的所有文件在web主目录下遍历并拷贝到/data/backuup下对应的目录结构下,都拷贝完毕,会将/data/backup目录下的所有内容压缩打包,然后将新程序覆盖web主目录下对应的文件。

备份文件名是由backup_当前日期_系统生成的随机数.tar.gz组成,之所以有随机数是防止一天之中有多次更新。备份压缩包中的目录文件结构也同样严格符合原文件目录结构。这样,如果发现问题,可以直接执行 tar –zxvf 备份文件 –C / 来进行恢复,相当的方便。

脚本使用方法:/paht/to/此脚本 /path/to/packet,包文件请使用全路径。此脚本还有不完善的地方,欢迎高手指正

阅读全文

阅读全文

蚊子最近一直在思考如何能更好的提高自己的运维效率,真正的实现无人干预或很少精力干预就完成希望的任务,目前蚊子面临的问题就是如何能快速高效准确的更新网站code,使用cfengine确实可以实现我想要达到的效果,但毕竟还得每台机器都进行cfengine的安装。关于cfengine可以看我之前的3篇文章,《cfengine学习笔记01》,《cfengine学习笔记02》,《cfengine学习笔记03》。

这两天在CU的shell讨论区闲逛,发现有人在讨论expect的问题,大概看了一下大家的问题和一些例子,发现expect脚本可以实现自动人机交互的工作,反正一些诸如自动登录等功能,当然这只是expect最基本的功能,但对蚊子来讲已经足够了。

网上关于expect的详细的文档真的不是很多,不过还不错,让我在CU里发现了下面这篇别人翻译好的文章,特分享给有需要的人。

[版权声明] 
  
Copyright(c) 1999 
  
本教程由*葫芦娃*翻译,并做了适当的修改,可以自由的用于非商业目的。 
但Redistribution时必须拷贝本[版权声明]。  

[BUG] 

有不少部分,翻译的时候不能作到“信,达”。当然了,任何时候都没有做到“雅”,希望各位谅解。 

[原著] 
  
Don Libes: National Institute of Standards and Technology 
libes@cme.nist.gov 

[目录] 
  
1.摘要 
2.关键字 
3.简介 
4.Expect综述 
5.callback 
6.passwd 和一致性检查 
7.rogue 和伪终端 
8.ftp 
9.fsck 
10.多进程控制:作业控制 
11.交互式使用Expect 
12.交互式Expect编程 
13.非交互式程序的控制 
14.Expect的速度 
15.安全方面的考虑 
16.Expect资源 
17.参考书籍 

1.[摘要] 

  现代的Shell对程序提供了最小限度的控制(开始,停止,等等),而把交互的特性留给了用户。 这意味着有些程序,
你不能非交互的运行,比如说passwd。 有一些程序可以非交互的运行,但在很大程度上丧失了灵活性,比如说fsck。
这表明Unix的工具构造逻辑开始出现问题。Expect恰恰填补了其中的一些裂痕,解决了在Unix环境中长期存在着的一些
问题。 

  Expect使用Tcl作为语言核心。不仅如此,不管程序是交互和还是非交互的,Expect都能运用。这是一个小语言和Unix
的其他工具配合起来产生强大功能的经典例子。 
  
  本部分教程并不是有关Expect的实现,而是关于Expect语言本身的使用,这主要也是通过不同的脚本描述例子来体现。
其中的几个例子还例证了Expect的几个新特征。 
  
2.[关键字] 
  
Expect,交互,POSIX,程序化的对话,Shell,Tcl,Unix; 

3.[简介] 
  
一个叫做fsck的Unix文件系统检查程序,可以从Shell里面用-y或者-n选项来执行。 在手册[1]里面,-y选项的定
义是象这样的。 

“对于fsck的所有问题都假定一个“yes”响应;在这样使用的时候,必须特别的小心,因为它实际上允许程序无条
件的继续运行,即使是遇到了一些非常严重的错误” 
  
相比之下,-n选项就安全的多,但它实际上几乎一点用都没有。这种接口非常的糟糕,但是却有许多的程序都是这种
风格。 文件传输程序ftp有一个选项可以禁止交互式的提问,以便能从一个脚本里面运行。但一旦发生了错误,它没有
提供的处理措施。 

Expect是一个控制交互式程序的工具。他解决了fsck的问题,用非交互的方式实现了所有交互式的功能。Expect不是
特别为fsck设计的,它也能进行类似ftp的出错处理。 

fsck和ftp的问题向我们展示了象sh,csh和别的一些shell提供的用户接口的局限性。 Shell没有提供从一个程序读
和象一个程序写的功能。这意味着shell可以运行fsck但只能以牺牲一部分fsck的灵活性做代价。有一些程序根本就不能
被执行。比如说,如果没有一个用户接口交互式的提供输入,就没法运行下去。其他还有象Telnet,crypt,su,rlogin等程
序无法在shell脚本里面自动执行。还有很多其他的应用程序在设计是也是要求用户输入的。 

Expect被设计成专门针和交互式程序的交互。一个Expect程序员可以写一个脚本来描述程序和用户的对话。接着Expect
程序可以非交互的运行“交互式”的程序。写交互式程序的脚本和写非交互式程序的脚本一样简单。Expect还可以用于对对
话的一部分进行自动化,因为程序的控制可以在键盘和脚本之间进行切换。 

bes[2]里面有详细的描述。简单的说,脚本是用一种解释性语言写的。(也有C和C++的Expect库可供使用,但这超出了本文
的范围).Expect提供了创建交互式进程和读写它们的输入和输出的命令。 Expect是由于它的一个同名的命令而命名的。 

Expect语言是基于Tcl的。Tcl实际上是一个子程序库,这些子程序库可以嵌入到程序里从而提供语言服务。 最终的
语言有点象一个典型的Shell语言。里面有给变量赋值的set命令,控制程序执行的if,for,continue等命令,还能进行普通
的数学和字符串操作。当然了,还可以用exec来调用Unix程序。所有这些功能,Tcl都有。Tcl在参考书籍 Outerhour[3][4]
里有详细的描述。 

Expect是在Tcl基础上创建起来的,它还提供了一些Tcl所没有的命令。spawn命令激活一个Unix程序来进行交互式的运行。
send命令向进程发送字符串。expect命令等待进程的某些字符串。 expect支持正规表达式并能同时等待多个字符串,并对
每一个字符串执行不同的操作。expect还能理解一些特殊情况,如超时和遇到文件尾。 

expect命令和Tcl的case命令的风格很相似。都是用一个字符串去匹配多个字符串。(只要有可能,新的命令总是和已
有的Tcl命令相似,以使得该语言保持工具族的继承性)。下面关于expect的定义是从手册[5]上摘录下来的。 

expect patlist1 action1 patlist2 action2….. 

该命令一直等到当前进程的输出和以上的某一个模式相匹配,或者等 到时间超过一个特定的时间长度,
或者等到遇到了文件的结束为止。 
  
如果最后一个action是空的,就可以省略它。 

每一个patlist都由一个模式或者模式的表(lists)组成。如果有一个模式匹配成功,相应的action就被执行。执
行的结果从expect返回。 
被精确匹配的字符串(或者当超时发生时,已经读取但未进行匹配的字符串)被存贮在变量expect_match里面。如
果patlist是eof或者timeout,则发生文件结束或者超时时才执行相应的action.一般超时的时值是10秒,但可以用类似
"set timeout 30"之类的命令把超时时值设定为30秒。 
  
下面的一个程序段是从一个有关登录的脚本里面摘取的。abort是在脚本的别处定义的过程,而其他的action使用
类似与C语言的Tcl原语。 

expect "*welcome*" break   
  "*busy*" {print busy;continue} 
  "*failed*" abort  
  timeout abort 

模式是通常的C Shell风格的正规表达式。模式必须匹配当前进程的从上一个expect或者interact开始的所有输
出(所以统配符*使用的非常)的普遍。但是,一旦输出超过2000个字节,前面的字符就会被忘记,这可以通过设定
match_max的值来改变。 

expect命令确实体现了expect语言的最好和最坏的性质。特别是,expect命令的灵活性是以经常出现令人迷惑的语法
做代价。除了关键字模式(比如说eof,timeout)那些模式表可以包括多个模式。这保证提供了一种方法来区分他们。但是分
开这些表需要额外的扫描,如果没有恰当的用["]括起来,这有可能会把和当成空白字符。由于Tcl提供了两种字符串引用
的方法:单引和双引,情况变的更糟。(在Tcl里面,如果不会出现二义性话,没有必要使用引号)。在expect的手册里面,
还有一个独立的部分来解释这种复杂性。幸运的是:有一些很好的例子似乎阻止了这种抱怨。但是,这个复杂性很有可能
在将来的版本中再度出现。为了增强可读性,在本文中,提供的脚本都假定双引号是足够的。 

字符可以使用反斜杠来单独的引用,反斜杠也被用于对语句的延续,如果不加反斜杠的话,语句到一行的结尾处就结
束了。这和Tcl也是一致的。Tcl在发现有开的单引号或者开的双引号时都会继续扫描。而且,分号可以用于在一行中分割
多个语句。这乍听起来有点让人困惑,但是,这是解释性语言的风格,但是,这确实是Tcl的不太漂亮的部分。 

5.[callback] 

令人非常惊讶的是,一些小的脚本如何的产生一些有用的功能。下面是一个拨电话号码的脚本。他用来把收费反向,
以便使得长途电话对计算机计费。这个脚本用类似“expect callback.exp 12016442332”来激活。其中,脚本的名字便
是callback.exp,而+1(201)644-2332是要拨的电话号码。 

#first give the user some time to logout 
exec sleep 4 
spawn tip modem 
expect "*connected*" 
send "ATD [index $argv 1] " 
#modem takes a while to connect 
set timeout 60 
expect "*CONNECT*" 

第一行是注释,第二行展示了如何调用没有交互的Unix程序。sleep 4会使程序阻塞4秒,以使得用户有时间来退出,
因为modem总是会回叫用户已经使用的电话号码。 

下面一行使用spawn命令来激活tip程序,以便使得tip的输出能够被expect所读取,使得tip能从send读输入。一旦
tip说它已经连接上,modem就会要求去拨打大哥电话号码。(假定modem都是贺氏兼容的,但是本脚本可以很容易的修改
成能适应别的类型的modem)。不论发生了什么,expect都会终止。如果呼叫失败,expect脚本可以设计成进行重试,但
这里没有。如果呼叫成功,getty会在expect退出后检测到DTR,并且向用户提示loging:。(实用的脚本往往提供更多的
错误检测)。 

这个脚本展示了命令行参数的使用,命令行参数存贮在一个叫做argv的表里面(这和C语言的风格很象)。在这种情况
下,第一个元素就是电话号码。方括号使得被括起来的部分当作命令来执行,结果就替换被括起来的部分。这也和
C Shell的风格很象。 

这个脚本和一个大约60K的C语言程序实现的功能相似。 
  

6.[passwd和一致性检查] 

在前面,我们提到passwd程序在缺乏用户交互的情况下,不能运行,passwd会忽略I/O重定向,也不能嵌入到管道里
边以便能从别的程序或者文件里读取输入。这个程序坚持要求真正的与用户进行交互。因为安全的原因,passwd被设计
成这样,但结果导致没有非交互式的方法来检验passwd。这样一个对系统安全至关重要的程序竟然没有办法进行可靠的
检验,真实具有讽刺意味。 

passwd以一个用户名作为参数,交互式的提示输入密码。下面的expect脚本以用户名和密码作为参数而非交互式的运行。 

spawn oasswd [index $argv 1] 
set password [index $argv 2] 
expect "*password:" 
send "$password " 
expect "*password:" 
send "$password " 
expect eof 

第一行以用户名做参数启动passwd程序,为方便起见,第二行把密码存到一个变量里面。和shell类似,变量的使用也
不需要提前声明。 

在第三行,expect搜索模式"*password:",其中*允许匹配任意输入,所以对于避免指定所有细节而言是非常有效的。 
上面的程序里没有action,所以expect检测到该模式后就继续运行。 

一旦接收到提示后,下一行就就把密码送给当前进程。表明回车。(实际上,所有的C的关于字符的约定都支持)。上面
的程序中有两个expect-send序列,因为passwd为了对输入进行确认,要求进行两次输入。在非交互式程序里面,这是毫无
必要的,但由于假定passwd是在和用户进行交互,所以我们的脚本还是这样做了。 

最后,"expect eof"这一行的作用是在passwd的输出中搜索文件结束符,这一行语句还展示了关键字的匹配。另外一
个关键字匹配就是timeout了,timeout被用于表示所有匹配的失败而和一段特定长度的时间相匹配。在这里eof是非常有必
要的,因为passwd被设计成会检查它的所有I/O是否都成功了,包括第二次输入密码时产生的最后一个新行。 

这个脚本已经足够展示passwd命令的基本交互性。另外一个更加完备的例子回检查别的一些行为。比如说,下面的这
个脚本就能检查passwd程序的别的几个方面。所有的提示都进行了检查。对垃圾输入的检查也进行了适当的处理。进程死
亡,超乎寻常的慢响应,或者别的非预期的行为都进行了处理。 

spawn passwd [index $argv 1] 
expect  eof {exit 1}   
timeout {exit 2}  
"*No such user.*" {exit 3}  
"*New password:"  
send "[index $argv 2 " 
expect  eof {exit 4}  
timeout {exit 2}  
"*Password too long*" {exit 5}  
"*Password too short*" {exit 5}  
"*Retype ew password:" 
send "[index $argv 3] " 
expect  timeout {exit 2}  
"*Mismatch*" {exit 6}  
"*Password unchanged*" {exit 7}  
" "  
expect timeout {exit 2}  
"*" {exit 6}  
eof 

  
这个脚本退出时用一个数字来表示所发生的情况。0表示passwd程序正常运行,1表示非预期的死亡,2表示锁定,等等。
使用数字是为了简单起见。expect返回字符串和返回数字是一样简单的,即使是派生程序自身产生的消息也是一样的。实际
上,典型的做法是把整个交互的过程存到一个文件里面,只有当程序的运行和预期一样的时候才把这个文件删除。否则这个
log被留待以后进一步的检查。 

这个passwd检查脚本被设计成由别的脚本来驱动。这第二个脚本从一个文件里面读取参数和预期的结果。对于每一个输
入参数集,它调用第一个脚本并且把结果和预期的结果相比较。(因为这个任务是非交互的,一个普通的老式shell就可以用
来解释第二个脚本)。比如说,一个passwd的数据文件很有可能就象下面一样。 

passwd.exp 3 bogus – – 
passwd.exp 0 fred abledabl abledabl 
passwd.exp 5 fred abcdefghijklm – 
passwd.exp 5 fred abc – 
passwd.exp 6 fred foobar bar  
passwd.exp 4 fred ^C – 

第一个域的名字是要被运行的回归脚本。第二个域是需要和结果相匹配的退出值。第三个域就是用户名。第四个域和
第五个域就是提示时应该输入的密码。减号仅仅表示那里有一个域,这个域其实绝对不会用到。在第一个行中,bogus表示
用户名是非法的,因此passwd会响应说:没有此用户。expect在退出时会返回3,3恰好就是第二个域。在最后一行中,^C就
是被切实的送给程序来验证程序是否恰当的退出。 

通过这种方法,expect可以用来检验和调试交互式软件,这恰恰是IEEE的POSIX 1003.2(shell和工具)的一致性检验所
要求的。进一步的说明请参考Libes[6]。 

7.[rogue 和伪终端] 

Unix用户肯定对通过管道来和其他进程相联系的方式非常的熟悉(比如说:一个shell管道)。expect使用伪终端来和派
生的进程相联系。伪终端提供了终端语义以便程序认为他们正在和真正的终端进行I/O操作。 

比如说,BSD的探险游戏rogue在生模式下运行,并假定在连接的另一端是一个可寻址的字符终端。可以用expect编程,
使得通过使用用户界面可以玩这个游戏。 

rogue这个探险游戏首先提供给你一个有各种物理属性,比如说力量值,的角色。在大部分时间里,力量值都是16,但
在几乎每20次里面就会有一个力量值是18。很多的rogue玩家都知道这一点,但没有人愿意启动程序20次以获得一个好的配
置。下面的这个脚本就能达到这个目的。 

for {} {1} {} { 
spawn rogue 
expect "*Str:18*" break  
  "*Str:16*"  
close 
wait 

interact 

第一行是个for循环,和C语言的控制格式很象。rogue启动后,expect就检查看力量值是18还是16,如果是16,程序
就通过执行close和wait来退出。这两个命令的作用分别是关闭和伪终端的连接和等待进程退出。rogue读到一个文件结束
符就推出,从而循环继续运行,产生一个新的rogue游戏来检查。 

当一个值为18的配置找到后,控制就推出循环并跳到最后一行脚本。interact把控制转移给用户以便他们能够玩这个
特定的游戏。 

想象一下这个脚本的运行。你所能真正看到的就是20或者30个初始的配置在不到一秒钟的时间里掠过屏幕,最后留给
你的就是一个有着很好配置的游戏。唯一比这更好的方法就是使用调试工具来玩游戏。 

我们很有必要认识到这样一点:rogue是一个使用光标的图形游戏。expect程序员必须了解到:光标的运动并不一定
以一种直观的方式在屏幕上体现。幸运的是,在我们这个例子里,这不是一个问题。将来的对expect的改进可能会包括一
个内嵌的能支持字符图形区域的终端模拟器。 

8.[ftp] 

我们使用expect写第一个脚本并没有打印出"Hello,World"。实际上,它实现了一些更有用的功能。它能通过非交互
的方式来运行ftp。ftp是用来在支持TCP/IP的网络上进行文件传输的程序。除了一些简单的功能,一般的实现都要求用户
的参与。 

下面这个脚本从一个主机上使用匿名ftp取下一个文件来。其中,主机名是第一个参数。文件名是第二个参数。 

spawn ftp [index $argv 1] 
expect "*Name*" 
send "anonymous " 
expect "*Password:*" 
send [exec whoami] 
expect "*ok*ftp>*" 
send "get [index $argv 2] " 
expect "*ftp>*" 

上面这个程序被设计成在后台进行ftp。虽然他们在底层使用和expect类似的机制,但他们的可编程能力留待改进。
因为expect提供了高级语言,你可以对它进行修改来满足你的特定需求。比如说,你可以加上以下功能: 

:坚持--如果连接或者传输失败,你就可以每分钟或者每小时,甚 
至可以根据其他因素,比如说用户的负载,来进行不定期的 
重试。 
:通知--传输时可以通过mail,write或者其他程序来通知你,甚至 
可以通知失败。 
:初始化-每一个用户都可以有自己的用高级语言编写的初始化文件 
(比如说,.ftprc)。这和C shell对.cshrc的使用很类似。 

expect还可以执行其他的更复杂的任务。比如说,他可以使用McGill大学的Archie系统。Archie是一个匿名的
Telnet服务,它提供对描述Internet上可通过匿名ftp获取的文件的数据库的访问。通过使用这个服务,脚本可以询问
Archie某个特定的文件的位置,并把它从ftp服务器上取下来。这个功能的实现只要求在上面那个脚本中加上几行就可
以。 

现在还没有什么已知的后台-ftp能够实现上面的几项功能,能不要说所有的功能了。在expect里面,它的实现却
是非常的简单。“坚持”的实现只要求在expect脚本里面加上一个循环。“通知”的实现只要执行mail和write就可以
了。“初始化文件”的实现可以使用一个命令,source .ftprc,就可以了,在.ftprc里面可以有任何的expect命令。 

虽然这些特征可以通过在已有的程序里面加上钩子函数就可以,但这也不能保证每一个人的要求都能得到满足。
唯一能够提供保证的方法就是提供一种通用的语言。一个很好的解决方法就是把Tcl自身融入到ftp和其他的程序中间去。
实际上,这本来就是Tcl的初衷。在还没有这样做之前,expect提供了一个能实现大部分功能但又不需要任何重写的方案。 

9.[fsck] 

fsck是另外一个缺乏足够的用户接口的例子。fsck几乎没有提供什么方法来预先的回答一些问题。你能做的就是给
所有的问题都回答"yes"或者都回答"no"。 

下面的程序段展示了一个脚本如何的使的自动的对某些问题回答"yes",而对某些问题回答"no"。下面的这个脚本一
开始先派生fsck进程,然后对其中两种类型的问题回答"yes",而对其他的问题回答"no"。 

for {} {1} {} { 
expect 
eof break  
"*UNREF FILE*CLEAR?" {send "r "}  
"*BAD INODE*FIX?" {send "y "}  
"*?" {send "n "}  

在下面这个版本里面,两个问题的回答是不同的。而且,如果脚本遇到了什么它不能理解的东西,就会执行
interact命令把控制交给用户。用户的击键直接交给fsck处理。当执行完后,用户可以通过按"+"键来退出或者

把控制交还给expect。如果控制是交还给脚本了,脚本就会自动的控制进程的剩余部分的运行。 

for {} {1} {}{ 
expect   
eof break  
"*UNREF FILE*CLEAR?" {send "y "}  
"*BAD INODE*FIX?" {send "y "}  
"*?" {interact +}  

如果没有expect,fsck只有在牺牲一定功能的情况下才可以非交互式的运行。fsck几乎是不可编程的,但它
却是系统管理的最重要的工具。许多别的工具的用户接口也一样的不足。实际上,正是其中的一些程序的不足导
致了expect的诞生。 

10.[控制多个进程:作业控制] 

  expect的作业控制概念精巧的避免了通常的实现困难。其中包括了两个问题:一个是expect如何处理经典的
作业控制,即当你在终端上按下^Z键时expect如何处理;另外一个就是expect是如何处理多进程的。 

  对第一个问题的处理是:忽略它。expect对经典的作业控制一无所知。比如说,你派生了一个程序并且发送
一个^Z给它,它就会停下来(这是伪终端的完美之处)而expect就会永远的等下去。 

  但是,实际上,这根本就不成一个问题。对于一个expect脚本,没有必要向进程发送^Z。也就是说,没有必
要停下一个进程来。expect仅仅是忽略了一个进程,而把自己的注意力转移到其他的地方。这就是expect的作业
控制思想,这个思想也一直工作的很好。 

从用户的角度来看是象这样的:当一个进程通过spawn命令启动时,变量spawn_id就被设置成某进程的描述
符。由spawn_id描述的进程就被认为是当前进程。(这个描述符恰恰就是伪终端文件的描述符,虽然用户把它当
作一个不透明的物体)。expect和send命令仅仅和当前进程进行交互。所以,切换一个作业所需要做的仅仅是把
该进程的描述符赋给spawn_id。 

这儿有一个例子向我们展示了如何通过作业控制来使两个chess进程进行交互。在派生完两个进程之后,一
个进程被通知先动一步。在下面的循环里面,每一步动作都送给另外一个进程。其中,read_move和write_move
两个过程留给读者来实现。(实际上,它们的实现非常的容易,但是,由于太长了所以没有包含在这里)。 

spawn chess ;# start player one 
set id1 $spawn_id 
expect "Chess " 
send "first " ;# force it to go first 
read_move 

spawn chess ;# start player two 
set id2 $spawn_id 
expect "Chess " 
  
for {} {1} {}{ 
send_move 
read_move 
set spawn_id $id1 
  
send_move 
read_move 
set spawn_id $id2 

  有一些应用程序和chess程序不太一样,在chess程序里,的两个玩家轮流动。下面这个脚本实现了一个冒
充程序。它能够控制一个终端以便用户能够登录和正常的工作。但是,一旦系统提示输入密码或者输入用户名的
时候,expect就开始把击键记下来,一直到用户按下回车键。这有效的收集了用户的密码和用户名,还避免了普
通的冒充程序的"Incorrect password-tryagain"。而且,如果用户连接到另外一个主机上,那些额外的登录也
会被记录下来。 

spawn tip /dev/tty17 ;# open connection to 
set tty $spawn_id ;# tty to be spoofed 

spawn login 
set login $spawn_id 

log_user 0 
  
for {} {1} {} { 
set ready [select $tty $login] 
  
case $login in $ready { 
set spawn_id $login 
expect   
{"*password*" "*login*"}{ 
  send_user $expect_match 
  set log 1 
  }  
  "*" ;# ignore everything else 
set spawn_id $tty; 
send $expect_match 

case $tty in $ready { 
set spawn_id $tty 
expect "* *"{ 
if $log { 
  send_user $expect_match 
  set log 0 

  }  
"*" { 
send_user $expect_match 
  } 
set spawn_id  $login; 
send $expect_match 


  

  这个脚本是这样工作的。首先连接到一个login进程和终端。缺省的,所有的对话都记录到标准输出上
(通过send_user)。因为我们对此并不感兴趣,所以,我们通过命令"log_user 0"来禁止这个功能。(有很多
的命令来控制可以看见或者可以记录的东西)。 

  在循环里面,select等待终端或者login进程上的动作,并且返回一个等待输入的spawn_id表。如果在
表里面找到了一个值的话,case就执行一个action。比如说,如果字符串"login"出现在login进程的输出中,
提示就会被记录到标准输出上,并且有一个标志被设置以便通知脚本开始记录用户的击键,直至用户按下了回
车键。无论收到什么,都会回显到终端上,一个相应的action会在脚本的终端那一部分执行。 

  这些例子显示了expect的作业控制方式。通过把自己插入到对话里面,expect可以在进程之间创建复杂
的I/O流。可以创建多扇出,复用扇入的,动态的数据相关的进程图。 

  相比之下,shell使得它自己一次一行的读取一个文件显的很困难。shell强迫用户按下控制键(比如,
^C,^Z)和关键字(比如fg和bg)来实现作业的切换。这些都无法从脚本里面利用。相似的是:以非交互方式运
行的shell并不处理“历史记录”和其他一些仅仅为交互式使用设计的特征。这也出现了和前面哪个passwd程
序的相似问题。相似的,也无法编写能够回归的测试shell的某些动作的shell脚本。结果导致shell的这些方
面无法进行彻底的测试。 

  如果使用expect的话,可以使用它的交互式的作业控制来驱动shell。一个派生的shell认为它是在交互
的运行着,所以会正常的处理作业控制。它不仅能够解决检验处理作业控制的shell和其他一些程序的问题。
还能够在必要的时候,让shell代替expect来处理作业。可以支持使用shell风格的作业控制来支持进程的运行。
这意味着:首先派生一个shell,然后把命令送给shell来启动进程。如果进程被挂起,比如说,发送了一个^Z,
进程就会停下来,并把控制返回给shell。对于expect而言,它还在处理同一个进程(原来那个shell)。 

expect的解决方法不仅具有很大的灵活性,它还避免了重复已经存在于shell中的作业控制软件。通过使
用shell,由于你可以选择你想派生的shell,所以你可以根据需要获得作业控制权。而且,一旦你需要(比如
说检验的时候),你就可以驱动一个shell来让这个shell以为它正在交互式的运行。这一点对于在检测到它们
是否在交互式的运行之后会改变输出的缓冲的程序来说也是很重要的。 

为了进一步的控制,在interact执行期间,expect把控制终端(是启动expect的那个终端,而不是伪终端)
设置成生模式以便字符能够正确的传送给派生的进程。当expect在没有执行interact的时候,终端处于熟模式
下,这时候作业控制就可以作用于expect本身。 

11.[交互式的使用expect] 

在前面,我们提到可以通过interact命令来交互式的使用脚本。基本上来说,interact命令提供了对对话
的自由访问,但我们需要一些更精细的控制。这一点,我们也可以使用expect来达到,因为expect从标准输入
中读取输入和从进程中读取输入一样的简单。 但是,我们要使用expect_user和send_user来进行标准I/O,同
时不改变spawn_id。 

下面的这个脚本在一定的时间内从标准输入里面读取一行。这个脚本叫做timed_read,可以从csh里面调用,
比如说,set answer="timed_read 30"就能调用它。 

#!/usr/local/bin/expect -f 
set timeout [index $argv 1] 
expect_user "* " 
send_user $expect_match 

  第三行从用户那里接收任何以新行符结束的任何一行。最后一行把它返回给标准输出。如果在特定的时间
内没有得到任何键入,则返回也为空。 

  第一行支持"#!"的系统直接的启动脚本。(如果把脚本的属性加上可执行属性则不要在脚本前面加上expect)。
当然了脚本总是可以显式的用"expect scripot"来启动。在-c后面的选项在任何脚本语句执行前就被执行。比如
说,不要修改脚本本身,仅仅在命令行上加上-c "trace…",该脚本可以加上trace功能了(省略号表示trace的
选项)。 

  在命令行里实际上可以加上多个命令,只要中间以";"分开就可以了。比如说,下面这个命令行: 

expect -c "set timeout 20;spawn foo;expect" 

一旦你把超时时限设置好而且程序启动之后,expect就开始等待文件结束符或者20秒的超时时限。 如果遇
到了文件结束符(EOF),该程序就会停下来,然后expect返回。如果是遇到了超时的情况,expect就返回。在这两
中情况里面,都隐式的杀死了当前进程。 

  如果我们不使用expect而来实现以上两个例子的功能的话,我们还是可以学习到很多的东西的。在这两中情
况里面,通常的解决方案都是fork另一个睡眠的子进程并且用signal通知原来的shell。如果这个过程或者读先发
生的话,shell就会杀司那个睡眠的进程。 传递pid和防止后台进程产生启动信息是一个让除了高手级shell程序员
之外的人头痛的事情。提供一个通用的方法来象这样启动多个进程会使shell脚本非常的复杂。 所以几乎可以肯定
的是,程序员一般都用一个专门C程序来解决这样一个问题。 

expect_user,send_user,send_error(向标准错误终端输出)在比较长的,用来把从进程来的复杂交互翻译成
简单交互的expect脚本里面使用的比较频繁。在参考[7]里面,Libs描述怎样用脚本来安全的包裹(wrap)adb,怎样
把系统管理员从需要掌握adb的细节里面解脱出来,同时大大的降低了由于错误的击键而导致的系统崩溃。 

一个简单的例子能够让ftp自动的从一个私人的帐号里面取文件。在这种情况里,要求提供密码。 即使文件
的访问是受限的,你也应该避免把密码以明文的方式存储在文件里面。把密码作为脚本运行时的参数也是不合适的,
因为用ps命令能看到它们。有一个解决的方法就是在脚本运行的开始调用expect_user来让用户输入以后可能使用的
密码。这个密码必须只能让这个脚本知道,即使你是每个小时都要重试ftp。 

即使信息是立即输入进去的,这个技巧也是非常有用。比如说,你可以写一个脚本,把你每一个主机上不
同的帐号上的密码都改掉,不管他们使用的是不是同一个密码数据库。如果你要手工达到这样一个功能的话,你必
须Telnet到每一个主机上,并且手工输入新的密码。而使用expect,你可以只输入密码一次而让脚本来做其它的事
情。 

expect_user和interact也可以在一个脚本里面混合的使用。考虑一下在调试一个程序的循环时,经过好多
步之后才失败的情况。一个expect脚本可以驱动哪个调试器,设置好断点,执行该程序循环的若干步,然后将控制
返回给键盘。它也可以在返回控制之前,在循环体和条件测试之间来回的切换。 

6.[passwd和一致性检查] 

在前面,我们提到passwd程序在缺乏用户交互的情况下,不能运行,passwd 
会忽略I/O重定向,也不能嵌入到管道里边以便能从别的程序或者文件里读取输 
入。这个程序坚持要求真正的与用户进行交互。因为安全的原因,passwd被设计 
成这样,但结果导致没有非交互式的方法来检验passwd。这样一个对系统安全 
至关重要的程序竟然没有办法进行可靠的检验,真实具有讽刺意味。 

passwd以一个用户名作为参数,交互式的提示输入密码。下面的expect脚 
本以用户名和密码作为参数而非交互式的运行。 

spawn oasswd [index $argv 1] 
set password [index $argv 2] 
expect "*password:" 
send "$password " 
expect "*password:" 
send "$password " 
expect eof 

第一行以用户名做参数启动passwd程序,为方便起见,第二行把密码存到 
一个变量里面。和shell类似,变量的使用也不需要提前声明。 

在第三行,expect搜索模式"*password:",其中*允许匹配任意输入,所 
以对于避免指定所有细节而言是非常有效的。 上面的程序里没有action,所以 
expect检测到该模式后就继续运行。 

一旦接收到提示后,下一行就就把密码送给当前进程。表明回车。(实 
际上,所有的C的关于字符的约定都支持)。上面的程序中有两个expect-send 
序列,因为passwd为了对输入进行确认,要求进行两次输入。在非交互式程序 
里面,这是毫无必要的,但由于假定passwd是在和用户进行交互,所以我们的 
脚本还是这样做了。 

最后,"expect eof"这一行的作用是在passwd的输出中搜索文件结束符, 
这一行语句还展示了关键字的匹配。另外一个关键字匹配就是timeout了, 
timeout被用于表示所有匹配的失败而和一段特定长度的时间相匹配。在这里 
eof是非常有必要的,因为passwd被设计成会检查它的所有I/O是否都成功了, 
包括第二次输入密码时产生的最后一个新行。 

这个脚本已经足够展示passwd命令的基本交互性。另外一个更加完备的例 
子回检查别的一些行为。比如说,下面的这个脚本就能检查passwd程序的别的 
几个方面。所有的提示都进行了检查。对垃圾输入的检查也进行了适当的处 
理。进程死亡,超乎寻常的慢响应,或者别的非预期的行为都进行了处理。 

spawn passwd [index $argv 1] 
expect  eof {exit 1}   
timeout {exit 2}  
"*No such user.*" {exit 3}  
"*New password:"  
send "[index $argv 2 " 
expect  eof {exit 4}  
timeout {exit 2}  
"*Password too long*" {exit 5}  
"*Password too short*" {exit 5}  
"*Retype ew password:" 
send "[index $argv 3] " 
expect  timeout {exit 2}  
"*Mismatch*" {exit 6}  
"*Password unchanged*" {exit 7}  
" "  
expect timeout {exit 2}  
"*" {exit 6}  
eof 

  
这个脚本退出时用一个数字来表示所发生的情况。0表示passwd程序正常 
运行,1表示非预期的死亡,2表示锁定,等等。使用数字是为了简单起见。 
expect返回字符串和返回数字是一样简单的,即使是派生程序自身产生的消息 
也是一样的。实际上,典型的做法是把整个交互的过程存到一个文件里面,只 
有当程序的运行和预期一样的时候才把这个文件删除。否则这个log被留待以 
后进一步的检查。 

这个passwd检查脚本被设计成由别的脚本来驱动。这第二个脚本从一个文 
件里面读取参数和预期的结果。对于每一个输入参数集,它调用第一个脚本并 
且把结果和预期的结果相比较。(因为这个任务是非交互的,一个普通的老式 
shell就可以用来解释第二个脚本)。比如说,一个passwd的数据文件很有可能 
就象下面一样。 

passwd.exp 3 bogus – – 
passwd.exp 0 fred abledabl abledabl 
passwd.exp 5 fred abcdefghijklm – 
passwd.exp 5 fred abc – 
passwd.exp 6 fred foobar bar  
passwd.exp 4 fred ^C – 

第一个域的名字是要被运行的回归脚本。第二个域是需要和结果相匹配的 
退出值。第三个域就是用户名。第四个域和第五个域就是提示时应该输入的密 
码。减号仅仅表示那里有一个域,这个域其实绝对不会用到。在第一个行中 
,bogus表示用户名是非法的,因此passwd会响应说:没有此用户。expect在 
退出时会返回3,3恰好就是第二个域。在最后一行中,^C就是被切实的送给程 
序来验证程序是否恰当的退出。 

通过这种方法,expect可以用来检验和调试交互式软件,这恰恰是IEEE的 
POSIX 1003.2(shell和工具)的一致性检验所要求的。进一步的说明请参考 
Libes[6]。 

7.[rogue 和伪终端] 

Unix用户肯定对通过管道来和其他进程相联系的方式非常的熟悉(比如说: 
一个shell管道)。expect使用伪终端来和派生的进程相联系。伪终端提供了终 
端语义以便程序认为他们正在和真正的终端进行I/O操作。 

比如说,BSD的探险游戏rogue在生模式下运行,并假定在连接的另一端是 
一个可寻址的字符终端。可以用expect编程,使得通过使用用户界面可以玩这 
个游戏。 

rogue这个探险游戏首先提供给你一个有各种物理属性,比如说力量值,的 
角色。在大部分时间里,力量值都是16,但在几乎每20次里面就会有一个力量 
值是18。很多的rogue玩家都知道这一点,但没有人愿意启动程序20次以获得一 
个好的配置。下面的这个脚本就能达到这个目的。 

for {} {1} {} { 
spawn rogue 
expect "*Str:18*" break  
  "*Str:16*"  
close 
wait 

interact 

第一行是个for循环,和C语言的控制格式很象。rogue启动后,expect就 
检查看力量值是18还是16,如果是16,程序就通过执行close和wait来退出。 
这两个命令的作用分别是关闭和伪终端的连接和等待进程退出。rogue读到一 
个文件结束符就推出,从而循环继续运行,产生一个新的rogue游戏来检查。 

当一个值为18的配置找到后,控制就推出循环并跳到最后一行脚本。 
interact把控制转移给用户以便他们能够玩这个特定的游戏。 

想象一下这个脚本的运行。你所能真正看到的就是20或者30个初始的配置 
在不到一秒钟的时间里掠过屏幕,最后留给你的就是一个有着很好配置的游戏 
。唯一比这更好的方法就是使用调试工具来玩游戏。 

我们很有必要认识到这样一点:rogue是一个使用光标的图形游戏。 
expect程序员必须了解到:光标的运动并不一定以一种直观的方式在屏幕上体 
现。幸运的是,在我们这个例子里,这不是一个问题。将来的对expect的改 
进可能会包括一个内嵌的能支持字符图形区域的终端模拟器。 

8.[ftp] 

我们使用expect写第一个脚本并没有打印出"Hello,World"。实际上,它 
实现了一些更有用的功能。它能通过非交互的方式来运行ftp。ftp是用来在支 
持TCP/IP的网络上进行文件传输的程序。除了一些简单的功能,一般的实现都 
要求用户的参与。 

下面这个脚本从一个主机上使用匿名ftp取下一个文件来。其中,主机名 
是第一个参数。文件名是第二个参数。 

spawn ftp [index $argv 1] 
expect "*Name*" 
send "anonymous " 
expect "*Password:*" 
send [exec whoami] 
expect "*ok*ftp>*" 
send "get [index $argv 2] " 
expect "*ftp>*" 

上面这个程序被设计成在后台进行ftp。虽然他们在底层使用和expect类 
似的机制,但他们的可编程能力留待改进。因为expect提供了高级语言,你可 
以对它进行修改来满足你的特定需求。比如说,你可以加上以下功能: 

:坚持--如果连接或者传输失败,你就可以每分钟或者每小时,甚 
至可以根据其他因素,比如说用户的负载,来进行不定期的 
重试。 
:通知--传输时可以通过mail,write或者其他程序来通知你,甚至 
可以通知失败。 
:初始化-每一个用户都可以有自己的用高级语言编写的初始化文件 
(比如说,.ftprc)。这和C shell对.cshrc的使用很类似。 

expect还可以执行其他的更复杂的任务。比如说,他可以使用McGill大学 
的Archie系统。Archie是一个匿名的Telnet服务,它提供对描述Internet上可 
通过匿名ftp获取的文件的数据库的访问。通过使用这个服务,脚本可以询问 
Archie某个特定的文件的位置,并把它从ftp服务器上取下来。这个功能的实 
现只要求在上面那个脚本中加上几行就可以。 

现在还没有什么已知的后台-ftp能够实现上面的几项功能,能不要说所有 
的功能了。在expect里面,它的实现却是非常的简单。“坚持”的实现只要求 
在expect脚本里面加上一个循环。“通知”的实现只要执行mail和write就可以 
了。“初始化文件”的实现可以使用一个命令,source .ftprc,就可以了, 
在.ftprc里面可以有任何的expect命令。 

虽然这些特征可以通过在已有的程序里面加上钩子函数就可以,但这也不 
能保证每一个人的要求都能得到满足。唯一能够提供保证的方法就是提供一种 
通用的语言。一个很好的解决方法就是把Tcl自身融入到ftp和其他的程序中间 
去。实际上,这本来就是Tcl的初衷。在还没有这样做之前,expect提供了一 
个能实现大部分功能但又不需要任何重写的方案。 

9.[fsck] 

fsck是另外一个缺乏足够的用户接口的例子。fsck几乎没有提供什么方法 
来预先的回答一些问题。你能做的就是给所有的问题都回答"yes"或者都回答 
"no"。 

下面的程序段展示了一个脚本如何的使的自动的对某些问题回答"yes", 
而对某些问题回答"no"。下面的这个脚本一开始先派生fsck进程,然后对其 
中两种类型的问题回答"yes",而对其他的问题回答"no"。 

for {} {1} {} { 
expect 
eof break  
"*UNREF FILE*CLEAR?" {send "r "}  
"*BAD INODE*FIX?" {send "y "}  
"*?" {send "n "}  

在下面这个版本里面,两个问题的回答是不同的。而且,如果脚本遇到 
了什么它不能理解的东西,就会执行interact命令把控制交给用户。用户的 
击键直接交给fsck处理。当执行完后,用户可以通过按"+"键来退出或者把 
控制交还给expect。如果控制是交还给脚本了,脚本就会自动的控制进程的 
剩余部分的运行。 

for {} {1} {}{ 
expect   
eof break  
"*UNREF FILE*CLEAR?" {send "y "}  
"*BAD INODE*FIX?" {send "y "}  
"*?" {interact +}  

如果没有expect,fsck只有在牺牲一定功能的情况下才可以非交互式的 
运行。fsck几乎是不可编程的,但它却是系统管理的最重要的工具。许多别 
的工具的用户接口也一样的不足。实际上,正是其中的一些程序的不足导致 
了expect的诞生。 

10.[控制多个进程:作业控制] 

  expect的作业控制概念精巧的避免了通常的实现困难。其中包括了两个问 
题:一个是expect如何处理经典的作业控制,即当你在终端上按下^Z键时 
expect如何处理;另外一个就是expect是如何处理多进程的。 

  对第一个问题的处理是:忽略它。expect对经典的作业控制一无所知。比 
如说,你派生了一个程序并且发送一个^Z给它,它就会停下来(这是伪终端的 
完美之处)而expect就会永远的等下去。 

  但是,实际上,这根本就不成一个问题。对于一个expect脚本,没有必要 
向进程发送^Z。也就是说,没有必要停下一个进程来。expect仅仅是忽略了 
一个进程,而把自己的注意力转移到其他的地方。这就是expect的作业控制 
思想,这个思想也一直工作的很好。 

从用户的角度来看是象这样的:当一个进程通过spawn命令启动时,变量 
spawn_id就被设置成某进程的描述符。由spawn_id描述的进程就被认为是当 
前进程。(这个描述符恰恰就是伪终端文件的描述符,虽然用户把它当作一个 
不透明的物体)。expect和send命令仅仅和当前进程进行交互。所以,切换一 
个作业所需要做的仅仅是把该进程的描述符赋给spawn_id。 

这儿有一个例子向我们展示了如何通过作业控制来使两个chess进程进行 
交互。在派生完两个进程之后,一个进程被通知先动一步。在下面的循环里 
面,每一步动作都送给另外一个进程。其中,read_move和write_move两个过 
程留给读者来实现。(实际上,它们的实现非常的容易,但是,由于太长了所 
以没有包含在这里)。 

spawn chess ;# start player one 
set id1 $spawn_id 
expect "Chess " 
send "first " ;# force it to go first 
read_move 

spawn chess ;# start player two 
set id2 $spawn_id 
expect "Chess " 
  
for {} {1} {}{ 
send_move 
read_move 
set spawn_id $id1 
  
send_move 
read_move 
set spawn_id $id2 

  有一些应用程序和chess程序不太一样,在chess程序里,的两个玩家 
轮流动。下面这个脚本实现了一个冒充程序。它能够控制一个终端以便用户 
能够登录和正常的工作。但是,一旦系统提示输入密码或者输入用户名的时 
候,expect就开始把击键记下来,一直到用户按下回车键。这有效的收集了 
用户的密码和用户名,还避免了普通的冒充程序的"Incorrect password-try 
again"。而且,如果用户连接到另外一个主机上,那些额外的登录也会被 
记录下来。 

spawn tip /dev/tty17 ;# open connection to 
set tty $spawn_id ;# tty to be spoofed 

spawn login 
set login $spawn_id 

log_user 0 
  
for {} {1} {} { 
set ready [select $tty $login] 
  
case $login in $ready { 
set spawn_id $login 
expect   
{"*password*" "*login*"}{ 
  send_user $expect_match 
  set log 1 
  }  
  "*" ;# ignore everything else 
set spawn_id $tty; 
send $expect_match 

case $tty in $ready { 
set spawn_id $tty 
expect "* *"{ 
if $log { 
  send_user $expect_match 
  set log 0 

  }  
"*" { 
send_user $expect_match 
  } 
set spawn_id  $login; 
send $expect_match 


  

  这个脚本是这样工作的。首先连接到一个login进程和终端。缺省的, 
所有的对话都记录到标准输出上(通过send_user)。因为我们对此并不感兴趣, 
所以,我们通过命令"log_user 0"来禁止这个功能。(有很多的命令来控制 
可以看见或者可以记录的东西)。 

  在循环里面,select等待终端或者login进程上的动作,并且返回一个 
等待输入的spawn_id表。如果在表里面找到了一个值的话,case就执行一个 
action。比如说,如果字符串"login"出现在login进程的输出中,提示就会 
被记录到标准输出上,并且有一个标志被设置以便通知脚本开始记录用户的 
击键,直至用户按下了回车键。无论收到什么,都会回显到终端上,一个相 
应的action会在脚本的终端那一部分执行。 

  这些例子显示了expect的作业控制方式。通过把自己插入到对话里面, 
expect可以在进程之间创建复杂的I/O流。可以创建多扇出,复用扇入的, 
动态的数据相关的进程图。 

  相比之下,shell使得它自己一次一行的读取一个文件显的很困难。 
shell强迫用户按下控制键(比如,^C,^Z)和关键字(比如fg和bg)来实现作业的 
切换。这些都无法从脚本里面利用。相似的是:以非交互方式运行的shell并 
不处理“历史记录”和其他一些仅仅为交互式使用设计的特征。这也出现了和 
前面哪个passwd程序的相似问题。相似的,也无法编写能够回归的测试shell 
的某些动作的shell脚本。结果导致shell的这些方面无法进行彻底的测试。 

  如果使用expect的话,可以使用它的交互式的作业控制来驱动shell。一 
个派生的shell认为它是在交互的运行着,所以会正常的处理作业控制。它不 
仅能够解决检验处理作业控制的shell和其他一些程序的问题。还能够在必要 
的时候,让shell代替expect来处理作业。可以支持使用shell风格的作业控 
制来支持进程的运行。这意味着:首先派生一个shell,然后把命令送给shell 
来启动进程。如果进程被挂起,比如说,发送了一个^Z,进程就会停下来,并 
把控制返回给shell。对于expect而言,它还在处理同一个进程(原来那个 
shell)。 

expect的解决方法不仅具有很大的灵活性,它还避免了重复已经存在于 
shell中的作业控制软件。通过使用shell,由于你可以选择你想派生的shell, 
所以你可以根据需要获得作业控制权。而且,一旦你需要(比如说检验的时 
候),你就可以驱动一个shell来让这个shell以为它正在交互式的运行。这一 
点对于在检测到它们是否在交互式的运行之后会改变输出的缓冲的程序来说也 
是很重要的。 

为了进一步的控制,在interact执行期间,expect把控制终端(是启动 
expect的那个终端,而不是伪终端)设置成生模式以便字符能够正确的传送给 
派生的进程。当expect在没有执行interact的时候,终端处于熟模式下,这时 
候作业控制就可以作用于expect本身。 

11.[交互式的使用expect] 

在前面,我们提到可以通过interact命令来交互式的使用脚本。基本上 
来说,interact命令提供了对对话的自由访问,但我们需要一些更精细的控 
制。这一点,我们也可以使用expect来达到,因为expect从标准输入中读取 
输入和从进程中读取输入一样的简单。 但是,我们要使用expect_user和 
send_user来进行标准I/O,同时不改变spawn_id。 

下面的这个脚本在一定的时间内从标准输入里面读取一行。这个脚本叫 
做timed_read,可以从csh里面调用,比如说,set answer="timed_read 30" 
就能调用它。 

#!/usr/local/bin/expect -f 
set timeout [index $argv 1] 
expect_user "* " 
send_user $expect_match 

  第三行从用户那里接收任何以新行符结束的任何一行。最后一行把它 
返回给标准输出。如果在特定的时间内没有得到任何键入,则返回也为空。 

  第一行支持"#!"的系统直接的启动脚本。(如果把脚本的属性加上可执 
行属性则不要在脚本前面加上expect)。当然了脚本总是可以显式的用 
"expect scripot"来启动。在-c后面的选项在任何脚本语句执行前就被执行。 
比如说,不要修改脚本本身,仅仅在命令行上加上-c "trace…",该脚本可 
以加上trace功能了(省略号表示trace的选项)。 

  在命令行里实际上可以加上多个命令,只要中间以";"分开就可以了。 
比如说,下面这个命令行: 

expect -c "set timeout 20;spawn foo;expect" 

一旦你把超时时限设置好而且程序启动之后,expect就开始等待文件 
结束符或者20秒的超时时限。 如果遇到了文件结束符(EOF),该程序就会停 
下来,然后expect返回。如果是遇到了超时的情况,expect就返回。在这两 
中情况里面,都隐式的杀死了当前进程。 

  如果我们不使用expect而来实现以上两个例子的功能的话,我们还是可 
以学习到很多的东西的。在这两中情况里面,通常的解决方案都是fork另一个 
睡眠的子进程并且用signal通知原来的shell。如果这个过程或者读先发生的 
话,shell就会杀司那个睡眠的进程。 传递pid和防止后台进程产生启动信息 
是一个让除了高手级shell程序员之外的人头痛的事情。提供一个通用的方法 
来象这样启动多个进程会使shell脚本非常的复杂。 所以几乎可以肯定的是, 
程序员一般都用一个专门C程序来解决这样一个问题。 

expect_user,send_user,send_error(向标准错误终端输出)在比较长 
的,用来把从进程来的复杂交互翻译成简单交互的expect脚本里面使用的比较 
频繁。在参考[7]里面,Libs描述怎样用脚本来安全的包裹(wrap)adb,怎样 
把系统管理员从需要掌握adb的细节里面解脱出来,同时大大的降低了由于错 
误的击键而导致的系统崩溃。 

一个简单的例子能够让ftp自动的从一个私人的帐号里面取文件。在这 
种情况里,要求提供密码。 即使文件的访问是受限的,你也应该避免把密码 
以明文的方式存储在文件里面。把密码作为脚本运行时的参数也是不合适的, 
因为用ps命令能看到它们。有一个解决的方法就是在脚本运行的开始调用 
expect_user来让用户输入以后可能使用的密码。这个密码必须只能让这个脚 
本知道,即使你是每个小时都要重试ftp。 

即使信息是立即输入进去的,这个技巧也是非常有用。比如说,你可 
以写一个脚本,把你每一个主机上不同的帐号上的密码都改掉,不管他们使用 
的是不是同一个密码数据库。如果你要手工达到这样一个功能的话,你必须 
Telnet到每一个主机上,并且手工输入新的密码。而使用expect,你可以只输 
入密码一次而让脚本来做其它的事情。 

expect_user和interact也可以在一个脚本里面混合的使用。考虑一下 
在调试一个程序的循环时,经过好多步之后才失败的情况。一个expect脚本 
可以驱动哪个调试器,设置好断点,执行该程序循环的若干步,然后将控制 
返回给键盘。它也可以在返回控制之前,在循环体和条件测试之间来回的切 
换。  

原文:http://fanqiang.chinaunix.net/a4/b8/20010912/1000001278.html

阅读全文

awk ‘ pattern {action} ‘

变量名 含义
argc 命令行变元个数
argv 命令行变元数组
filename 当前输入文件名
fnr 当前文件中的记录号
fs 输入域分隔符,默认为一个空格
rs 输入记录分隔符
nf 当前记录里域个数
NR 到目前为止记录数
OFS 输出域分隔符
ORS 输出记录分隔符
1、awk ‘/101/’ file 显示文件file中包含101的匹配行。

awk ‘/101/,/105/’ file
awk ‘$1 == 5’ file
awk ‘$1 == “CT”‘ file 注意必须带双引号
awk ‘$1 * $2 >100 ‘ file
awk ‘$2 >5 && $2<=15’ file
2、awk ‘{print NR,NF,$1,$NF,}’ file 显示文件file的当前记录号、域数和每一行的第一个和最后一个域。
awk ‘/101/ {print $1,$2 + 10}’ file 显示文件file的匹配行的第一、二个域加10。
awk ‘/101/ {print $1$2}’ file
awk ‘/101/ {print $1 $2}’ file 显示文件file的匹配行的第一、二个域,但显示时域中间没有分隔符。
3、df | awk ‘$4>1000000 ‘

通过管道符获得输入,如:显示第4个域满足条件的行。
4、awk -F “|” ‘{print $1}’ file

按照新的分隔符“|”进行操作。
awk ‘BEGIN { FS=”[: \t|]” } {print $1,$2,$3}’ file

通过设置输入分隔符(FS=”[: \t|]”)修改输入分隔符。
Sep=”|”
awk -F $Sep ‘{print $1}’ file 按照环境变量Sep的值做为分隔符。
awk -F ‘[ :\t|]’ ‘{print $1}’ file 按照正则表达式的值做为分隔符,这里代表空格、:、TAB、|同时做为分隔符。
awk -F ‘[][]’ ‘{print $1}’ file 按照正则表达式的值做为分隔符,这里代表[、]

5、awk -f awkfile file 通过文件awkfile的内容依次进行控制。
cat awkfile /101/{print “\047 Hello! \047″} –遇到匹配行以后打印 ‘ Hello! ‘.\047代表单引号。
{print $1,$2} –因为没有模式控制,打印每一行的前两个域。
6、awk ‘$1 ~ /101/ {print $1}’ file 显示文件中第一个域匹配101的行(记录)。
7、awk ‘BEGIN { OFS=”%”} {print $1,$2}’ file

通过设置输出分隔符(OFS=”%”)修改输出格式。
8、awk ‘BEGIN { max=100 ;print “max=” max} BEGIN

表示在处理任意行之前进行的操作。
{max=($1 >max ?$1:max); print $1,”Now max is “max}’ file

取得文件第一个域的最大值。
(表达式1?表达式2:表达式3 相当于:
if (表达式1)
表达式2
else
表达式3
awk ‘{print ($1>4 ? “high “$1: “low “$1)}’ file
9、awk ‘$1 * $2 >100 {print $1}’ file

显示文件中第一个域匹配101的行(记录)。
10、awk ‘{$1 == ‘Chi’ {$3 = ‘China’; print}’ file

找到匹配行后先将第3个域替换后再显示该行(记录)。
awk ‘{$7 %= 3; print $7}’ file

将第7域被3除,并将余数赋给第7域再打印。
11、awk ‘/tom/ {wage=$2+$3; printf wage}’ file

找到匹配行后为变量wage赋值并打印该变量。
12、awk ‘/tom/ {count++;}
END {print “tom was found “count” times”}’ file END

表示在所有输入行处理完后进行处理。
13、awk ‘gsub(/\$/,””);gsub(/,/,””); cost+=$4;
END {print “The total is $” cost> “filename”}’ file

gsub函数用空串替换$和,再将结果输出到filename中。
1 2 3 $1,200.00
1 2 3 $2,300.00
1 2 3 $4,000.00
awk ‘{gsub(/\$/,””);gsub(/,/,””);
if ($4>1000&&$4<2000) c1+=$4;
else if ($4>2000&&$4<3000) c2+=$4;
else if ($4>3000&&$4<4000) c3+=$4;
else c4+=$4; }
END {printf “c1=[%d];c2=[%d];c3=[%d];c4=[%d]\n”,c1,c2,c3,c4}”‘ file
通过if和else if完成条件语句
awk ‘{gsub(/\$/,””);gsub(/,/,””);
if ($4>3000&&$4<4000) exit;
else c4+=$4; }
END {printf “c1=[%d];c2=[%d];c3=[%d];c4=[%d]\n”,c1,c2,c3,c4}”‘ file
通过exit在某条件时退出,但是仍执行END操作。
awk ‘{gsub(/\$/,””);gsub(/,/,””);
if ($4>3000) next;
else c4+=$4; }
END {printf “c4=[%d]\n”,c4}”‘ file
通过next在某条件时跳过该行,对下一行执行操作。
14、awk ‘{ print FILENAME,$0 }’ file1 file2 file3>fileall

把file1、file2、file3的文件内容全部写到fileall中,格式为打印文件并前置文件名。
15、awk ‘ $1!=previous { close(previous); previous=$1 }
{print substr($0,index($0,” “) +1)>$1}’ fileall

把合并后的文件重新分拆为3个文件。并与原文件一致。
16、awk ‘BEGIN {“date”|getline d; print d}’

通过管道把date的执行结果送给getline,并赋给变量d,然后打印。
17、awk ‘BEGIN {system(“echo \”Input your name:\\c\””); getline d;print “\nYour name is”,d,”\b!\n”}’
通过getline命令交互输入name,并显示出来。
awk ‘BEGIN {FS=”:”;while(getline< “/etc/passwd” >0) { if($1~”050[0-9]_”) print $1}}’
打印/etc/passwd文件中用户名包含050x_的用户名。
18、awk ‘{ i=1;while(i

awk ‘{ for(i=1;i

type file|awk -F “/” ‘
{ for(i=1;i
{ if(i==NF-1) { printf “%s”,$i }
else { printf “%s/”,$i } })’

显示一个文件的全路径。

用for和if显示日期
awk ‘BEGIN {
for(j=1;j<=12;j++)
{ flag=0;
printf “\n%d月份\n”,j;
for(i=1;i<=31;i++)
{
if (j==2&&i>28) flag=1;
if ((j==4||j==6||j==9||j==11)&&i>30) flag=1;
if (flag==0) {printf “%02d%02d “,j,i}
}
}
}’
19、在awk中调用系统变量必须用单引号,如果是双引号,则表示字符串
Flag=abcd
awk ‘{print ‘$Flag’}’ 结果为abcd
awk ‘{print “$Flag”}’ 结果为$Flag

原文:http://www.ixdba.net/hbcms/article/19/355.html

阅读全文

SED单行脚本快速参考(Unix 流编辑器)                       2005年12月29日

英文标题:USEFUL ONE-LINE SCRIPTS FOR SED (Unix stream editor)
原标题:HANDY ONE-LINERS FOR SED (Unix stream editor)

整理:Eric Pement  – 电邮:pemente[at]northpark[dot]edu         版本5.5
译者:Joe Hong     – 电邮:hq00e[at]126[dot]com

在以下地址可找到本文档的最新(英文)版本:
http://sed.sourceforge.net/sed1line.txt
http://www.pement.org/sed/sed1line.txt

其他语言版本:
  中文          – http://sed.sourceforge.net/sed1line_zh-CN.html
  捷克语        – http://sed.sourceforge.net/sed1line_cz.html
  荷语          – http://sed.sourceforge.net/sed1line_nl.html
  法语          – http://sed.sourceforge.net/sed1line_fr.html
  德语          – http://sed.sourceforge.net/sed1line_de.html

  葡语          – http://sed.sourceforge.net/sed1line_pt-BR.html

文本间隔:
——–

# 在每一行后面增加一空行
sed G

# 将原来的所有空行删除并在每一行后面增加一空行。
# 这样在输出的文本中每一行后面将有且只有一空行。
sed ‘/^$/d;G’

# 在每一行后面增加两行空行
sed ‘G;G’

# 将第一个脚本所产生的所有空行删除(即删除所有偶数行)
sed ‘n;d’

# 在匹配式样“regex”的行之前插入一空行
sed ‘/regex/{x;p;x;}’

# 在匹配式样“regex”的行之后插入一空行
sed ‘/regex/G’

# 在匹配式样“regex”的行之前和之后各插入一空行
sed ‘/regex/{x;p;x;G;}’

编号:
——–

# 为文件中的每一行进行编号(简单的左对齐方式)。这里使用了“制表符”
# (tab,见本文末尾关于’\t’的用法的描述)而不是空格来对齐边缘。
sed = filename | sed ‘N;s/\n/\t/’

# 对文件中的所有行编号(行号在左,文字右端对齐)。
sed = filename | sed ‘N; s/^/     /; s/ *\(.\{6,\}\)\n/\1  /’

# 对文件中的所有行编号,但只显示非空白行的行号。
sed ‘/./=’ filename | sed ‘/./N; s/\n/ /’

# 计算行数 (模拟 "wc -l")
sed -n ‘$=’

文本转换和替代:
——–

# Unix环境:转换DOS的新行符(CR/LF)为Unix格式。
sed ‘s/.$//’                     # 假设所有行以CR/LF结束
sed ‘s/^M$//’                    # 在bash/tcsh中,将按Ctrl-M改为按Ctrl-V
sed ‘s/\x0D$//’                  # ssed、gsed 3.02.80,及更高版本

# Unix环境:转换Unix的新行符(LF)为DOS格式。
sed "s/$/echo -e \\\r/"        # 在ksh下所使用的命令
sed ‘s/$’"/echo \\\r/"         # 在bash下所使用的命令
sed "s/$/echo \\\r/"           # 在zsh下所使用的命令
sed ‘s/$/\r/’                    # gsed 3.02.80 及更高版本

# DOS环境:转换Unix新行符(LF)为DOS格式。
sed "s/$//"                      # 方法 1
sed -n p                         # 方法 2

# DOS环境:转换DOS新行符(CR/LF)为Unix格式。
# 下面的脚本只对UnxUtils sed 4.0.7 及更高版本有效。要识别UnxUtils版本的
#  sed可以通过其特有的“–text”选项。你可以使用帮助选项(“–help”)看
# 其中有无一个“–text”项以此来判断所使用的是否是UnxUtils版本。其它DOS
# 版本的的sed则无法进行这一转换。但可以用“tr”来实现这一转换。
sed "s/\r//" infile >outfile     # UnxUtils sed v4.0.7 或更高版本
tr -d \r <infile >outfile        # GNU tr 1.22 或更高版本

# 将每一行前导的“空白字符”(空格,制表符)删除
# 使之左对齐
sed ‘s/^[ \t]*//’                # 见本文末尾关于’\t’用法的描述

# 将每一行拖尾的“空白字符”(空格,制表符)删除
sed ‘s/[ \t]*$//’                # 见本文末尾关于’\t’用法的描述

# 将每一行中的前导和拖尾的空白字符删除
sed ‘s/^[ \t]*//;s/[ \t]*$//’

# 在每一行开头处插入5个空格(使全文向右移动5个字符的位置)
sed ‘s/^/     /’

# 以79个字符为宽度,将所有文本右对齐
sed -e :a -e ‘s/^.\{1,78\}$/ &/;ta’  # 78个字符外加最后的一个空格

# 以79个字符为宽度,使所有文本居中。在方法1中,为了让文本居中每一行的前
# 头和后头都填充了空格。 在方法2中,在居中文本的过程中只在文本的前面填充
# 空格,并且最终这些空格将有一半会被删除。此外每一行的后头并未填充空格。
sed  -e :a -e ‘s/^.\{1,77\}$/ & /;ta’                     # 方法1
sed  -e :a -e ‘s/^.\{1,77\}$/ &/;ta’ -e ‘s/\( *\)\1/\1/’  # 方法2

# 在每一行中查找字串“foo”,并将找到的“foo”替换为“bar”
sed ‘s/foo/bar/’                 # 只替换每一行中的第一个“foo”字串
sed ‘s/foo/bar/4’                # 只替换每一行中的第四个“foo”字串
sed ‘s/foo/bar/g’                # 将每一行中的所有“foo”都换成“bar”
sed ‘s/\(.*\)foo\(.*foo\)/\1bar\2/’ # 替换倒数第二个“foo”
sed ‘s/\(.*\)foo/\1bar/’            # 替换最后一个“foo”

# 只在行中出现字串“baz”的情况下将“foo”替换成“bar”
sed ‘/baz/s/foo/bar/g’

# 将“foo”替换成“bar”,并且只在行中未出现字串“baz”的情况下替换
sed ‘/baz/!s/foo/bar/g’

# 不管是“scarlet”“ruby”还是“puce”,一律换成“red”
sed ‘s/scarlet/red/g;s/ruby/red/g;s/puce/red/g’  #对多数的sed都有效
gsed ‘s/scarlet\|ruby\|puce/red/g’               # 只对GNU sed有效

# 倒置所有行,第一行成为最后一行,依次类推(模拟“tac”)。
# 由于某些原因,使用下面命令时HHsed v1.5会将文件中的空行删除
sed ‘1!G;h;$!d’               # 方法1
sed -n ‘1!G;h;$p’             # 方法2

# 将行中的字符逆序排列,第一个字成为最后一字,……(模拟“rev”)
sed ‘/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//’

# 将每两行连接成一行(类似“paste”)
sed ‘$!N;s/\n/ /’

# 如果当前行以反斜杠“\”结束,则将下一行并到当前行末尾
# 并去掉原来行尾的反斜杠
sed -e :a -e ‘/\\$/N; s/\\\n//; ta’

# 如果当前行以等号开头,将当前行并到上一行末尾
# 并以单个空格代替原来行头的“=”
sed -e :a -e ‘$!N;s/\n=/ /;ta’ -e ‘P;D’

# 为数字字串增加逗号分隔符号,将“1234567”改为“1,234,567”
gsed ‘:a;s/\B[0-9]\{3\}\>/,&/;ta’                     # GNU sed
sed -e :a -e ‘s/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta’  # 其他sed

# 为带有小数点和负号的数值增加逗号分隔符(GNU sed)
gsed -r ‘:a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta’

# 在每5行后增加一空白行 (在第5,10,15,20,等行后增加一空白行)
gsed ‘0~5G’                      # 只对GNU sed有效
sed ‘n;n;n;n;G;’                 # 其他sed

选择性地显示特定行:
——–

# 显示文件中的前10行 (模拟“head”的行为)
sed 10q

# 显示文件中的第一行 (模拟“head -1”命令)
sed q

# 显示文件中的最后10行 (模拟“tail”)
sed -e :a -e ‘$q;N;11,$D;ba’

# 显示文件中的最后2行(模拟“tail -2”命令)
sed ‘$!N;$!D’

# 显示文件中的最后一行(模拟“tail -1”)
sed ‘$!d’                        # 方法1
sed -n ‘$p’                      # 方法2

# 显示文件中的倒数第二行
sed -e ‘$!{h;d;}’ -e x              # 当文件中只有一行时,输入空行
sed -e ‘1{$q;}’ -e ‘$!{h;d;}’ -e x  # 当文件中只有一行时,显示该行
sed -e ‘1{$d;}’ -e ‘$!{h;d;}’ -e x  # 当文件中只有一行时,不输出

# 只显示匹配正则表达式的行(模拟“grep”)
sed -n ‘/regexp/p’               # 方法1
sed ‘/regexp/!d’                 # 方法2

# 只显示“不”匹配正则表达式的行(模拟“grep -v”)
sed -n ‘/regexp/!p’              # 方法1,与前面的命令相对应
sed ‘/regexp/d’                  # 方法2,类似的语法

# 查找“regexp”并将匹配行的上一行显示出来,但并不显示匹配行
sed -n ‘/regexp/{g;1!p;};h’

# 查找“regexp”并将匹配行的下一行显示出来,但并不显示匹配行
sed -n ‘/regexp/{n;p;}’

# 显示包含“regexp”的行及其前后行,并在第一行之前加上“regexp”所
# 在行的行号 (类似“grep -A1 -B1”)
sed -n -e ‘/regexp/{=;x;1!p;g;$!N;p;D;}’ -e h

# 显示包含“AAA”、“BBB”或“CCC”的行(任意次序)
sed ‘/AAA/!d; /BBB/!d; /CCC/!d’  # 字串的次序不影响结果

# 显示包含“AAA”、“BBB”和“CCC”的行(固定次序)
sed ‘/AAA.*BBB.*CCC/!d’

# 显示包含“AAA”“BBB”或“CCC”的行 (模拟“egrep”)
sed -e ‘/AAA/b’ -e ‘/BBB/b’ -e ‘/CCC/b’ -e d    # 多数sed
gsed ‘/AAA\|BBB\|CCC/!d’                        # 对GNU sed有效

# 显示包含“AAA”的段落 (段落间以空行分隔)
# HHsed v1.5 必须在“x;”后加入“G;”,接下来的3个脚本都是这样
sed -e ‘/./{H;$!d;}’ -e ‘x;/AAA/!d;’

# 显示包含“AAA”“BBB”和“CCC”三个字串的段落 (任意次序)
sed -e ‘/./{H;$!d;}’ -e ‘x;/AAA/!d;/BBB/!d;/CCC/!d’

# 显示包含“AAA”、“BBB”、“CCC”三者中任一字串的段落 (任意次序)
sed -e ‘/./{H;$!d;}’ -e ‘x;/AAA/b’ -e ‘/BBB/b’ -e ‘/CCC/b’ -e d
gsed ‘/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d’         # 只对GNU sed有效

# 显示包含65个或以上字符的行
sed -n ‘/^.\{65\}/p’

# 显示包含65个以下字符的行
sed -n ‘/^.\{65\}/!p’            # 方法1,与上面的脚本相对应
sed ‘/^.\{65\}/d’                # 方法2,更简便一点的方法

# 显示部分文本——从包含正则表达式的行开始到最后一行结束
sed -n ‘/regexp/,$p’

# 显示部分文本——指定行号范围(从第8至第12行,含8和12行)
sed -n ‘8,12p’                   # 方法1
sed ‘8,12!d’                     # 方法2

# 显示第52行
sed -n ’52p’                     # 方法1
sed ’52!d’                       # 方法2
sed ’52q;d’                      # 方法3, 处理大文件时更有效率

# 从第3行开始,每7行显示一次   
gsed -n ‘3~7p’                   # 只对GNU sed有效
sed -n ‘3,${p;n;n;n;n;n;n;}’     # 其他sed

# 显示两个正则表达式之间的文本(包含)
sed -n ‘/Iowa/,/Montana/p’       # 区分大小写方式

选择性地删除特定行:
——–

# 显示通篇文档,除了两个正则表达式之间的内容
sed ‘/Iowa/,/Montana/d’

# 删除文件中相邻的重复行(模拟“uniq”)
# 只保留重复行中的第一行,其他行删除
sed ‘$!N; /^\(.*\)\n\1$/!P; D’

# 删除文件中的重复行,不管有无相邻。注意hold space所能支持的缓存
# 大小,或者使用GNU sed。
sed -n ‘G; s/\n/&&/; /^\([ -~]*\n\).*\n\1/d; s/\n//; h; P’

# 删除除重复行外的所有行(模拟“uniq -d”)
sed ‘$!N; s/^\(.*\)\n\1$/\1/; t; D’

# 删除文件中开头的10行
sed ‘1,10d’

# 删除文件中的最后一行
sed ‘$d’

# 删除文件中的最后两行
sed ‘N;$!P;$!D;$d’

# 删除文件中的最后10行
sed -e :a -e ‘$d;N;2,10ba’ -e ‘P;D’   # 方法1
sed -n -e :a -e ‘1,10!{P;N;D;};N;ba’  # 方法2

# 删除8的倍数行
gsed ‘0~8d’                           # 只对GNU sed有效
sed ‘n;n;n;n;n;n;n;d;’                # 其他sed

# 删除匹配式样的行
sed ‘/pattern/d’                      # 删除含pattern的行。当然pattern
                                       # 可以换成任何有效的正则表达式

# 删除文件中的所有空行(与“grep ‘.’ ”效果相同)
sed ‘/^$/d’                           # 方法1
sed ‘/./!d’                           # 方法2

# 只保留多个相邻空行的第一行。并且删除文件顶部和尾部的空行。
# (模拟“cat -s”)
sed ‘/./,/^$/!d’        #方法1,删除文件顶部的空行,允许尾部保留一空行
sed ‘/^$/N;/\n$/D’      #方法2,允许顶部保留一空行,尾部不留空行

# 只保留多个相邻空行的前两行。
sed ‘/^$/N;/\n$/N;//D’

# 删除文件顶部的所有空行
sed ‘/./,$!d’

# 删除文件尾部的所有空行
sed -e :a -e ‘/^\n*$/{$d;N;ba’ -e ‘}’  # 对所有sed有效
sed -e :a -e ‘/^\n*$/N;/\n$/ba’        # 同上,但只对 gsed 3.02.*有效

# 删除每个段落的最后一行
sed -n ‘/^$/{p;h;};/./{x;/./p;}’

特殊应用:
——–

# 移除手册页(man page)中的nroff标记。在Unix System V或bash shell下使
# 用’echo’命令时可能需要加上 -e 选项。
sed "s/.echo \\\b//g"    # 外层的双括号是必须的(Unix环境)
sed ‘s/.^H//g’             # 在bash或tcsh中, 按 Ctrl-V 再按 Ctrl-H
sed ‘s/.\x08//g’           # sed 1.5,GNU sed,ssed所使用的十六进制的表示方法

# 提取新闻组或 e-mail 的邮件头
sed ‘/^$/q’                # 删除第一行空行后的所有内容

# 提取新闻组或 e-mail 的正文部分
sed ‘1,/^$/d’              # 删除第一行空行之前的所有内容

# 从邮件头提取“Subject”(标题栏字段),并移除开头的“Subject:”字样
sed ‘/^Subject: */!d; s///;q’

# 从邮件头获得回复地址
sed ‘/^Reply-To:/q; /^From:/h; /./d;g;q’

# 获取邮件地址。在上一个脚本所产生的那一行邮件头的基础上进一步的将非电邮
# 地址的部分剃除。(见上一脚本)
sed ‘s/ *(.*)//; s/>.*//; s/.*[:<] *//’

# 在每一行开头加上一个尖括号和空格(引用信息)
sed ‘s/^/> /’

# 将每一行开头处的尖括号和空格删除(解除引用)
sed ‘s/^> //’

# 移除大部分的HTML标签(包括跨行标签)
sed -e :a -e ‘s/<[^>]*>//g;/</N;//ba’

# 将分成多卷的uuencode文件解码。移除文件头信息,只保留uuencode编码部分。
# 文件必须以特定顺序传给sed。下面第一种版本的脚本可以直接在命令行下输入;
# 第二种版本则可以放入一个带执行权限的shell脚本中。(由Rahul Dhesi的一
# 个脚本修改而来。)
sed ‘/^end/,/^begin/d’ file1 file2 … fileX | uudecode   # vers. 1
sed ‘/^end/,/^begin/d’ "$@" | uudecode                    # vers. 2

# 将文件中的段落以字母顺序排序。段落间以(一行或多行)空行分隔。GNU sed使用
# 字元“\v”来表示垂直制表符,这里用它来作为换行符的占位符——当然你也可以
# 用其他未在文件中使用的字符来代替它。
sed ‘/./{H;d;};x;s/\n/={NL}=/g’ file | sort | sed ‘1s/={NL}=//;s/={NL}=/\n/g’
gsed ‘/./{H;d};x;y/\n/\v/’ file | sort | sed ‘1s/\v//;y/\v/\n/’

# 分别压缩每个.TXT文件,压缩后删除原来的文件并将压缩后的.ZIP文件
# 命名为与原来相同的名字(只是扩展名不同)。(DOS环境:“dir /b”
# 显示不带路径的文件名)。
echo @echo off >zipup.bat
dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1 \1.TXT/" >>zipup.bat

使用SED:Sed接受一个或多个编辑命令,并且每读入一行后就依次应用这些命令。
当读入第一行输入后,sed对其应用所有的命令,然后将结果输出。接着再读入第二
行输入,对其应用所有的命令……并重复这个过程。上一个例子中sed由标准输入设
备(即命令解释器,通常是以管道输入的形式)获得输入。在命令行给出一个或多
个文件名作为参数时,这些文件取代标准输入设备成为sed的输入。sed的输出将被
送到标准输出(显示器)。因此:

cat filename | sed ’10q’         # 使用管道输入
sed ’10q’ filename               # 同样效果,但不使用管道输入
sed ’10q’ filename > newfile     # 将输出转移(重定向)到磁盘上

要了解sed命令的使用说明,包括如何通过脚本文件(而非从命令行)来使用这些命
令,请参阅《sed & awk》第二版,作者Dale Dougherty和Arnold Robbins
(O’Reilly,1997;http://www.ora.com),《UNIX Text Processing》,作者
Dale Dougherty和Tim O’Reilly(Hayden Books,1987)或者是Mike Arst写的教
程——压缩包的名称是“U-SEDIT2.ZIP”(在许多站点上都找得到)。要发掘sed
的潜力,则必须对“正则表达式”有足够的理解。正则表达式的资料可以看
《Mastering Regular Expressions》作者Jeffrey Friedl(O’reilly 1997)。
Unix系统所提供的手册页(“man”)也会有所帮助(试一下这些命令
“man sed”、“man regexp”,或者看“man ed”中关于正则表达式的部分),但
手册提供的信息比较“抽象”——这也是它一直为人所诟病的。不过,它本来就不
是用来教初学者如何使用sed或正则表达式的教材,而只是为那些熟悉这些工具的人
提供的一些文本参考

括号语法:前面的例子对sed命令基本上都使用单引号(’…’)而非双引号
("…")这是因为sed通常是在Unix平台上使用。单引号下,Unix的shell(命令
解释器)不会对美元符($)和后引号(...)进行解释和执行。而在双引号下
美元符会被展开为变量或参数的值,后引号中的命令被执行并以输出的结果代替
后引号中的内容。而在“csh”及其衍生的shell中使用感叹号(!)时需要在其前
面加上转义用的反斜杠(就像这样:\!)以保证上面所使用的例子能正常运行
(包括使用单引号的情况下)。DOS版本的Sed则一律使用双引号("…")而不是
引号来圈起命令。

‘\t’的用法:为了使本文保持行文简洁,我们在脚本中使用’\t’来表示一个制表
符。但是现在大部分版本的sed还不能识别’\t’的简写方式,因此当在命令行中为
脚本输入制表符时,你应该直接按TAB键来输入制表符而不是输入’\t’。下列的工
具软件都支持’\t’做为一个正则表达式的字元来表示制表符:awk、perl、HHsed、
sedmod以及GNU sed v3.02.80。

不同版本的SED:不同的版本间的sed会有些不同之处,可以想象它们之间在语法上
会有差异。具体而言,它们中大部分不支持在编辑命令中间使用标签(:name)或分
支命令(b,t),除非是放在那些的末尾。这篇文档中我们尽量选用了可移植性较高
的语法,以使大多数版本的sed的用户都能使用这些脚本。不过GNU版本的sed允许使
用更简洁的语法。想像一下当读者看到一个很长的命令时的心情:

   sed -e ‘/AAA/b’ -e ‘/BBB/b’ -e ‘/CCC/b’ -e d

好消息是GNU sed能让命令更紧凑:

   sed ‘/AAA/b;/BBB/b;/CCC/b;d’      # 甚至可以写成
   sed ‘/AAA\|BBB\|CCC/b;d’

此外,请注意虽然许多版本的sed接受象“/one/ s/RE1/RE2/”这种在’s’前带有空
格的命令,但这些版本中有些却不接受这样的命令:“/one/! s/RE1/RE2/”。这时
只需要把中间的空格去掉就行了。

速度优化:当由于某种原因(比如输入文件较大、处理器或硬盘较慢等)需要提高
命令执行速度时,可以考虑在替换命令(“s/…/…/”)前面加上地址表达式来
提高速度。举例来说:

   sed ‘s/foo/bar/g’ filename         # 标准替换命令
   sed ‘/foo/ s/foo/bar/g’ filename   # 速度更快
   sed ‘/foo/ s//bar/g’ filename      # 简写形式

当只需要显示文件的前面的部分或需要删除后面的内容时,可以在脚本中使用“q”
命令(退出命令)。在处理大的文件时,这会节省大量时间。因此:

   sed -n ‘45,50p’ filename           # 显示第45到50行
   sed -n ’51q;45,50p’ filename       # 一样,但快得多

如果你有其他的单行脚本想与大家分享或者你发现了本文档中错误的地方,请发电
子邮件给本文档的作者(Eric Pement)。邮件中请记得提供你所使用的sed版本、
该sed所运行的操作系统及对问题的适当描述。本文所指的单行脚本指命令行的长
度在65个字符或65个以下的sed脚本〔译注1〕。本文档的各种脚本是由以下所列作
者所写或提供:

Al Aab                               # 建立了“seders”邮件列表
Edgar Allen                          # 许多方面
Yiorgos Adamopoulos                  # 许多方面
Dale Dougherty                       # 《sed & awk》作者
Carlos Duarte                        # 《do it with sed》作者
Eric Pement                          # 本文档的作者
Ken Pizzini                          # GNU sed v3.02 的作者
S.G. Ravenhall                       # 去html标签脚本
Greg Ubben                           # 有诸多贡献并提供了许多帮助
————————————————————————-

译注1:大部分情况下,sed脚本无论多长都能写成单行的形式(通过-e'选项和;’
号)——只要命令解释器支持,所以这里说的单行脚本除了能写成一行还对长度有
所限制。因为这些单行脚本的意义不在于它们是以单行的形式出现。而是让用户能
方便地在命令行中使用这些紧凑的脚本才是其意义所在。

原文:http://sed.sourceforge.net/sed1line_zh-CN.html

阅读全文