GNU awk的$1=$1到底有什么作用？$0=$0呢？

cu上出了个shell题：

http://bbs.chinaunix.net/thread-2319120-1-1.html

第八题：GNU awk的$1=$1到底有什么作用？$0=$0呢？

这题问得相当的细致。可能很多人已经常用这二个赋值语句，却半知半解。以下分二部分对这个题目进行分析

建议没心情，没耐心，没兴趣的人，只需要了解下第一部分，看第二部分就表看了，很罗嗦的。

第一部分：能过man上边的解析，回签这二个赋值语句的功能

第二部分：awk部分源码解析（结点树简介，及域模块)

          通过分析awk 域模块源码 ，了解awk的内部处理机制

参考程序及源码版本：gawk-3.1.5

=========================第一部分================================================

第一部分：GNU awk的$1=$1到底有什么作用？$0=$0呢？

首先了解一下一些知识，先翻一下man awk里的这段话：

 assigning to a    non-existent field (e.g., $(NF+2) = 5) increases the value of NF,

对不存在的域赋值，会增加NF值

creates any intervening fields with the  null  string  as  their  value, 

空字符串作为中间域的值

and  causes the value of $0 to be recomputed, with the fields being separated by the value of OFS.

$0会被根据OFS值重新计算，

References to negative numbered fields cause a fatal error. 

引用负的域索引是无效的，并且会导致错误

Decrementing NF causes  the  values of  fields past the new value to be lost,

减少NF值时，索引大于NF的域将会丢失

and the value of $0 to be recomputed, with the fields being separated  by the value of OFS.

同时$0也会被根据OFS值重新计算，

Assigning a value to an existing field causes the whole record to be rebuilt when $0 is referenced.

对当前存在的域值进行赋值，会使记录在$0被引用时重构

Similarly,assigning a value to $0 causes the record to be resplit, creating new values for the fields.

对$0赋值，也会使记录重新重分割，对域重新赋值

这里涉及到二种记录操作

1：记录分割，记录按FS值分割成域，赋给每个域值

2：记录重构，根据域值和OFS重构域。重构之后: $0=$1OFS$2OFS……

 

另外补充一点额外的知识：

$0与$1,$2….是分开存放的，$0保存的是记录初始的整串值（包括刚读进来时候的分隔符），而$1,2...保存的是分割后的域值，

awk内部函数机制基本上保证了二者的同步，一般不会出现什么错误。

尽管如此，分开存储的记录和域还是不可必免会存在一些应用问题，下边举二个例子说明：

 

例子一：当我们想通过更改OFS，变更域之间的输出分隔符时，此时$0由于保存的是原来的串，输出并不是按$1OFS$2进行输出：

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";print $0;}'          
aaa bbb 
[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";print $0;}'       
aaa bbb

此时的办法采用可以列举的办法：

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";print $1,$2;}'    
aaa#bbb 
但是当域值很多时（或不固定时），再用列举的话可能要借用NF，写一个循环

例子二：当我们想通过更改FS，变更域之间的分隔符时，此时$0由于保存的是原来的串，$1并没有重新分隔

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "aa#a b#bb"|awk '{FS="#";print $1}'       
aa#a 
$1=$1的解析：

命令分解：

1：赋值操作的顺序是从右到左，先通过右操作数引用了$1,取得当前$1的值，

2：再通过赋值操作将值赋给左边的$1

 

步骤解析：

步骤1没什么特别的，若当前NF=0，这里的$1只会得到空值（NULL string)

步骤2分二种情况

1：若当前NF=0，即上边引文中提到的 assigning to a    non-existent field，

        此时，NF由0变1，

 2：若NF>1，则NF不变

接下来是关健做用：由于步骤2触发了域赋值操作，产生了连带的动作：在下一次引用$0时，会对$0进行重新构。（根据OFS）

 

归纳作用：

下次引用$0时，对$0进行按引用时的OFS进行重构（$1OFS$2OFS……）

应用：

例子一：变更输出分隔符，可以这样：

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";$1=$1;print $0;}' 
aaa#bbb 
[root@rac_2 ~]# echo "aaa bbb"|awk '{OFS="#";$1=$1;print $0;}'
aaa#bbb

再来是$0=$0的解析

命令分解：

1：赋值操作的顺序是从右到左，先通过右操作数引用了$0,取得当前$0的值

2：再通过赋值操作将值赋给左边的$0

 

步骤分析：

步骤1：这里引用了$0进行取值，由于上边提到的设定，要注意是否有重构问题

步骤2：这里是赋值引用，对$0的赋值引用，会涉及到根据当前的FS对域的重分割

归纳作用：根据右操作数$0取出的值（可能是重构的），赋给$0,并根据FS重新分隔

应用：

例子二：变更输入分隔符，对当前记录进行重解析：

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "aa#a b#bb"|awk '{FS="#";$0=$0;print $1}' 
aa#a 
[root@rac_2 ~]# echo "aa#a b#bb"|awk '{FS="#";$0=$0;print $1}'
aa#a

