awk命令详细说明

迈不过友情╰ 2022-12-15 04:00 758阅读 0赞

### 文章目录 ###

*  1 前言
 *  2 第一部分：入门
 *   *  2.1 第一个awk程序
     *  2.2 常用变量
     *  2.3 awk脚本
     *  2.3 表达式和运算符
     *  2.4 字符串化变量
 *  3 第二部分：提高
 *   *  3.1 处理多行
     *  3.2 条件语句
     *  3.3 循环语句
     *  3.4 数组
 *  4 第三部分：精通
 *   *  4.1 格式化输出
     *  4.2 字符串函数
 *  实例\_参考
 *   *  脚本执行方式
     *  输出文本中的1、4项
     *  指定分割字符
     *   *  使用单个","分割
         *  使用多个分隔符
     *  设置变量
     *  设置过滤条件
     *   *  匹配字符t
         *  过滤第一列参数等于this的行
         *  过滤第一列等于this并且第二列等于is的行
         *  输出第一列包含 th，并打印第一列与第四列
         *  输出包含 "is" 的行
     *  Awk的文本分行读取,和分行判断..
     *  忽略大小写
     *  模式取反
     *  从文件中找出长度大于 20 的行
     *  AWK实现计算方法
     *  Awk的列整理为行的格式
     *  Awk的牛闪闪用法(满足2个条件组成一行内容）
     *  打印99乘法表

# 1 前言 #

awk是一种非常好的语言，适合于文本处理和报表生成，它还有许多精心设计的特性，允许进行特殊技巧程序设计。对于短消息来说，比如处理话单文件，使用awk就非常方便，鉴于测试组大部分人对awk并不熟悉，因此仅以本文作一个提纲挈领的介绍，希望对初学者迅速掌握awk有所帮助。

# 2 第一部分：入门 #

## 2.1 第一个awk程序 ##

所有的编程书籍都是通过一个`“Hello world!”`简单程序入门，作为借鉴，本文也采用此方法带大家入门。现在，在当前目录下建立一个文本文件`hello.txt`，内容如下：

Hello world!

在命令行中输入以下命令：  
`awk '{ print }' hello.txt`  
执行后hello.txt文件的内容显示在屏幕上。编写并且执行awk程序的方法很简单，如上所示，花括号内的是程序代码，后面的hello.txt为指定的输入文件。awk是一种行处理程序，执行awk时，它依次对输入文件中的每一行执行花括号中的代码，如上面的例子，就是对hello.txt中的每一行执行print命令。所有输出都发送到stdout，最后在屏幕上显示的结果为Hello world!。  
上面的例子是将脚本作为命令行自变量传递给awk，我们也可以把脚本写入一个外部文件，然后通过-f选项向awk传递这个脚本文件。  
例如编写脚本文件`hello.ask`如下：

{  print }

然后通过如下方式执行：`awk -f hello.awk hello.txt`  
这种编写独立脚本文件的方式应用在多行、比较复杂的程序上，非常合适，而且，在后面你还将看到，这种方式还可以让你非常方便地使用附加awk功能。

## 2.2 常用变量 ##

awk有自己的特殊变量集合。其中一些允许调整awk的运行方式，而其它变量可以被读取以收集关于输入的有用信息。下面列举出最基本的几个常用变量，并用例子一一说明用法。

<table> 
 <thead> 
  <tr> 
   <th>Awk特殊变量</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>-v</code> var=value or --asign var=value</td> 
   <td>赋值一个用户定义变量。</td> 
  </tr> 
  <tr> 
   <td><code>$number</code></td> 
   <td>表示记录的字段。比如，<code>$1</code>表示第1个字段，<code>$2</code>表示第2个字段，如此类推。而<code>$0</code>比较特殊，表示整个当前行</td> 
  </tr> 
  <tr> 
   <td><code>FNR</code></td> 
   <td>各文件分别计数的行号</td> 
  </tr> 
  <tr> 
   <td><code>FS</code></td> 
   <td>缩写-F，表示字段分隔符（默认是任何空格），FS值并没有被限制为单一字符，可以通过指定任意长度的字符模式，将它设置成正则表达式。如果正在处理由一个或多个tab分隔的字段，可以按以下方式设置FS：<code>FS="\t+"</code></td> 
  </tr> 
  <tr> 
   <td><code>NF</code></td> 
   <td>叫做“字段数量”变量，表示当前记录中的字段数量</td> 
  </tr> 
  <tr> 
   <td><code>NR</code></td> 
   <td>表示当前记录的编号（awk将第一个记录算作记录号1），变量始终包含当前记录的编号（awk将第一个记录算作记录号1）。迄今为止，我们处理的输入文件每一行包含一个记录，对于这些情况，NR就是当前行号。可以象使用NF变量一样使用NR来只打印某些输入行：<code>(NR &lt; 10 ) || (NR &gt; 100) { print "We are on record number 1-9 or 101+" }</code></td> 
  </tr> 
  <tr> 
   <td><code>ARGC</code></td> 
   <td>命令行参数的数目</td> 
  </tr> 
  <tr> 
   <td><code>ARGIND</code></td> 
   <td>命令行中当前文件的位置(从0开始算)</td> 
  </tr> 
  <tr> 
   <td><code>ARGV</code></td> 
   <td>包含命令行参数的数组</td> 
  </tr> 
  <tr> 
   <td><code>CONVFMT</code></td> 
   <td>数字转换格式(默认值为%.6g)ENVIRON环境变量关联数组</td> 
  </tr> 
  <tr> 
   <td><code>ERRNO</code></td> 
   <td>最后一个系统错误的描述</td> 
  </tr> 
  <tr> 
   <td><code>FIELDWIDTHS</code></td> 
   <td>字段宽度列表(用空格键分隔)</td> 
  </tr> 
  <tr> 
   <td><code>FILENAME</code></td> 
   <td>当前文件名</td> 
  </tr> 
  <tr> 
   <td><code>IGNORECASE</code></td> 
   <td>如果为真，则进行忽略大小写的匹配</td> 
  </tr> 
  <tr> 
   <td><code>OFMT</code></td> 
   <td>数字的输出格式(默认值是%.6g)</td> 
  </tr> 
  <tr> 
   <td><code>OFS</code></td> 
   <td>输出记录分隔符（输出换行符），输出时用指定的符号代替换行符</td> 
  </tr> 
  <tr> 
   <td><code>ORS</code></td> 
   <td>输出记录分隔符(默认值是一个换行符)</td> 
  </tr> 
  <tr> 
   <td><code>RLENGTH</code></td> 
   <td>由match函数所匹配的字符串的长度</td> 
  </tr> 
  <tr> 
   <td><code>RS</code></td> 
   <td>记录分隔符(默认是一个换行符)</td> 
  </tr> 
  <tr> 
   <td><code>RSTART</code></td> 
   <td>由match函数所匹配的字符串的第一个位置</td> 
  </tr> 
  <tr> 
   <td><code>SUBSEP</code></td> 
   <td>数组下标分隔符(默认值是/034)</td> 
  </tr> 
 </tbody> 
</table>

*  例

$ awk 'BEGIN{printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n","FILENAME","ARGC","FNR","FS","NF","NR","OFS","ORS","RS";printf "---------------------------------------------\n"} {printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n",FILENAME,ARGC,FNR,FS,NF,NR,OFS,ORS,RS}'  log.txt
    FILENAME ARGC  FNR   FS   NF   NR  OFS  ORS   RS
    ---------------------------------------------
    log.txt    2    1         5    1
    log.txt    2    2         5    2
    log.txt    2    3         3    3
    log.txt    2    4         4    4
    $ awk -F\' 'BEGIN{ printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n","FILENAME","ARGC","FNR","FS","NF","NR","OFS","ORS","RS";printf "---------------------------------------------\n"} { printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n",FILENAME,ARGC,FNR,FS,NF,NR,OFS,ORS,RS}' log.txt FILENAME ARGC FNR FS NF NR OFS ORS RS --------------------------------------------- log.txt 2 1 '    1    1
    log.txt    2    2    ' 1 2 log.txt 2 3 '    2    3
    log.txt    2    4    ' 1 4 # 输出顺序号 NR, 匹配文本行号 $ awk '{ print NR,FNR,$1,$2,$3}' log.txt --------------------------------------------- 1 1 2 this is 2 2 3 Are you 3 3 This's a test
    4 4 10 There are
    # 指定输出分割符
    $  awk '{print $1,$2,$5}' OFS=" $ "  log.txt
    ---------------------------------------------
    2 $ this $ test
    3 $ Are $ awk
    This's $ a $
    10 $ There $

## 2.3 awk脚本 ##

*  BEGIN\{ 这里面放的是执行前的语句 \}，awk在开始处理输入文件之前会执行BEGIN块，因此它是初始化FS（字段分隔符）变量、打印页眉或初始化其它在程序中以后会引用的全局变量的极佳位置。
 *  END \{这里面放的是处理完所有的行后要执行的语句 \}，awk在处理了输入文件中的所有行之后执行这个块。通常，END块用于执行最终计算或打印应该出现在输出流结尾的摘要信息。
 *  \{这里面放的是处理每一行时要执行的语句\}，这个一般放BEGIN和END的中间位置。

为了便于举例说明，在当前目录下生成一个历史话单文件`bill`（注意，是一行内容，中间没有换行符），其内容如下：

4429300,0,8613902700001,8613902700002,8613800288500,2004/06/26 10:31:33,2004/06/26 10:31:33,0,0,0,4,6,1,0,0,0,,0,2004/06/26 10:31:32,NULL,1,0,0,nihao@,
    4429300,0,8613902700001,8613902700003,8613800288500,2004/06/26 10:31:33,2004/06/26 10:31:33,0,0,0,4,6,1,0,0,0,,0,2004/06/26 10:31:32,NULL,1,0,0,nihao@,

我们可以使用`$0`变量将整个bill文件内容读出： `awk '{ print $0 }' bill`（在awk中，`print`和`print $0`的作用完全一样。）  
使用`$number`变量，对多个字段的文本进行处理，将变得非常容易，它可以让你毫不费力地引用每个独立的字段。例如，我们可以列出主叫号码和被叫号码：  
`awk -F"," '{ print $3,$4 }' bill`  
上例中，在调用awk时，使用`-F选项来指定，`作为字段分隔符。awk处理后打印出主叫号码字段和被叫号码字段。而且，你还可以在字段中插入字符，比如：  
`awk -F"," '{ print "OrgAddr: "$3, "\tDestAddr: "$4 }' bill`  
以下是该脚本输出：

OrgAddr: 8613902700001  DestAddr: 8613902700002
    OrgAddr: 8613902700001  DestAddr: 8613902700003

以上命令中，我们是通过-F选项来指定字段分隔符的。  
如果我们使用脚本文件，则就要用到FS变量来设置字段分隔符。  
编写脚本文件bill.awk如下：

BEGIN { 
        FS=","
    }
    {  print "OrgAddr: "$3, "\tDestAddr: "$4 }

建议最好用脚本文件，这样方便日后重复利用，也方便修改。

*  下面展示一个完整的awk脚本

学生成绩表内容如下

[root@ccx ccx]# cat score.txt
    Marry   2143 78 84 77
    Jack    2321 66 78 45
    Tom     2122 48 77 71
    Mike    2537 87 97 95
    Bob     2415 40 57 62

awk 脚本如下

[root@ccx ccx]# cat cal.awk
    #!/bin/awk -f
    #运行前
    BEGIN { 
        math = 0
        english = 0
        computer = 0
     
        printf "NAME NO. MATH ENGLISH COMPUTER TOTAL\n"
        printf "---------------------------------------------\n"
    }
    #运行中
    { 
        math+=$3
        english+=$4
        computer+=$5
        printf "%-6s %-6s %4d %8d %8d %8d\n", $1, $2, $3,$4,$5, $3+$4+$5
    }
    #运行后
    END { 
        printf "---------------------------------------------\n"
        printf " TOTAL:%10d %8d %8d \n", math, english, computer
        printf "AVERAGE:%10.2f %8.2f %8.2f\n", math/NR, english/NR, computer/NR
    }

执行结果如下

[root@ccx ccx]# awk -f cal.awk score.txt
    NAME    NO.   MATH  ENGLISH  COMPUTER   TOTAL
    ---------------------------------------------
    Marry  2143     78       84       77      239
    Jack   2321     66       78       45      189
    Tom    2122     48       77       71      196
    Mike   2537     87       97       95      279
    Bob    2415     40       57       62      159
    ---------------------------------------------
      TOTAL:       319      393      350
    AVERAGE:     63.80    78.60    70.00

## 2.3 表达式和运算符 ##

bill内容如下：

awk 允许使用正则表达式，根据正则表达式是否匹配当前行来选择执行独立代码块。以下示例脚本只输出bill中包含字符序列8613902700003的那些行：`awk '/8613902700003/ { print }' bill`  
当然，可以使用更复杂的正则表达式：`/[0-9]*/ { print }`  
下面列出正则表达式元字符：

<table> 
 <thead> 
  <tr> 
   <th>字符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>.</code>(英文句号)</td> 
   <td>可代替除一行之外的任何单个字符，和*不同的是，这个只会打印含有条件的结果，如：<code>awk '/t*/{print}' test.txt</code>，不含有t的结果是不会被打印的</td> 
  </tr> 
  <tr> 
   <td><code>*</code></td> 
   <td>可代替零个或多个在它前面出现的字符</td> 
  </tr> 
  <tr> 
   <td><code>[chars]</code></td> 
   <td>可代替chars中的任何一个字符，chars是一串字符序列。你可以用<code>-</code>符号来定义一个字符范围。如果<code>^</code>是chars中的第一个字符，那么将匹配没有在chars中指定的字符</td> 
  </tr> 
  <tr> 
   <td><code>^</code></td> 
   <td>匹配一行的开头</td> 
  </tr> 
  <tr> 
   <td><code>$</code></td> 
   <td>匹配一行的结尾</td> 
  </tr> 
  <tr> 
   <td><code>\</code></td> 
   <td>把\后面的字符照常输出，通常用来转义（不使用特殊含义）一个元字符</td> 
  </tr> 
 </tbody> 
</table>

`.`和`*`的区别，注：使用.和\*需要加上/转移符，否则报错。

[root@ccx ccx]# awk '/t./{print}' test.txt 
    this is a test 
    good things are about to happen
    [root@ccx ccx]# awk '/t*/{print}' test.txt 
    this is a test 
    good things are about to happen
    _____________________________
    我感到难过,不是因为你欺骗了我,而是因为我再也不能相信你了,555
    
    [root@ccx ccx]#

下面列出运算符表达式元字符：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>=</code> <code>+=</code> <code>-=</code> <code>*=</code> <code>/=</code> <code>%=</code> <code>^=</code> <code>**=</code></td> 
   <td>赋值</td> 
  </tr> 
  <tr> 
   <td><code>?:</code></td> 
   <td>C条件表达式</td> 
  </tr> 
  <tr> 
   <td><code>||</code></td> 
   <td>逻辑或</td> 
  </tr> 
  <tr> 
   <td><code>&amp;&amp;</code></td> 
   <td>逻辑与</td> 
  </tr> 
  <tr> 
   <td><code>~</code>和<code>!~</code></td> 
   <td>匹配正则(包含)与不匹配，比如第二个参数中包含is的内容：$2 ~ is</td> 
  </tr> 
  <tr> 
   <td><code>&lt;</code> <code>&lt;=</code> <code>&gt;</code> <code>&gt;=</code> <code>!=</code> <code>==</code></td> 
   <td>关系运算符</td> 
  </tr> 
  <tr> 
   <td><code>空格</code></td> 
   <td>连接</td> 
  </tr> 
  <tr> 
   <td><code>+</code> <code>-</code></td> 
   <td>加，减</td> 
  </tr> 
  <tr> 
   <td><code>*</code> <code>/</code> <code>%</code></td> 
   <td>乘，除与求余</td> 
  </tr> 
  <tr> 
   <td><code>+</code> <code>-</code> <code>!</code></td> 
   <td>一元加，减和逻辑非</td> 
  </tr> 
  <tr> 
   <td><code>^***</code></td> 
   <td>求幂</td> 
  </tr> 
  <tr> 
   <td><code>++</code> <code>--</code></td> 
   <td>增加或减少，作为前缀或后缀</td> 
  </tr> 
  <tr> 
   <td><code>$</code></td> 
   <td>字段引用</td> 
  </tr> 
  <tr> 
   <td><code>in</code></td> 
   <td>数组成员</td> 
  </tr> 
  <tr> 
   <td><code>[0-9]</code></td> 
   <td>代表一个单独的数字</td> 
  </tr> 
  <tr> 
   <td><code>[a-z]</code></td> 
   <td>代表一个单独的小写字母</td> 
  </tr> 
  <tr> 
   <td><code>[A-Z]</code></td> 
   <td>代表一个单独的大写字母</td> 
  </tr> 
  <tr> 
   <td><code>[a-zA-Z]</code></td> 
   <td>代表一个单独的字母</td> 
  </tr> 
  <tr> 
   <td><code>[a-zA-Z 0-9]</code></td> 
   <td>代表一个单独的字母或数字</td> 
  </tr> 
 </tbody> 
</table>

bill内容如下：

除了使用正则表达式来选择行，我们也可以使用布尔表达式来选择行。使用方法是将布尔表达式放在代码块之前，仅当对前面的布尔表达式求值为真时，awk才执行代码块。以下示例脚本将输出bill中第四个字段等于8613902700003的所有行中的第三、四字段。如果当前行的第四个字段不等于8613902700003，awk将继续处理文件而不对当前行执行print语句：  
`$4 == "8613902700003" { print "OrgAddr: "$3, "\tDestAddr: "$4 }`  
注意，代码块前的布尔表达式必须与代码块在同一行上。  
awk 提供了完整的比较运算符集合，包括`==`、`<`、`>`、`<=`、`>=`和`!=`。另外，awk还提供了`~`和`!~` 运算符，它们分别表示`匹配`和`不匹配`。它们的用法是在运算符左边指定变量，在右边指定正则表达式。例如：  
`$4 ~ /8613902700003/ { print "OrgAddr: "$3, "\tDestAddr: "$4 }`  
awk还允许使用布尔运算符`||`（逻辑或）和`&&`（逻辑与），以便创建更复杂的布尔表达式：  
`( $3 == "8613902700001" ) && ( $4 == "8613902700003" ) { print }`  
awk的另一个优点是它有完整的数学运算符集合。除了标准的加、减、乘、除，awk还允许使用指数运算符`^`、模运算符`%`和其它许多从C语言中借入的易于使用的赋值操作符。  
这些运算符包括前后加减（i++、–j）、加／减／乘／除赋值运算符（a+=3、b\*=2、c/=2.2、d-=6.2）。不仅如此，还有易于使用的模／指数赋值运算符（a^=2、b%=4）。

## 2.4 字符串化变量 ##

awk变量“字符串化”是指所有awk变量在内部都是按字符串形式存储的。而且只要变量包含有效数字字符串，就可以对它执行数学操作，awk会自动处理字符串到数字的转换步骤。请看以下这个示例：

BEGIN   {  x="0" }
    /^$/    {  x=x+1 }
    END     {  print "I found " x " blank lines. :)" }

这个例子的功能是计算文件中空白行的数量，`^$`表示空行。  
如果做一个小实验，就可以发现如果某个特定变量不包含有效数字，awk在对数学表达式求值时会将该变量当作数字0处理。

# 3 第二部分：提高 #

## 3.1 处理多行 ##

在这一节里，顺带着讲一下三个特别的变量：

<table> 
 <thead> 
  <tr> 
   <th>Awk特殊变量</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>RS</code></td> 
   <td>表示记录分隔符</td> 
  </tr> 
  <tr> 
   <td><code>OFS</code></td> 
   <td>表示输出字段分隔符，在两个单独的字段间插入定义的字符串</td> 
  </tr> 
  <tr> 
   <td><code>ORS</code></td> 
   <td>表示输出记录分隔符，在两个单独的记录间插入定义的字符串</td> 
  </tr> 
 </tbody> 
</table>

第一部分我们讨论的都是一个记录占用一行的情况，如果要分析占据多行的记录，除了依靠FS，还需要设置RS（记录分隔符变量）。RS变量告诉awk当前记录什么时候结束，新记录什么时候开始。  
为了便于讨论，我们依然首先在当前目录下生成一个通讯录文件`address`，其内容如下：

zhangsan
    13712345678
    zhs@hotmail.com
     
    lisi
    13012345678
    ls@21cn.com

要处理这个文件，可以将每三行看作是一个独立的记录，一个记录包含三个字段。如下脚本将原记录由三行转换成一行输出：

BEGIN { 
        FS="\n"
        RS=""
    }
    { 
        print $1 ", " $2 ", " $3
    }

此代码将产生以下输出：

zhangsan, 13712345678, zhs@hotmail.com
    lisi, 13012345678, ls@21cn.com

在上面例子中，为了在三个字段之间插入一个逗号和空格，使用了","。这个方法虽然有用，但比较难看。其实我们还有更好的方法，那就是设置变量OFS（输出字段分隔符）。OFS缺省情况下被设置成" "（单个空格）。使用如下脚本可以达到上面例子同样的效果：

BEGIN { 
        FS="\n"
        RS=""
        OFS=", "
    }
     
    { 
        print $1, $2, $3
    }

awk还有一个特殊变量ORS（输出记录分隔符）。ORS缺省情况下被设置成`\n`，如果我们将其设为`\n\n`，就可以使输出记录的间隔翻倍。例子就不举了，大家可以自己试试。个空格分隔记录（而不换行），将ORS设置成 `` (空格)。  
需要注意的是，使用上面的方法，最多只能处理一个记录占用三行的文本，象下面一个记录占据四行的通讯录，就处理不了了（大家可以试试看）：

wangwu
    13512345678
    ww@163.com
    wuhan, hubei

要处理这种情况，代码最好考虑每个记录的字段数量，并依次打印每个记录。以下就是修正的代码：

BEGIN { 
        FS="\n"
        RS=""
        ORS=""
    }
     
    {  
            x=1
            while ( x<NF ) { 
                    print $x "\t"
                    x++
            }
            print $NF "\n"
    }

程序输出如下：  
`wangwu 13512345678 ww@163.com wuhan, hubei`

## 3.2 条件语句 ##

awk的if语句类似于C语言的if语句，没什么好说的，举一个例子吧：

{ 
        if ( $1 == "foo" ) { 
            if ( $2 == "foo" ) { 
                print "uno"
            } else { 
                print "one"
            }
        } else if ($1 == "bar" ) { 
            print "two"
        } else { 
            print "three"
        }
    }

## 3.3 循环语句 ##

其实在第1节的最后(处理多行），我们已经看到了awk的while循环结构，它等同于相应的C语言while循环。awk还有"do…while"循环，它在代码块结尾处对条件求值，还是直接举例吧：

*  `do...while`示例

{ 
        count=1
        do { 
            print "I get printed at least once no matter what"
        } while ( count != 1 )
    }

*  `for`循环  
    也等同于C语言的for循环：

for ( x = 1; x <= 4; x++ ) { 
        print "iteration",x
    }

*  `break` 和 `continue`  
    此外，如同C语言一样，awk提供了break、continue来控制awk的循环结构。break语句用于跳出最深层的循环，使循环立即终止，并继续执行循环代码块后面的语句。continue语句使awk立即开始执行下一个循环迭代，而不执行代码块的其余部分。

## 3.4 数组 ##

在awk中，数组下标通常从1开始，而不是0：

myarray[1]="jim"
    myarray[2]=456

awk遇到第一个赋值语句时，它将创建myarray，并将元素myarray\[1\]设置成"jim"。执行了第二个赋值语句后，数组就有两个元素了。Awk数组不需要连续的数字序列下标（例如，可以定义myarr\[1\]和myarr\[1000\]，但不定义其它所有元素）  
awk可以使用`in`操作来遍历数组中的所有元素，如下所示：

for ( x in myarray ) { 
        print myarray[x]
    }

但是这个方法有一个缺点——当awk在数组下标之间轮转时，它不会依照任何特定的顺序。那就意味着我们不能知道以上代码的输出是：

jim
    456

还是

456
    jim

awk数组中还可以使用字符串下标，其实，不管你使用的下标是字符串还是数字，awk在幕后还将其认为是字符串下标。举例如下：  
代码一：

myarr["1"]="China"
    print myarr["1"]

代码二：

myarr["1"]="Mr. Whipple"
    print myarr[1]

代码三：

myarr["name"]="Mr. Whipple"
    print myarr["name"]

它们都将打印 “China”！  
删除数组元素使用`delete`，举例如下：  
`delete fooarray[1]`  
另外，如果想要查看是否存在某个特定数组元素，可以使用特殊的`in`布尔运算符，如下所示：

if ( 1 in fooarray ) { 
        print "It's there."
    } else { 
        print "Can't find it."
    }

# 4 第三部分：精通 #

## 4.1 格式化输出 ##

虽然大多数情况下awk的print语句可以完成任务，但有时我们还需要更多。使用两个函数`printf()`、`sprintf()`，将能让输出锦上添花。`printf()`会将格式化字符串打印到`stdout`，而`sprintf()`则返回可以赋值给变量的格式化字符串。  
从下面例子可以看到，它们几乎与C语言完全相同。

x=1
    b="foo"
    printf("%s got a %d on the last test\n","Jim",83)
    myout=("%s-%d",b,x)
    print myout

此代码将打印：

Jim got a 83 on the last test
    foo-1

## 4.2 字符串函数 ##

既然awk把所有变量都当作字符串处理，那么字符串处理对awk就显得尤为重要。但要说明一点，awk不能象在其它语言（如 C、C++）中那样将字符串看作是字符数组。例如，如果执行以下代码：

mystring="How are you doing today?"
    print mystring[3]

将会接收到一个错误，如下所示：  
`awk: string.gawk:59: fatal: attempt to use scalar as array`  
不用担心，awk有许多字符串函数，弥补了这个缺陷。现将常用的字符串函数列举如下：  
函数使用方式如：  
从文件中找出长度大于 20 的行

[root@ccx ccx]# awk 'length>20' test.txt 
    good things are about to happen
    _____________________________
    我感到难过,不是因为你欺骗了我,而是因为我再也不能相信你了,555
    [root@ccx ccx]#

<table> 
 <thead> 
  <tr> 
   <th>字符串函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>length()</code></td> 
   <td>返回字符串的长度</td> 
  </tr> 
  <tr> 
   <td><code>index()</code></td> 
   <td>返回子字符串在另一个字符串中出现的位置</td> 
  </tr> 
  <tr> 
   <td><code>tolower()</code></td> 
   <td>返回字符串并且将所有字符转换成小写</td> 
  </tr> 
  <tr> 
   <td><code>toupper()</code></td> 
   <td>返回字符串并且将所有字符转换成大写</td> 
  </tr> 
  <tr> 
   <td><code>substr()</code></td> 
   <td>返回从字符串中选择的子串</td> 
  </tr> 
  <tr> 
   <td><code>match()</code></td> 
   <td>返回子字符串在另一个字符串中出现的位置。它与index()的区别在于它并不搜索子串，它搜索的是正则表达式。</td> 
  </tr> 
  <tr> 
   <td><code>sub()</code></td> 
   <td>替换匹配的第一个字符序列，并返回整个字符串</td> 
  </tr> 
  <tr> 
   <td><code>substr()</code></td> 
   <td>使用<code>substr()</code>可以从字符串中选择子串。以下是<code>substr()</code>的调用方法：<code>mysub=substr(mystring,startpos,maxlen)</code>，以下是一个示例：<code>print substr(mystring,9,3)</code></td> 
  </tr> 
  <tr> 
   <td><code>gsub()</code></td> 
   <td>替换匹配的全部字符序列，并返回整个字符串</td> 
  </tr> 
  <tr> 
   <td><code>split()</code></td> 
   <td>分割字符串，并将各部分放到使用整数下标的数组中</td> 
  </tr> 
  <tr> 
   <td><code>length()</code></td> 
   <td>返回字符串的长度，例子如：<code>print length(mystring)</code></td> 
  </tr> 
  <tr> 
   <td><code>index()</code></td> 
   <td>返回子字符串在另一个字符串中出现的位置，如果没有找到该字符串则返回0，例子如：<code>print index(mystring,"you")</code></td> 
  </tr> 
  <tr> 
   <td><code>tolower()</code>和<code>toupper()</code></td> 
   <td>返回字符串并且将所有字符分别转换成小写或大写。注意，<code>tolower()</code>和<code>toupper()</code>返回新的字符串，不会修改原来的字符串。例子：<code>print tolower(mystring)</code>，<code>print toupper(mystring)</code></td> 
  </tr> 
  <tr> 
   <td><code>match()</code></td> 
   <td><code>match()</code>与<code>index()</code>非常相似，它与<code>index()</code>的区别在于它并不搜索子串，它搜索的是正则表达式。<code>match()</code>函数将返回匹配的起始位置，如果没有找到匹配，则返回0。此外，<code>match()</code>还将设置两个变量，叫作<code>RSTART</code>和<code>RLENGTH</code>。<code>RSTART</code>包含返回值（第一个匹配的位置），<code>RLENGTH</code>指定它占据的字符跨度（如果没有找到匹配，则返回-1）。通过使用<code>RSTART</code>、<code>RLENGTH</code>、<code>substr()</code>和一个小循环，可以轻松地遍历字符串中的每个匹配。以下是一个<code>match()</code>调用示例：<code>print match(mystring,/you/)</code>,<code>RSTART</code>, <code>RLENGTH</code></td> 
  </tr> 
  <tr> 
   <td><code>gsub()</code></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

注：  
`sub()`和`gsub()`是两个字符串替换函数。`sub()`的调用方法如下：  
`sub(regexp,replstring,mystring)`  
调用`sub()`时，它将在`mystring`中匹配`regexp`的第一个字符序列，并且用`replstring`替换该序列。`gsub()`与`sub()`的唯一的区别是`sub()`替换第一个`regexp`匹配（如果有的话），`gsub()`则执行全局替换，换出字符串中的所有匹配。举例如下：

sub(/o/,"O",mystring)
    print mystring
    mystring="How are you doing today?"
    gsub(/o/,"O",mystring)
    print mystring

其输出结果如下：

HOw are you doing today?
    HOw are yOu dOing tOday?

`split()`的功能是分割字符串，并将分割后的各部分放到使用整数下标的数组中。此函数有三个变量，第一个自变量为要分割的原始字符串，第二个自变量为分割后填入的数组名称，第三个变素为用于指示分割的分隔符。`split()`返回时，它将返回分割的字符串元素的数量。`split()`将分割的每一个部分赋值给下标从1开始的数组。举例如下：

numelements=split("Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec",mymonths,",")
    print mymonths[1],mymonths[numelements]

其输出如下：

Jan Dec

最后需要说明一点的是，调用`length()`、`sub()`或`gsub()`时，可以去掉最后一个变量，这样awk将对`$0`（整个当前行）应用函数调用。例如要打印文件中每一行的长度，使用以下awk脚本：

{ 
        print length()
    }

# 实例\_参考 #

## 脚本执行方式 ##

*  格式：`awk -f name.awk test.txt`

`test.txt`内容如下

[root@ccx ccx]# cat test.txt
    this is a test 
    good things are about to happen
    _____________________________
    我感到难过,不是因为你欺骗了我,而是因为我再也不能相信你了,555
    [root@ccx ccx]#

awk脚本名：`test.awk`内容如下

[root@ccx ccx]# cat test.awk 
    #!/bin/awk -f
    #执行前
    BEGIN{ 
            FS="[ ,]"
    
    }
    #执行中
    { 
            print $1 , $2
    }
    #执行后
    END{ 
            print "test"
    }

使用空格和,为分隔符，打印1和2个结果并在脚本最后输出test，执行结果如下：

[root@ccx ccx]# awk -f test.awk test.txt 
    this is
    good things
    _____________________________ 
    我感到难过 不是因为你欺骗了我
     
    test
    [root@ccx ccx]#

## 输出文本中的1、4项 ##

test.txt文本内容如下

[root@ccx ccx]# cat test.txt
    this is a test 
    good things are about to happen
    [root@ccx ccx]#

可以用来过滤命令内容的，如果是脚本中，则每行的1和4行内容都会被打印：`awk '{print $1,$4}'`

[root@ccx ccx]# awk '{print $1,$4}' test.txt 
    this test
    good about
    [root@ccx ccx]#

## 指定分割字符 ##

`test.txt`内容如下

### 使用单个","分割 ###

注：这种情况如果一行中没有指定分割的内容，则会整行打印(如下，只有中文有`,`，所以只有中文的$1和$2生效了。

[root@ccx ccx]# awk -F, '{print $1,$2}' test.txt 
    this is a test  
    good things are about to happen 
    _____________________________ 
    我感到难过 不是因为你欺骗了我

### 使用多个分隔符 ###

先使用空格分割，然后对分割结果再使用","分割  
注：使用多个分隔符需要在-F后面加上`'[在这里面直接添加分隔符]'`

[root@ccx ccx]# awk -F'[ ,]' '{print $1,$2}' test.txt 
    this is
    good things
    _____________________________ 
    我感到难过 不是因为你欺骗了我
     
    [root@ccx ccx]#

## 设置变量 ##

`test.txt`内容如下

*  \-v是设置变量，使用的时候直接在-v后面定义变量，不需要间隔符。  
    注：因为没有设置分隔符，所以默认分隔符是`空格`。

[root@ccx ccx]# awk -va=1 '{print $1,$1+a}' test.txt 
    this 1
    good 1
    _____________________________ 1
    我感到难过,不是因为你欺骗了我,而是因为我再也不能相信你了,555 1
     1
    [root@ccx ccx]#

*  设置变量和分隔符为`,`如下  
    注，一行中没有,的则不会匹配的（如果需要都匹配，则设置多个分隔符）。

[root@ccx ccx]# awk -va=1 -F, '{print $1,$1+a}' test.txt 
    this is a test  1
    good things are about to happen 1
    _____________________________ 1
    我感到难过 1
     1
    [root@ccx ccx]#

## 设置过滤条件 ##

`test.txt`内容如下

[root@ccx ccx]# cat test.txt 
    this is a test 
    this not balabala
    good things are about to happen
    _____________________________
    我感到难过,不是因为你欺骗了我,而是因为我再也不能相信你了,555
    
    [root@ccx ccx]#
    [root@ccx ccx]#

### 匹配字符t ###

`.`是绝对匹配，没有匹配到的不会被打印，`*`即使没有匹配到的也会被打印

### 过滤第一列参数等于this的行 ###

注：参数需要加上`""`，否则过滤不出结果

[root@ccx ccx]# awk '$1=="this" {print}' test.txt 
    this is a test 
    this not balabala
    [root@ccx ccx]#

### 过滤第一列等于this并且第二列等于is的行 ###

使用了`&&`，注意：参数需要加上`""`，否则过滤不出结果

[root@ccx ccx]# awk '$1=="this" && $2=="is" {print}' test.txt 
    this is a test 
    [root@ccx ccx]#

### 输出第一列包含 th，并打印第一列与第四列 ###

注：包含内容必须放`//`中间，否则过滤无效。

[root@ccx ccx]# awk '$1 ~ /th/ {print $1,$4}' test.txt 
    this test
    this 
    [root@ccx ccx]#

### 输出包含 “is” 的行 ###

~ 表示模式开始。// 中是模式。

[root@ccx ccx]# awk '/is/' test.txt 
    this is a test 
    this not balabala

## Awk的文本分行读取,和分行判断… ##

[root@ccx ccx]# more hosts
    127.0.0.1               loopback localhost      # loopback (lo0) name/address
    172.30.126.10  IVM10  
    172.24.23.230 IVM230
    172.24.23.80 IVM80
    172.30.126.60 localhost
    172.24.23.39 IVM39
    172.24.23.82 IVM82
    172.24.23.160 Robin_Hu_Dev
    172.24.23.236 IVM236
    [root@ccx ccx]# cat ./hosts | awk '{if($1 == ivm_ip && $2 == ivm_name) {print $0}}' ivm_ip=172.24.23.39 ivm_name=IVM39
    172.24.23.39 IVM39
    [root@ccx ccx]# cat ./hosts | awk '{if($1 == ivm_ip || $2 == ivm_name) {print $0}}' ivm_ip=172.24.23.39 ivm_name=IVM82
    172.24.23.39 IVM39
    172.24.23.82 IVM82

## 忽略大小写 ##

忽略大小写格式为： `BEGIN{IGNORECASE=1} /忽略大小写的字母/`  
test.txt内容

[root@ccx ccx]# cat test.txt 
    this is a test 
    This not balabala
    good things are about to happen
    _____________________________
    我感到难过,不是因为你欺骗了我,而是因为我再也不能相信你了,555
    
    [root@ccx ccx]#

*  忽略this的大小写，默认打印全部

[root@ccx ccx]# awk 'BEGIN{IGNORECASE=1} /this/ ' test.txt 
    this is a test 
    This not balabala
    [root@ccx ccx]#

*  打印1和4行

[root@ccx ccx]# awk 'BEGIN{IGNORECASE=1} /this/ {print $1,$4}' test.txt 
    this test
    This 
    [root@ccx ccx]#

## 模式取反 ##

打印第一列不是th的1和4内容

[root@ccx ccx]# awk '$1 !~ /th/ {print $1,$4}' test.txt 
    This 
    good about
    _____________________________ 
    我感到难过,不是因为你欺骗了我,而是因为我再也不能相信你了,555 
     
    [root@ccx ccx]#

## 从文件中找出长度大于 20 的行 ##

利用了字符串函数，更多函数见上面4.2。

## AWK实现计算方法 ##

直接±\*/即可，方法如下：

[root@ccx ccx]# echo "2 5" | awk '{print($1+$2)}'
    7
    [root@ccx ccx]# echo "2 5" | awk '{print($1-$2)}'
    -3
    [root@ccx ccx]# echo "2 5" | awk '{print($1+$2)*$2}'
    35
    [root@ccx ccx]#

## Awk的列整理为行的格式 ##

以:为分隔符，然后用for循环打印内容即可

[root@ccx ccx]# echo "123123123:1312312:sdfasdfsa" | awk -F":" '{for(i=1;i<=NF;i++) print $i}'
    123123123
    1312312
    Sdfasdfsa

## Awk的牛闪闪用法(满足2个条件组成一行内容） ##

`data.txt`内容如下

[root@ccx ccx]#cat data.txt
    #CONTACT
    ID=454
    NAME=Fred Weinhaus
    CREATED=1251770526
    MAIL=fmw@alink.net
    ICON=Contact0
    
    #CONTACT
    ID=455
    NAME=binsos@googlegroups.com
    CREATED=1253364946
    MAIL=binsos@googlegroups.com
    DESCRIPTION=
    SHORT NAME=
    PHONE=1xxxxx999901
    ICON=Contact0

要求:::取name和 phone同时有效的，组成行。

awk -F[=] 'BEGIN{i=0}$1=="#CONTACT"{i++}$1=="NAME"{n[i]=$2}$1=="PHONE"{p[i]=$2}END{for(i in n){if (n[i] && p[i]) printf "%s, %s\n",n[i],p[i]}}' data.txt

执行和结果如下

[root@ccx ccx]# awk -F[=] 'BEGIN{i=0}$1=="#CONTACT"{i++}$1=="NAME"{n[i]=$2}$1=="PHONE"{p[i]=$2}END{for(i in n){if (n[i] && p[i]) printf "%s, %s\n",n[i],p[i]}}' data.txt
    binsos@googlegroups.com, 1xxxxx999901
    [root@ccx ccx]#

## 打印99乘法表 ##

代码如下

seq 9 | sed 'H;g' | awk -v RS='' '{for(i=1;i<=NF;i++)printf("%dx%d=%d%s", i, NR, i*NR, i==NR?"\n":"\t")}'

执行结果如下

[root@ccx ccx]# seq 9 | sed 'H;g' | awk -v RS='' '{for(i=1;i<=NF;i++)printf("%dx%d=%d%s", i, NR, i*NR, i==NR?"\n":"\t")}'
    1x1=1
    1x2=2   2x2=4
    1x3=3   2x3=6   3x3=9
    1x4=4   2x4=8   3x4=12  4x4=16
    1x5=5   2x5=10  3x5=15  4x5=20  5x5=25
    1x6=6   2x6=12  3x6=18  4x6=24  5x6=30  6x6=36
    1x7=7   2x7=14  3x7=21  4x7=28  5x7=35  6x7=42  7x7=49
    1x8=8   2x8=16  3x8=24  4x8=32  5x8=40  6x8=48  7x8=56  8x8=64
    1x9=9   2x9=18  3x9=27  4x9=36  5x9=45  6x9=54  7x9=63  8x9=72  9x9=81
    [root@ccx ccx]#