将这个脚本放在这里基于两个目的：

• 这个脚本中用了许多的循环结构可作为上一篇的补充。
• 同时这一篇用了模拟的数字运算——了解这种运算方法有助于以后学习一些经典的sed脚本或写出自已的算术脚本

by hq00e

# 打印斐波那契序列
# 文件名：fib.sed
# 调用：seq 10 | sed -f fib.sed  # 打印前10个数字
#       yes | sed -f fib.sed     # 打印序列直到溢出

# 这个脚本用模拟的方式进行数字运算。有关这种方法的更
# 多细节可以参考Greg Ubben写的教程：
# http://sed.sourceforge.net/grabbag/tutorials/

1{
# 下面字母串的长度决定了可打印的序列长度
# 可以修改下面的字串使之支持更多的序列
# s/.*/zyxwvutsrqponmlkjihgfedcba/
  s/.*/kjihgfedcba/
# 初始化序列为“1, 1”
  s/.*/ &a &a /; h; d
}

# 从hs取最后两组数字串进行运算
g
s/.* \(.*\) \(.*\) $/\1\2/

# 进行进位操作前先对两组数字加总（其实是排序）
s/\(\(.\)\2*\)/\1 /g
:lpsort
s/\(\([^ ]\)\2\{0,\}\)\( .*\)\2/\1\2\3/
tlpsort
s/ //g

# 调整加总的结果
# 加总时我们进行如下运算：
# edcbaa + edcbaaa = edcbaaaa
#    1   +    2    =     3
# 但实际在加总（排序）后我们等到的结果是：
# edcbaa + edcbaaa = eeddccbbaaaaa
# 我们需要将eeddccbbaaaaa转换为edcbaaaa

s/\(.\)\(\1\{1,19\}\)/\2/g

# 进行进位操作。
# baaaaaaaaaaa进位后成为bba——10

:doCarry
s/\(.\)\(\(.\)\3\{9\}\)\3/\1\1\3/
t doCarry

# 简单（粗糙）的溢出检验
# 因为第一个字母如果超过9个说明没有正常进位——即溢出
/^\(.\)\1\{9\}/{g;s/$/ ++OVERFLOW++/; b2digi}

# 将这一轮的结果保存到hold space。记得在最后加上一个空格。
G
s/\(.*\)\n\(.*\)/\2\1 /
$!{h;d}
g

# 运算完后将模拟结果转为数字表示的结果
:2digi
s/\([a-z]\)\1\{9\}/9/g
s/\([a-z]\)\1\{8\}/8/g
s/\([a-z]\)\1\{7\}/7/g
s/\([a-z]\)\1\{6\}/6/g
s/\([a-z]\)\1\{5\}/5/g
s/\([a-z]\)\1\{4\}/4/g
s/\([a-z]\)\1\{3\}/3/g
s/\([a-z]\)\1\1/2/g
s/\([a-z]\)\1/1/g
s/\([a-z]\)/0/g
s/ 0*/ /g
# 溢出检验需要q命令
q

[--结束--]

Table of Contents

• sed中的循环结构
  • 在sed中进行判断
    • 用holdspace储存标志位
    • 用pattern space储存标志位
    • 用地址进行判断
    • 用式样进行判断
  • 循环常用的命令解析
    • b/t控制循环
      • 退出条件
    • d/D控制循环
    • 标志位控件循环
    • N作为退出条件
  • 实例

sed中的循环结构

这篇文章粗略地总结了一些在sed进行循环操作的方法。的确是很粗糙但为了在农历年前放上就不管那么多了。
by hq00e

一些缩写
ps=pattern space，式样空间
hs=hold space，保留空间
regexp=regular expression， 正则表达式

循环都可以写为条件转移的形式。如C语言中的if加goto的形式，但这与结构化编程的思想相违背。因而C语言中通常用for\while来写循环语句。但在被编译后程序的机器代码仍是以条件转移的形式出现的。sed没有专门的循环语句，但提供了转移的命令，因而我们仍然可以实现循环。本篇中总结用sed进行循环的几种方式。sed处理文本的方式本身就是一种循环：

do while not EOF
 read line
   ... do sth
 end do。

在sed中进行判断

因为sed只处理字符和行号，它只能通过式样来作字串的匹配判断或者对行号进行判断。所以判断的条件需要以字串或行号的形式出现。

用holdspace储存标志位

在hs中存储字串作为标志位，如：