综合应用$1=$1,$0=$0

这里涉及到了FS跟OFS同时变更时，要注意分析，区别应用：

例子三：替换原来的分隔符（假如为A）为新的串（B），最后按分隔符（C）输出第三域

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;$0=$0;print $3}' 
B3 
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;$0=$0;print $3}'
B3
 

这里如果少了$1=$1的话，则$0在引用时无法根据新的OFS值重构，没有做替换，仍按原先的串按新FS解析，得到原先的第三域值

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$0=$0;print $3}'   
A3 
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$0=$0;print $3}'
A3

这里如果少了$0=$0的话，$0以原先的值"1CA2CA3CA"在读入时按"A"分隔，$3不变

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;print $3}' 
3C 
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";$1=$1;print $3}'
3C

这个结果与下边等同：

view plaincopy to clipboardprint?
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";print $3}'             
3C 
[root@rac_2 ~]# echo "1CA2CA3CA"|awk 'BEGIN{FS="A"}{FS="C";OFS="B";print $3}'          
3C

=====================================================================================================

二：awk部分源码解析（结点树简介，及域模块)

看man还是有些不够清晰的，或多或少会留下点疑问，应该会有人考虑到$0在分割之后存放成各个域，既然可以通过各个域拼接起来，为什么还要保存一份原先的串的样本？

比如怎么证明$0是独立于$1,$2,$3的存储存在？这样做又出于什么考虑？

再比如为什么在$1=$1后不是立即重构$0,而是在引用的时候才重构。

再比如对$0进行赋值后，是直接触发分割的，还是在引用域前才进行分隔。

没什么什么比查源码更能回答这些问题的了

通过查看awk的源码中的awk.h头文件可以了解到awk的源码的核心数据结构：结点（typedef struct  NODE)和结点树，awk代码里的各种元素都是以树和结点这种结构存在的，变量如FS/$0/$0是结点，操作符如“=赋值符等”也是结点，内置函数（builtin)也是结点，哈希数组也是结点。

awk是以节点（node 结构)树的形式保存各种变量和操作的，比如各变量，各{}操作块都是树的节点。awk通过调用awkgram.c的yylex+yyparse二个函数，解析awk程序，并形成各种树，比较典型的，如主体程序有三颗数：

view plaincopy to clipboardprint?
/* A block of AWK code to be run before running the program */ 
NODE *begin_block = NULL;  
/* The parse tree is stored here.  */ 
NODE *expression_value;  
/* A block of AWK code to be run after the last input file */ 
NODE *end_block = NULL; 
/* A block of AWK code to be run before running the program */
NODE *begin_block = NULL;
/* The parse tree is stored here.  */
NODE *expression_value;
/* A block of AWK code to be run after the last input file */
NODE *end_block = NULL;

程序块在解析形成树之后，由函数 执行Int interpret(register NODE *volatile tree)

begin模块跟end模块都执行一次

view plaincopy to clipboardprint?
if (begin_block != NULL) {  
        in_begin_rule = TRUE;  
        (void) interpret(begin_block);  
}  
if (end_block != NULL) {  
        in_end_rule = TRUE;  
        (void) interpret(end_block);  
} 
        if (begin_block != NULL) {
                in_begin_rule = TRUE;
                (void) interpret(begin_block);
        }
        if (end_block != NULL) {
                in_end_rule = TRUE;
                (void) interpret(end_block);
        }

而中间模块：expression_value 是在do_input里，一次读一一条记录执行一次的

view plaincopy to clipboardprint?
for (;;) {                                                                                 
        rval2 = rval3 = -1;     /* for debugging */                                        
        rval2 = interpret(expression_value);                                               
        if (rval2 != 0)                                                                    
                rval3 = inrec(iop);                                                        
        if (rval2 == 0 || rval3 != 0)                                                      
                break;                                                                     
}  
                        for (;;) {                                                                              
                                rval2 = rval3 = -1;     /* for debugging */                                     
                                rval2 = interpret(expression_value);                                            
                                if (rval2 != 0)                                                                 
                                        rval3 = inrec(iop);                                                     
                                if (rval2 == 0 || rval3 != 0)                                                   
                                        break;                                                                  
                        }
 

然后回到正题：域模块源码：field.c，通过分析模块的数据结构和函数来了解模块设计，包括分隔符设计，记录分割，记录设置，域设置等

首先是数据结构：

view plaincopy to clipboardprint?
NODE **fields_arr;              /* array of pointers to the field nodes */ 
NODE **fields_arr;              /* array of pointers to the field nodes */

fields_arr数组保存了所有域节点，$1,2...分别对应一样的下标fields_arr[1,2…]：

C的数组索引是从0开始的，这里也不例外，

fields_arr[0]是用于保存完整记录的节点，保存记录值，即$0

然后是函数，我们关注函数的功能和调用。

NF相关函数：

