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

最新推荐文章于 2023-08-05 21:45:18 发布
最新推荐文章于 2023-08-05 21:45:18 发布
阅读量4.1k 收藏 5
点赞数 1
分类专栏： Shell 文章标签： parsing null pointers reference 数据结构 debugging
详细解析了GNU awk中$1=$1与$0=$0的具体作用，介绍了这两种赋值方式如何影响记录的重构与域的分割。通过实际案例展示了如何利用这些特性来改变输入和输出字段分隔符。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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,有的做为设定进行调整。

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

 

本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/sosodream/archive/2011/05/16/6425192.aspx

Awk里的域赋值操作和部分源码解析（$1=$1,$0=$0,FS,OFS)
星晨大海
05-16 7007
前言：cu上出了个shell题：http://bbs.chinaunix.net/thread-2319120-1-1.html第八题：GNU awk的$1=$1到底有什么作用？$0=$0呢？这题问得相当的细致。可能很多人已经常用这二个赋值语句，却半知半解。以下分二部分对这个题目进行分析建议没心情，没耐心，没兴趣的人，只需要了解下第一部分，看第二部分就表看了，很罗嗦的。第一部分：能过man上边的解析，回签这二个赋值语句的功能第二部分：awk部分源码解析（结点树简介，及域模块)          通过分析a
[Shell] awk $1=$1
cizhiyou2391的博客
05-03 1788
$1=$1 是用来激活$0的重新赋值,也就是说 字段$1...和字段数NF的改变会促使awk重新计算$0的值,通常是在改变OFS后而需要输出$0时这样做 echo "A B C D" | awk '{OFS="|";prin...
awk学习笔记
weixin_34006965的博客
04-30 5280
不错的学习链接：所以拷贝下来了http://sebug.net/paper/books/awk/ awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息awk处理过程:依次对每一行进行处理，然后输出awk命令形式:awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END...
awk的$1=$1与$0=$0
weixin_34387468的博客
11-11 1886
awk的$1=$1与$0=$0 2012-04-16 10:41:03|分类： Editor |标签：linuxawk |字号大中小订阅 $1=$1 是用来激活$0的重新赋值,也就是说 字段$1...和字段数NF的改变会促使awk重新计算$0的值,通常是在改变OFS后而需要输出$0时这样做 echo "A B C D" | ...
$1=$1的解释?
一步一步
01-03 2051
有一文本类似 "aaa bbb ccc" 需求是把中间的分隔符替换成竖线" | "比较直观的结果如下: echo "aaa bbb ccc" | nawk {print $1"|"$2"|"$3}比较高深的结果如下: echo "aaa bbb ccc" | nawk BEGIN{OFS="|"} {$1=$1;print}                        或者: echo
GNU Awk - 中文版1
08-08
《GNU Awk - 中文版1》是一本详细介绍GNU Awk的参考手册，适用于广泛的读者群体，无论是初学者还是经验丰富的程序员。Awk是一种强大的文本分析工具，它基于Alfred V. Aho、Brian W. Kernighan和Peter J. Weinberger...
GNU AWK 英文版使用手册
02-04
手册中提到的文档的ISBN是1-882114-28-0，版权信息显示，该手册是根据GNU自由文档许可证进行复制、分发和/或修改的。 手册的作者是Arnold D. Robbins，他是AWK编程领域的专家，他的作品是这一领域中非常重要的参考...
GAWK-Effective AWK Programming - GNU Awk编程经典
04-24
标签“GAWK AWK”表明这本书专注于GNU Awk的编程，同时涉及了通用的Awk编程知识，因为Awk语言本身在多种版本的Unix和类Unix系统中都有实现。 在提供的部分内容中，我们可以看到书籍的结构，它分为几个部分（Part）...
The GNU Awk User's Guide
11-22
The GNU Awk User's Guide
bash-{$1=$1；print $0}中關於$1 = $1的小疑問
weixin_39773337的博客
07-19 268
原例子出處：https://blog.youkuaiyun.com/xuejinliang/article/details/52250599 文件cat dir.txt如下： % 1 2 3 % 4 5 % 6 7 8 9 % 使输出结果为 1 2 3 4 5 6 7 8 9 处理的方式如下 原貼： awk ‘{RS=”#\n”;ORS=”\n”;OFS=” ”;}NR!=1{$1=$1;print $0}’ file 實際上我發現下面也可以： cat dir.txt | awk 'BEGIN{RS="#\n"}NR
shell 去空格，去掉字符串前后空格（awk、sed 、eval）
热门推荐
猎人在吃肉
06-09 3万+
正则表达式说明： ^\s+ 匹配行首一个或多个空格 \s+$ 匹配行末一个或多个空格 ^\s+|\s+$ 同时匹配行首或者行末的空格 1、awk 去空格 方法1： [root@localhost ~]# echo ' A B C ' | awk '{gsub(/^\s+|\s+$/, "");print}' A B C 方法2： [root@linux ~]# echo " A B C " | awk '$1=$1' A B C 2、eval 去空格
GNU awk的$1=$1到底有什么作用?$0=$0呢?
lin_FS的专栏
12-15 3244
转载：http://www.codeweblog.com/gnu-awk%E7%9A%84-1-1%E5%88%B0%E5%BA%95%E6%9C%89%E4%BB%80%E4%B9%88%E4%BD%9C%E7%94%A8-0-0%E5%91%A2/ GNU awk的$1=$1到底有什么作用？$0=$0呢？ $1=$1 是用来激活$0的重新赋值,也就是说 字段$1...和字段数NF的
awk命令
executive
08-17 329
文章目录awk awk 在awk中输出的自定义字符串 默认都当做变量，只有加双引号，文件名在执行框中也要加引号 awk是一行一行执行的 awk中的$1表示第一个字段,$2表示第二个字段,以此类推， $0表示一整行- 内置变量> FS设置域分隔符 等于-F(在没输出屏幕之前字段之间的分隔符） OFS 输出域分隔符 改变文件内容的分割符号，并且打印出来（显示到屏幕字段之间的分隔符） NF 浏...
Linux Shell文本处理三剑客grep、sed、awk总结
清风
05-18 1652
目录 grep sed工具 地址 基础命令： 高级编辑： 标签 awk 选项： 内置变量： 模式： awk流程控制： 内置函数 I/O语句 自定义函数 grep 过滤来自一个文件或标准输入匹配模式内容。 除了 grep 外，还有 egrep、fgrep。egrep 是 grep 的扩展，相当于 grep -E。fgrep 相当于 grep - f，用的少。 用法：grep [OPTION]... PATTERN [FILE]... 常用选项： -E：支持扩展正则
awk学习(1)
星星的技术专栏
10-09 1261
好文章http://www.linux.gov.cn/shell/awk.htm 一、处理方式      awk用于处理文本文件，awk的处理文本文件的方式是这样的，它逐行扫描文件，从第一行到最后一行，寻找匹配的特定模式的行，并在这些行上进行你想要的操作。如果没有指定处理动作，则把匹配的行显示到标准输出(屏幕)，如果没有指定模式，则所有被操作所指定的行都被处理。
正则部分内容、回溯漏洞案例、awk案例
vt_yjx的博客
08-05 441
NFA引擎在匹配过程中可能需要进行回溯，因此相对于DFA引擎来说，它的匹配速度可能会稍慢一些，并且在匹配复杂的正则表达式时，可能会出现回溯次数过多的情况。DFA引擎可以处理使用有限状态自动机来实现匹配，不需要进行回溯，因此匹配速度非常快，而且不会受到回溯次数限制的影响。以小括号为界，括号内的就是一个组，第几次出现的括号就是第几组，之后可以用对应数字引用该组，但引用的不是组内的正则，而是值。但是确执行了16步，原因是\d匹配数字，没问题，但是\b无法左边不是数字，就不算是边界，所以匹配失败，
Linux awk 入门教程
程序员的那些事
11-16 793
（给程序员的那些事加星标）来源：阮一峰www.ruanyifeng.com/blog/2018/11/awk.htmlawk 是处理文本文件的一个应用程序，几乎所有 Li...
test system
weixin_30586085的博客
07-18 448
$1在shell中称为“位置参数”，表示传入的第1个参数（第1个入参）。用在shell脚本主体中，表示shell脚本的第1个入参。用在shell脚本函数里，表示函数的第1个入参。test -z $1 是一个判断表达式，用于判断$1的值是否为空字符串。若为空，则结果为true；否则为false。 UNAME_OS=`(uname -s) 2>/dev/null` if test -z "$s...
正则表达式中的$1的使用方法
weixin_30772105的博客
03-01 4227
<script type="text/javascript"> //正则表达式中的$1的使用方法，在replice中$1不需要加RegExp，但是$1需加引号。var str1='120' var str2='120pt' var str3='120px' var reg=/^(\d+)(pt|px|em)?/ alert(reg.exec(str3)...
awk '{print $0}|"/bin/sh"
最新发布
08-06
<think>我们正在讨论如何在awk命令中调用shell命令。根据用户的问题，他/她想知道如何通过awk命令调用shell命令。 在awk中，有两种主要方法可以调用shell命令： 1. 使用system()函数：这个函数可以执行一个字符串作为shell命令，并返回命令的退出状态。 2. 使用管道：通过管道将数据传递给shell命令，并读取命令的输出。 需要注意的是，awk本身是一种文本处理工具，但有时我们需要在awk脚本中执行一些外部命令。 我们将分别给出示例： 1. 使用system()函数： 语法：system("shell command") 示例：假设我们有一个文件，我们想用awk处理每一行，同时对于每一行，我们使用shell的echo命令打印一个额外的信息。 awk '{print $0; system("echo 这一行有 " length($0) " 个字符")}' filename 注意：system()函数会启动一个shell来执行命令，所以可以执行任何在shell中能执行的命令。但是，它不会将awk的变量直接传递给shell命令，我们需要通过字符串拼接的方式将awk变量嵌入命令字符串中。 2. 使用管道（getline）： 我们可以通过管道将命令的输出读入awk变量中。 示例：我们想要将当前目录下的文件列表读入awk，然后打印每个文件名和其大小。 awk 'BEGIN { command = "ls -l" while ( (command | getline result) > 0 ) { print result } close(command) }' 这里，我们使用`command | getline`来读取命令的输出，每次读取一行。注意，使用完后要关闭命令（close(command)），否则可能会造成资源泄漏。 另外，我们也可以将awk的输出通过管道传递给外部命令，例如： awk '{print $1 | "sort -r"}' filename # 将第一列排序后输出 但是，用户的问题是关于在awk中调用shell命令，所以重点在于如何执行shell命令。 根据引用[2]：AWK是按一行一行地读取输入的。所以，在每行处理中调用system()是常见的做法。 然而，需要注意的是，频繁调用system()会降低awk的效率，因为每个system()调用都会启动一个新的shell进程。 因此，如果可能，尽量在awk中完成文本处理，或者考虑将数据收集起来，然后一次调用外部命令处理多个数据。 现在，我们根据用户的问题，给出一个具体的例子： 假设我们有一个文件data.txt，内容如下： apple 5 banana 3 orange 4 我们想使用awk计算每种水果的总价（假设单价为每公斤10元），并且使用shell的bc命令来进行浮点数乘法（因为awk本身不直接支持浮点数计算，但实际awk也可以做浮点运算，这里仅作为调用shell命令的示例）。 我们可以这样写： awk '{ # 使用system调用bc计算，但注意system不返回命令的输出，只返回退出状态 # 所以我们需要将结果写入一个临时文件，然后再读取，这样很麻烦 # 因此，这里我们使用getline的方式 cmd = "echo " $2 "*10 | bc" cmd | getline result close(cmd) print $1, $2, result }' data.txt 但是，实际上这个计算用awk本身就可以完成：$2*10，所以这里只是演示。 更常见的场景是调用一些外部工具，比如调用date命令转换日期格式等。 另外，注意在awk中调用shell命令时，命令字符串的构造要小心，特别是当字段中包含空格或特殊字符时，需要做适当的转义。 因此，我们给出一个更实际的例子：在awk中调用shell命令来转换日期格式。 假设文件dates.txt包含： 2023-01-01 2023-02-15 我们想将日期格式转换成“月/日/年”格式，即01/01/2023。我们可以使用系统的date命令（注意：这个例子在GNU date下有效）。 awk '{ cmd = "date -d \"" $0 "\" +%m/%d/%Y" cmd | getline newdate close(cmd) print newdate }' dates.txt 注意：这里我们使用了-d选项（GNU date），如果是其他系统的date命令可能不支持。 总结： - 使用system()函数：当不需要获取命令输出，只需要执行命令（如重定向输出到文件，或者执行一些操作）时。 - 使用管道和getline：当需要获取命令输出时。 最后，我们提醒用户，在awk中调用shell命令会带来性能开销，并且可能引入安全风险（如果命令字符串来自不可信的输入，则可能执行任意命令），因此请谨慎使用。 根据要求，我们生成相关问题： 1. 如何在awk中安全地构造shell命令字符串？ 2. 除了system和getline，还有没有其他方法在awk中调用外部命令？ 3. 如何避免在awk中频繁调用外部命令导致的性能问题？</think>### 如何在awk命令中调用Shell命令 在awk中调用Shell命令主要有两种方式，通过`system()`函数或管道配合`getline`实现： #### 1. **使用 `system()` 函数** 直接执行Shell命令，返回值为命令的退出状态码（0表示成功）： ```awk # 示例：每处理一行就执行一次Shell命令 awk '{ print "当前行:", $0; status = system("echo '执行Shell命令' > log.txt"); if (status != 0) print "命令执行失败" }' input.txt ``` - **说明**： - `system("command")` 会启动子Shell执行命令 - 命令输出默认直接显示到终端（可通过重定向捕获） - 适合无需获取命令输出的场景（如创建文件） #### 2. **使用管道与 `getline`** 捕获命令输出到awk变量： ```awk # 示例：将命令输出读入变量 awk 'BEGIN { cmd = "date +%F"; cmd | getline today; # 将date命令结果存入today close(cmd); # 关闭管道 print "当前日期:", today }' ``` - **关键点**： - `command | getline var` 将命令输出保存到变量`var` - 必须显式`close(command)`关闭管道，避免资源泄漏 - 适合需要处理命令输出的场景（如提取系统信息） --- ### ⚠️ 注意事项 1. **性能影响**：频繁调用Shell命令会显著降低效率，尽量用awk内置函数替代 - 例如用`gsub()`代替`sed`，用算术运算代替`bc` 2. **命令注入风险**：避免直接使用未过滤的外部数据构造命令 ```awk # 危险示例（用户输入未过滤） awk -v user_input="$1" '{ system("rm " user_input) }' ``` 3. **返回值处理**： - `system()`返回退出状态码（非输出内容） - 管道错误需检查`getline`返回值（成功=1, 失败=-1） --- ### 典型应用场景 1. **动态获取系统信息** ```awk awk 'BEGIN { "uname -m" | getline arch; print "系统架构:", arch }' ``` 2. **结合外部工具处理数据** ```awk # 用gzip压缩匹配行 awk '/error/ { print | "gzip > errors.log.gz" } END { close("gzip > errors.log.gz") }' logfile ``` 3. **文件操作** ```awk # 找到大文件后移动 awk 'BEGIN { cmd="find . -size +1G" } while ((cmd | getline file) > 0) { system("mv -v \"" file "\" /backup/") } close(cmd)' ``` --- ### 常见问题解决 **Q：命令输出包含空格时如何处理？** A：用双引号包裹变量，例如： ```awk system("grep \"" $1 "\" /etc/passwd") ``` **Q：如何并发执行命令？** A：在END块中统一处理，避免行处理时阻塞： ```awk { data[$1]++ } END { for (key in data) { print key, data[key] | "sort -k2n > result.txt" } close("sort -k2n > result.txt") } ``` > 参考文档：AWK执行Shell命令时，每次调用`system()`或管道都会创建新进程。在数据量较大时，建议批量处理命令以减少开销[^1]。AWK的管道操作需显式关闭，否则可能导致资源耗尽[^2]。 --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值