# 进行6次操作
1{x; s/^/654321/; x}
 :a
 x;
 /./{ s/.//; x; s/reg/ex/; ba}
 x;
 do sth else;

# 对每一行进行6次替换操作
1{x; s/^/654321/; x}
G
:a
/\n./{ s/reg/ex/; s/\n.$//; tb; s/.$//; ba}
:b
do sth else

用pattern space储存标志位

用pattern space(标志位附加在前面或后面)，与hs的方式基本一样只是将标志位放在ps中。

1{ s/^/654321\n/ }
:a
/.\n/{ s/.//; s/reg/ex/; ba }
do sth else

用地址进行判断

地址（常用的地址是1,$）。当循环的条件与地址或行号有关时可以以这种方式。

sed '/./{H;d};x;/re/p' # 显示某个段落
2,8{H;d}; $G  # 类似ed中的:2,8m$。d在这里有两个作用a清空PS。b强制进入下一cycle。

用式样进行判断

以当前ps的内容作为判断的标准，当循环条件与输入的内容有关时可以用这种方法。这样方法与标志位的方法相似，所不同的是我们并不人为地设置标志而是以当前ps的内容作为标志。请参考下面的例子：

:a
 do sth with regexp
/regexp/ba

如果中间有s命令我们常用t来跳转，因而上面的可以写为：
:a
s/regexp/blah/
ta

循环常用的命令解析

q, b, t, T, d, n, N, :label

b/t控制循环

b都是sed中的分支（跳转）命令。它的格式是`b label’，也可以去掉中间的空格，写作`blabel’。上面命令的作用是从:label处继续执行脚本。label必须在脚本中定义，方法是在前面加上冒号（:），如`:loop’`:lable’。大部分sed对标签的长度有限制，具体的限制可以参考sed faq。如果b后没有带标签，则默认转到脚本结束处。
要注意的是许多的sed不允许在后面接其他命令因而：
gsed 'b abc;s/^/eee/;:abc;…'
这样的命令在其他版本的sed中要写成：

sed 'b abc
      s/^/eee/
     :abc'
或：
sed -e 'b abc' -e 's/^/eee/; :abc'

t命令与b相似。不同点在于t是以前s命令的成功与否来决定是否跳转，如成功则跳转。如果在一个s命令后使用了多个条件跳转则第二个及其后的t都会失败。gnu sed还提供了与t相反的T命令。

$ echo abc|sed 's/a/a/;bb;:b;tc;s/^/zzz/;:c'
abc

$ echo abc|sed 's/a/a/;tb;:b;tc;s/^/zzz/;:c'
zzzabc

$ echo abc|sed 's/a/a/;tb;:b;tc;s/^/zzz/;:c'
zzzabc

b/t控制循环：
s/re/&/;t
s/re/&/;T
与
/re/b
/re/!b
是等价的。但在下面的内容中我们会看到s/t的组合可以用在一些更复杂的情况。

当作用b进行循环时常用下面的方式退出循环：
在b前使用式样或地址（循环条件）：

:a
...
/regexp/ba

上面的情况通常要求中间的语句对/regexp/进行修改或有另外的退出命令，才不会成为死循环。

退出条件

使用b/t循环时，为了避免出现死循环通常要设置退出的条件。如：

:a
...
/xxx/b
...
/regexp/ba

除了用b外还可以用t, N, q, d作为退出的命令，用式样或行号作为退出的条件。当前面有成功的替换时，可用`t’转移动脚本中的任意位置——当然也可以跳出循环体。在最后一行使用N会退出脚本，利用这一点我们可以退出循环体。不过不同版本的sed在最后一行使用`N’时的结果不同——有的会显示ps的内容，有的则不会。`q’命令用来退出脚本，当然也就不会再循环了。`d’和`D’命令的副作用是强制脚本进入下cycle，这使得我们可以用这两个命令来形成行与行之间的循环，如果下一循环中不满足循环的进入条件则循环中止——所以这两个命令既是进行循环的命令也是退出的命令。当然这些行前面都可以使用式样或行号作为运行命令的条件。

如果中间的语句没有对/regexp/修改则结果类似：

:a
...
ba

例：要将输入中#号后的所有xxx删除。

输入：
abc#efxxxghxxxxijxxx
输出：
abc#efghxij

sed ':a
s/\(#.*\)xxx/\1/  # 修改了循环标志
/#.*xxx/ba'

当然这时t可以派上用场了：

sed ':a; s/\(#.*\)xxx/\1/; ta'

下面是一些实例：

echo -e "abc\nefg" | sed ':a;/re/b;ba'
echo -e "abc\nefg" | sed ':a;/re/!b;ba'
echo -e "abc\nefg" | sed ':a;s/re/&/;t;ba'
echo -e "abc\nefg" | gsed ':a;s/re/&/;T;ba'
用以控制循环：
echo -e "abc\nefg" | sed ':a;/re/ba'
echo -e "abc\nefg" | sed ':a;/re/!ba'
echo -e "abc\nefg" | sed ':a;s/re/&/;ta'
echo -e "abc\nefg" | sed ':a;s/re/&/;Ta'
echo -e "abc\nefg" | sed '/re/b; :'

d/D控制循环

用d来控制循环也是sed脚本中比较常用的技巧。d之所以能用来控制循环主要是因为它在删除完之后不会执行接下来的命令而会直接进入下一个cycle中。例：

sed 'd; s/^/abc/' # s命令将不会被执行

标志位控件循环

在前面我们已经说过sed中进行条件判断的一些方法。这些方法除了是进入循环的条件也可以作为退出循环的条件。这里举个例子：

G;s/$/123456789/ # 循环9次
:loop
s/\n$//;t break  # 退出循环
... do sth       # 进行操作
s/.$//           # 减一操作
b loop           # next

N作为退出条件

N添加下一行到当前PS。如果在最后一行时运行了N，sed通常会退出。如果在循环中使用则会退出循环。需要注意的是不同的N对最后一行的处理是不同的，一些版本在最后一行执行N时会安静的退出。而另一些版本如GNU sed将会默认显示PS的内容再退出。
见下面的例子：

echo -e "abc\nefg" | sed ':a;ba'
echo -e "abc\nefg" | sed ':a;n;ba'
echo -e "abc\nefg" | sed ':a;N;ba'
echo -e "abc\nefg" | sed ':a;$!n;ba'
echo -e "abc\nefg" | sed ':a;$!N;ba'

第一个例子中sed会进入死循环。第二三个例子会正常退出。其中第二个例子会显示输入，而第三个例子的行为与sed的版本有关，GNU sed会显示输入。最后一个例子会进入死循环，前面说过在$!N可以让N在所有的sed版本中显示结果。但仍要判断使用的时机。

实例

在sed中使用循环的例子相当多，这里举几例。

# “sed单行脚本”中的一个例子
# 以79个字符为宽度，将所有文本右对齐
sed -e :a -e 's/^.\{1,78\}$/ &/;ta'  # 78个字符外加最后的一个空格

# 类似ed中的:2,8m$。
# d在这里有两个作用，a、清空PS。b、强制进入下一cycle。
# do while 2<=linenum<=8; H; end do
sed '2,8{H;d}; $G'

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

PS: 以前的中文版本（5.4版）可以在我以前的Blog: hq00e.blogsome.com上找到。

`r'命令用来读入文本。与`a'的作用相似，但文本是放在独立的文件而不是放在脚本中。用`r'的好处在于将数据与脚本独立，使脚本更易读并且修改数据文件更方便。

用法

这是GNU sed自带文档中对`r'命令的说明：

`r filename’

Queue the contents of filename to be read and inserted into the output stream at the end of the current cycle, or when the next input line is read. Note that if filename cannot be read, it is treated as if it were an empty file, without any error indication.

GNU对这个命令进行了扩展：

• 接受两个地址。可以对一定的地址区间进行操作
• 允许使用/dev/stdin作为文件名
• 新增了一个`R'命令。这个命令用法与`r'一样但一次只读入一行。

另外一些需要注意的地方：

• 文件不能读取时，则当成空文件处理不会有出错信息。
• r 命令之后不能再使用其他命令，因而如果后面的命令要另起一行或以`-e'选项隔开。
• r是在当前的cycle结束后才在最后加入内容的，所以在无法在cycle中对读入的内容进行操作的。

实例

我一向认为一个例子比得上千言万语。看个例子先：现有一个网页要进行如下修改，在<head>中增加<meta>标签。在</body>标签前增加版权声明的标签。我们将要在</title>标签后的内容放在meta.tag中。将放在文件未尾的内容放在copyleft.tag中。里面的内容如下：

$ cat meta.tag
<meta name="description" content="...">
<meta name="keywords" content="..., ... ">

$ cat copyleft.tag
<div class="copyleft">
版权所有……
</div>

我们需要的命令是：

sed '/<\/title>/r meta.tag
      /<\/body>/{
            x
            r copyleft.tag
            G}'  samp.html

写成单行的形式就是：

sed -e '/<\/title>/r meta.tag' -e '/<\/body>/{x;r copyleft.tag' -e 'G}'  samp.html

如果你在Windows的命令行上使用的话，那就根据你所用的版本将单引号相应的改为双引号。不过请务必注意上面脚本是一个简化的情形，因为标签也可能有大写字母¹（虽然W3C的XHTML中要求标签必须是小写，但这种可能性是存在的视你自已的情况而定。）如果你用的是GNU sed的话那恭喜，你可以在式样后使用`I'修改符（modifier）：/<\/title>/I。否则：/<\/[tT][iI][tT][lL][eE]>/当然偶尔可以偷懒：/<\/[tT].[tT].[eE]>/。

实例：批量修改

当然我们想修改的通常不会只是一个文件，于是我们需要用到shell（注意文件的读写权限）：

$ for a in `find . -name "*.html"`
do
 mv $a $a.bak
 sed -e '/<\/title>/r meta.tag' -e '/<\/body>/{x;r copyleft.tag' -e 'G}' $a.bak >$a
done

find有一个-exec，但是如果参数太多会出错因而这里使用了for命令。
如果是Windows平台：

for /R %a in (*.html) do @copy %a %a.bak & @sed -e "..." %a.bak>%a

在批处理中使用时记得要用`%%'代替`%'。

如果你用的是GNU sed 4.0或以上版本，那你可以使用-i选项代替`mv'命令：

$ for a in `find . -name "*.html"`
do
 gsed -i.bak -e '
       /<\/title>/r meta.tag
       /<\/body>/{
          x
          r copyleft.tag
          G}' $a
done

这个sed脚本是用来解sudoku字迷的。sudoku中玩家要根据给定的几个数字，对空格进行填充。使得每一行每一列中都有数字1到9，并且每个小正方形中的也必须有1到9（可参考下面的图）。老实说在见到这个脚本之前，我根本不知道有这种游戏。后来找了个线上sudoku用简单级玩了一下，成绩……。可以在sudoku的网站上找到更多sudoku游戏的信息（当然也可以google一下）。

`sedoku’确实是个让人开眼界的sed程序/脚本，因为大多数人都将sed的应用局限在很小的范围内——谁会想到它也可以用来解数字字迷游戏呢？建议对sed有兴趣的话一定要收藏！

另外，sedoku脚本接收的输入要求以点“.”代替空格。所以像这样的字迷：

对应的文本格式应该为：

$ cat sudoku1
.3..1.89.
.1..96.5.
.654..7..
39..7....
84.6.1.73
....8..62
..9..564.
.8.76..1.
.57.4..2.

这是运行结果：

$ sed -f sedoku.sed sudoku1
234517896
718396254
965428731
396274185
842651973
571983462
129835647
483762519
657149328

[--结束--]

这里面用到了两个数组a和p，刚接触awk的人可以参考一下这里面数组的用法。个人认为使用数组可以大大地简化脚本。尤其是awk中对变量的类型没有严格限定，可以很容易地在数组的索引与值之间建立关联。

下面是脚本：

#!/usr/bin/gawk -f
# 1234567890 壹贰叁肆伍陆柒捌玖零
# 说明：单位以“亿亿”表示10的16次方，而“亿亿亿”表示
# 10的24次方，依此类推

# 自定义函数setunits()：为数字增加中文单位
# setunits(起始位，结束位，亿的个数， ...局部变量)
func setunits(off1,off2,state,   i,j){
	for(i=off2;i>=off1;i--) {
		if (off2-i==4) $i=$i "万"
		else if($i!="0") $i=$i p[(off2-i)%4]
	   }
	# 每8位state就增加1，用来控制单位中“亿”的个数。
	j=state; while(j--) $off2=$off2 "亿"
	# 退出条件
	if (off1==1) return
	else if (off1<=9) setunits(1,off1-1,++state)
	else setunits(off1-8,off1-1,++state)
}

# 自定义函数conv_num()：将数字转换为中文
# 定义局部变量i
func conv_num(  i){
	# 注意下面替换的顺序
	sub(/0*\./,"点")
	# 清除连续的0
	gsub(/0000万0000[亿]+/,"")
	gsub(/0000万/,"")
	gsub(/0+亿/,"亿")
	gsub(/0+万/,"万")
	gsub(/0+/,"0")
	sub(/^[亿万]+/,"")
	#清除首尾的0
	sub(/^00*/,"")
	sub(/00*$/,"")
	sub(/^$/,"零")
        sub(/^点/,"零点")
	# 替换阿拉伯数字为中文
        for(i in a) gsub(i-1,a[i])
}

# 主程序体 -------------------------
# 设置栏位的输入和输出的分隔符为空字串
BEGIN{  FS=OFS=""
	split("拾,佰,仟,万",p,",")
	split("零,壹,贰,叁,肆,伍,陆,柒,捌,玖",a,",")
     }

{ gsub(/,/,"") } #允许输入 123,456.789 的形式

# 验证输入。这里没有对多个小数点进行验证。
/^[-0-9][0-9.]*$/{ 

	# 判断正负
	isNeg=(sub(/^-/,""))

	# 小数点前的数字进行单位设置
	if (dotpos=index($0,".")) {
		of2=dotpos-1
		for (i=of2+2;i<=NF;i++) $i=a[$i+1]
	}else of2=NF
	if (of2>8) setunits(of2-7,of2,0)
	else setunits(1,of2,0)

	# 阿拉伯数字转为中文数字
	conv_num()

	# 还原正负号
	if (isNeg && $0!="零") print "负" $0
	else print
	}

# 程序结束 -------------------------

将上面的脚本保存为”chfig.awk”（当然你可以随意地命名）。这是运行结果：

hq00e@somewhere ~
$ echo 98.76543210|gawk -f chfig.awk
玖拾捌点柒陆伍肆叁贰壹零

hq00e@somewhere ~
$ echo -10000234000.060|gawk -f chfig.awk
负壹佰亿零贰拾叁万肆仟点零陆零

[--结束--]

Table of Contents

• 字母加总
  • 任务分析
  • 计算总和的脚本
  • 另一种实现方法
  • 显示特定总和值单词/词组的脚本。

字母加总

awk中的关联数组十分灵活方便。这一篇中将会涉及关联数组的用法。

–by hq00e

曾经看过这样的一个签名档：

如果将英语的26个字母由A到Z分别编上1到26的分数，
你的知识(KNOWLEDGE)只能得到11+14+15+23+12+5+4+7+5=96分。
你努力工作(HARDWORK)也只能得到8+1+18+4+23+15+18+11=98分。
只有你的态度(ATTITUDE)才是左右你生命全部的1+20+20+9+20+21+4+5=100分。

想知道还有哪些单词的总和是100吗？这知道答案很容易，只要你会用awk。所以这一次我们要写一个脚本来计算英文单词字母的总和。如果有字典文件还可以找出和为特定值的所有单词和词组。

任务分析

根据前面引用的签名档，字母A到Z将分别由数字1到26来表示——A=1,B=2,…,Z=26。不分大小写所以A=a=1。

• 首先，要对字母进行编号。方法有很多种，这里我们会使用awk中常用的技巧来完成编号。
• 其次，读入字母，并根据相应的编号进行加总。

只要两步——看来是个简单任务！现在开始想一想具体怎么用awk实现？或者（如果你对awk不是很熟的话）用其他编程语言怎么实现？

计算总和的脚本

首先，对字母编号。awk中为数组元素分配多个值常用的方法是用`split(STRING, ARRAY [, FIELDSEP])’函数。它的返回值是数组元互素的个数。需要注意的是：数组的下标是从`1′，而不是从`0′开始的。

	n=split("ABCDEFGHIJKLMNOPQRSTUVWXYZ",alpha,"")

这条语句会生成alpha数组，内容如下：alpha[1]="A";alpha[2]="B";...;alpha[26]="Z"。但我们需要的是以字母为索引找到对应的数值，而不是相反。所以还要进一步加工：

	while(n) { num_alpha[alpha[n]]=n; n--}

现在得到了一个关联数组num_alpha[]。内容如下：

num_alpha["A"]=1
num_alpha["B"]=2
...
num_alpha["Z"]=3

现在只要以输入的字母为索引就能得到对应的数值了。假设输入”ADD”，只要分别以“A”、“D”、“D”为索引加总：

  num_alpha["A"] + num_alpha["D"] + num_alpha["D"]
=       1        +      4         +       4
=       9

加总的脚本如下：

     {
       # 每读入一条记录时，先将总和归0
       sum=0
       # 将所有栏位的字母加总。非字母字符将被忽略，
       # 因为我们并未为非字母字符同值
       # 注意：这里用了toupper()。在gawk中还可以设置
       # IGNORECASE使之不区分大小写。
       for (i=1;i<=NF;i++) sum+=num_alpha[toupper($i)]
       # 输出计算结果
       print sum
     }

上面的脚本中并未对输入进行限定。如果输入含有非字母字符，脚本仅是忽略它们——因为在数组中没有相应的索引，所以不会对运算结果造成影响。但你可能希望对结果进行限定，使得只有当输入中只含字母和空格（词组）时才进行加总。为此我们可以用正则表达式对输入做简单的筛选：`/^[a-zA-Z ]+$/’¹。注意后面的空格。
具体实现如下：

gawk 'BEGIN{
   FS=""
   # split()的最后一个参数可省略，因为和FS是一样的
   n=split("ABCDEFGHIJKLMNOPQRSTUVWXYZ",alpha,"")
   while(n) { num_alpha[alpha[n]]=n; n-- }
  }
/^[a-zA-Z ]+$/{
   sum=0
   for (i=1;i<=NF;i++) sum+=num_alpha[toupper($i)]
   print sum
      }'

另一种实现方法

不过我们还可以将这个脚本写得更紧凑一点，我们需要有一种不同的思路。上一个脚本，我们预先计算每个字母对应的数值，但我们其实可以边加总边计算，即省略了数组这一中间过程。awk提供了一个函数`index(IN, FIND)’，用来返回`FIND’在`IN’中的位置。而“ABCD…Z”中字母的位置与各自的编号是一致的，因而可以以输入的字母为索引通过`index()’来实时计算总和。

gawk -vFS="" '{
    # 将FS设为空字串，这样每个字母都会被视为一个栏位。
   sum=0                  # 每读入一条记录时将sum置0
   for(i=1;i<=NF;i++)  # 将所有栏位相加
     sum+=index("ABCDEFGHIJKLMNOPQRSTUVWXYZ",toupper($i))
   print sum
 }'

下面是一些运行结果：

$ echo fortune|gawk -vFS="" '{sum=0;for(i=1;i<=NF;i++)sum+=index("ABCDEFGHIJKLM
NOPQRSTUVWXYZ",toupper($i));print sum}'
99

财富的确是很重要，看来比爱重要很多——用“love”运行的结果是“54”。不过建议试一下“love and care”——光有爱是不行的还要懂得关怀！

显示特定总和值单词/词组的脚本。

如果你有看上一篇并有找到合适的英汉字典的话，我们还可以让gawk替我们找出所有和为特定值的单词或短语。为此需要增加一条判断语句：

gawk -vFS="" '{        # 将FS设为空字串，这样每个字母都会被视为一个栏位。
   sum=0               # 每读入一条记录时将sum置0
   for(i=1;i<=NF;i++)  # 将所有栏位相加
     sum+=index("ABCDEFGHIJKLMNOPQRSTUVWXYZ",toupper($i))
   # 总和为100的话则输出当前记录（$0），当然你也可以改成其他值
   if (sum==100) print
 }'

当然我们还需要有字典文件，对我们之前用过的字典文件dict.txt²进行加工：
`cut -f1 dict.txt >voca.txt’
如果用的是Windows的话，你可能没有cut工具，那就用awk：

gawk -v FS="\t" "{print $1}" dict.txt >voca.txt

运行前面的脚本：

gawk -vFS="" '{...省略...}' voca.txt

这是脚本在Windows下的运行结果³：

e:\> gawk -vFS="" "{sum=0;for(i=1;i<=NF;i++)sum+=index(\"ABCDEFGHIJKLMNOPQRSTUVW
XYZ\",toupper($i));if(sum==100)print}" voca.txt
...省略
American oil
Anchicodium
Anglophobia
Anthozoa
Astralon
AutoMark
Avernus
Bar Draught
Bear steady!
Berlin blue
Bingham body
Bombay hemp
Bouma cycle
Butoxide
C battery cab
Carbolan dye
...省略

当然如果你不想输入那么长的脚本的话，可以将它放到单独的脚本文件中。

[–结束–]