NF（域数值）赋值函数：view plaincopy to clipboardprint?
void set_NF() 
void set_NF()

      直接更改NF值，域数组随NF长短做伸缩

       最后一句话:field0_valid = FALSE;涉及到记录重构，见rebuild_record()

记录层面的函数：赋值，重构，域分割等

记录重置函数：view plaincopy to clipboardprint?
void reset_record() 
void reset_record()

       重置记录，清除fields_arr，NF= -1,视情况保存当前FS

       当对$0赋值时即是调用此函数

记录赋值函数：view plaincopy to clipboardprint?
void  set_record(const char *buf, int cnt) 
void  set_record(const char *buf, int cnt)

          此函数调用：reset_record,重置数组，将buf数组里的内容保存到fields_arr[0] 里边去

          注意：此时并未进行分割。注释里是这么写的：

 * setup $0, but defer parsing rest of line until reference is made to $(>0)

 * or to NF.  At that point, parse only as much as necessary.

虽然保存的记录值，但没有做域解析，直到域或NF引用才做解析

记录重构函数:view plaincopy to clipboardprint?
static void  rebuild_record() 
static void  rebuild_record()

        这个函数没有参数，这个函数的功能是把当前各域fields_arr[1,2….]数组拼接OFS，形成新的字符串更新到fields_arr[0]

        并且这个函数只在get_field函数里，只有在field0_valid标志为fault时前提下，做$0引用时，才调用

记录分割函数：view plaincopy to clipboardprint?
NODE * do_split(NODE *tree) 
NODE * do_split(NODE *tree)

        根据设定的规则，解析域，包括定长解析，正则解析，字符串解析等。

       （这么多的规则，是为了满足功能和效率需求。）

域层面的函数： 

 

域赋值函数：view plaincopy to clipboardprint?
tatic void set_field(long num, char *str, long len, NODE *dummy ATTRIBUTE_UNUSED)  
tatic void set_field(long num, char *str, long len, NODE *dummy ATTRIBUTE_UNUSED) 

         通过对域节点操作fields_arr[num]，简单的赋域值，这函数由get_field调用

最关健的函数：

域引用函数：view plaincopy to clipboardprint?
NODE ** get_field(register long requested, Func_ptr *assign) 
NODE ** get_field(register long requested, Func_ptr *assign)

         requested是fields_arr的下标数值，下标为零是记录,即$0，下标大于零是域

         这边称为引用函数，因为域引用，有可能是出现在赋值运算符的左边（LHS）或右边（LHS）

          因为在词法解析过程中，$n是出现在赋值语句"="号左边还是右边都是一样的标记，并没有什么不同，

          到语法解析的时候才能明白并且由assign指定，assign为空则是取值引用，非空则是赋值引用

 

          这个函数分为以下四种情况：

           1：$0取值引用，requested=0，assign = NULL

若 field0_valid = FALSE则调用 rebuild_record（重构fields_arr[0])，

返回fields_arr[0]

           2：$n(n>=1)取值引用，requested!=0，assign = NULL

若未进行域解析，则调用域解析函数，

返回fields_arr[n]

           3：$0赋值引用，requested=0，assign != NULL

若 field0_valid = FALSE,同样调用 rebuild_record重构记录，

记录赋值是在 set_record里完成的，返回fields_arr[0]

           4：$n(n>=1)赋值引用：requested!=0，assign = NULL

设置 field0_valid = FALSE;

域赋值在set_field里完成的，返回fields_arr[n]

 

结论：

1：记录值（$0）与各域值（$1,2,….）是分离存放不同node结点里，前者存放在fields_arr[0]，后者存放在fields_arr[1,2...]

2：域赋值引用会引起记录重构和分割（不是同步的）

3：域取值引用会根据情况判断是否进行记录重构，或重新分割。

再看awk的一些更新记录关于get_field函数的说明：

view plaincopy to clipboardprint?
Changes from 2.12.27 to 2.12.28             
Tuned get_field() -- it was unnecessarily parsing the whole record on reference  
  to $0.  
Changes from 2.11.1 to 2.12  
Fixed bug in get_field() whereby changes to a field were not always  
  properly reflected in $0.  
 get_field() passes FS_regexp  
  to re_parse_field(), as does do_split().  
Changes from 2.10beta to 2.11beta  
Fix in get_field() for case where $0 is changed and then $(n) are  
changed and then $0 is used. 
Changes from 2.12.27 to 2.12.28          
Tuned get_field() -- it was unnecessarily parsing the whole record on reference
  to $0.
Changes from 2.11.1 to 2.12
Fixed bug in get_field() whereby changes to a field were not always
  properly reflected in $0.
 get_field() passes FS_regexp
  to re_parse_field(), as does do_split().
Changes from 2.10beta to 2.11beta
Fix in get_field() for case where $0 is changed and then $(n) are
changed and then $0 is used.

其实这部分机制也就是awk程序当前版本的一种设定。在版本变更中，有的做为bug,有的做为设定进行调整。

没必要再深究下去了，知道基本的作用就行了。

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sosodream/archive/2011/05/16/6425192.aspx