一直以来在查对条件是否匹配时，我们使用的都是简单的表达式。那如果你想用超过一个表达式来查对特定的条件呢？

本文中，我们将看看如何在过滤文本和字符串时，结合多个表达式，即复合表达式，用以查对条件。

awk 的复合表达式可由表示“与”的组合操作符 && 和表示“或”的 || 构成。

复合表达式的常规写法如下：

( 第一个表达式 ) && ( 第二个表达式 )

这里只有当“第一个表达式” 和“第二个表达式”都是真值时整个表达式才为真。

( 第一个表达式 ) || ( 第二个表达式) 

这里只要“第一个表达式” 为真或“第二个表达式”为真，整个表达式就为真。

注意：切记要加括号。

表达式可以由比较操作符构成，具体可查看 awk 系列的第四节。

现在让我们通过一个例子来加深理解：

此例中，有一个文本文件 tecmint_deals.txt，文本中包含着一张随机的 Tecmint 交易清单，其中包含了名称、价格和种类。

TecMint Deal List
No      Name                                    Price           Type
1       Mac_OS_X_Cleanup_Suite                  $9.99           Software
2       Basics_Notebook                         $14.99          Lifestyle
3       Tactical_Pen                            $25.99          Lifestyle
4       Scapple                                 $19.00          Unknown
5       Nano_Tool_Pack                          $11.99          Unknown
6       Ditto_Bluetooth_Altering_Device         $33.00          Tech
7       Nano_Prowler_Mini_Drone                 $36.99          Tech 

我们只想打印出价格超过 $20 且其种类为 “Tech” 的物品，在其行末用 (*) 打上标记。

我们将要执行以下命令。

# awk '($3 ~ /^\$[2-9][0-9]*\.[0-9][0-9]$/) && ($4=="Tech") { printf "%s\t%s\n",$0,"*"; } ' tecmint_deals.txt 

6   Ditto_Bluetooth_Altering_Device     $33.00      Tech    *
7   Nano_Prowler_Mini_Drone         $36.99          Tech     *

此例，在复合表达式中我们使用了两个表达式：

• 表达式 1：($3 ~ /^\$[2-9][0-9]*\.[0-9][0-9]$/) ；查找交易价格超过 $20 的行，即只有当 $3 也就是价格满足 /^\$[2-9][0-9]*\.[0-9][0-9]$/ 时值才为真值。
• 表达式 2：($4 == “Tech”) ；查找是否有种类为 “Tech”的交易，即只有当 $4 等于 “Tech” 时值才为真值。 切记，只有当 && 操作符的两端状态，也就是两个表达式都是真值的情况下，这一行才会被打上 (*) 标志。

总结

有些时候为了真正符合你的需求，就不得不用到复合表达式。当你掌握了比较和复合表达式操作符的用法之后，复杂的文本或字符串过滤条件也能轻松解决。

希望本向导对你有所帮助，如果你有任何问题或者补充，可以在下方发表评论，你的问题将会得到相应的解释。

via: http://www.tecmint.com/combine-multiple-expressions-in-awk/

作者：Aaron Kili 译者：martin2011qi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

对于 使用 awk 命令的用户来说，处理一行文本中的数字或者字符串时，使用比较运算符来过滤文本和字符串是十分方便的。

在 awk 系列的此部分中，我们将探讨一下如何使用比较运算符来过滤文本或者字符串。如果你是程序员，那么你应该已经熟悉了比较运算符；对于其它人，下面的部分将介绍比较运算符。

awk 中的比较运算符是什么？

awk 中的比较运算符用于比较字符串和或者数值，包括以下类型：

• > – 大于
• < – 小于
• >= – 大于等于
• <= – 小于等于
• == – 等于
• != – 不等于
• some_value ~ / pattern/ – 如果 some\_value 匹配模式 pattern，则返回 true
• some_value !~ / pattern/ – 如果 some\_value 不匹配模式 pattern，则返回 true

现在我们通过例子来熟悉 awk 中各种不同的比较运算符。

在这个例子中，我们有一个文件名为 food\_list.txt 的文件，里面包括不同食物的购买列表。我想给食物数量小于或等于 30 的物品所在行的后面加上(**)

File – food_list.txt
No      Item_Name               Quantity        Price
1       Mangoes                    45           $3.45
2       Apples                     25           $2.45
3       Pineapples                 5            $4.45
4       Tomatoes                   25           $3.45
5       Onions                     15           $1.45
6       Bananas                    30           $3.45

Awk 中使用比较运算符的通用语法如下：

# 表达式 { 动作; }

为了实现刚才的目的，执行下面的命令：

# awk '$3 <= 30 { printf "%s\t%s\n", $0,"**" ; } $3 > 30 { print $0 ;}' food_list.txt

No  Item_Name`      Quantity    Price
1   Mangoes            45       $3.45
2   Apples             25       $2.45   **
3   Pineapples         5        $4.45   **
4   Tomatoes           25       $3.45   **
5   Onions             15       $1.45   **
6   Bananas            30       $3.45   **

在刚才的例子中，发生如下两件重要的事情：

• 第一个“表达式 {动作;}”组合中， $3 <= 30 { printf “%s\t%s\n”, $0,”**” ; } 打印出数量小于等于30的行，并且在后面增加(**)。物品的数量是通过 $3 这个域变量获得的。
• 第二个“表达式 {动作;}”组合中， $3 > 30 { print $0 ;} 原样输出数量小于等于 30 的行。

再举一个例子：

# awk '$3 <= 20 { printf "%s\t%s\n", $0,"TRUE" ; } $3 > 20  { print $0 ;} ' food_list.txt 

No    Item_Name     Quantity    Price
1     Mangoes          45       $3.45
2     Apples           25       $2.45
3     Pineapples        5       $4.45 TRUE
4     Tomatoes         25       $3.45
5     Onions           15       $1.45 TRUE
6     Bananas          30       $3.45

在这个例子中，我们想通过在行的末尾增加 (TRUE) 来标记数量小于等于20的行。

总结

这是一篇对 awk 中的比较运算符介绍性的指引，因此你需要尝试其他选项，发现更多使用方法。

如果你遇到或者想到任何问题，请在下面评论区留下评论。请记得阅读 awk 系列下一部分的文章，那里我将介绍组合表达式。

via: http://www.tecmint.com/comparison-operators-in-awk/

作者：Aaron Kili 译者：chunyang-wen 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

作为 awk 命令系列的第三部分，这次我们将看一看如何基于用户定义的特定模式来筛选文本或字符串。

在筛选文本时，有时你可能想根据某个给定的条件或使用一个可被匹配的特定模式，去标记某个文件或数行字符串中的某几行。使用 awk 来完成这个任务是非常容易的，这也正是 awk 中可能对你有所帮助的几个功能之一。

让我们看一看下面这个例子，比方说你有一个写有你想要购买的食物的购物清单，其名称为 food\_prices.list，它所含有的食物名称及相应的价格如下所示：

$ cat food_prices.list 
No  Item_Name       Quantity    Price
1   Mangoes            10       $2.45
2   Apples             20       $1.50
3   Bananas            5        $0.90
4   Pineapples         10       $3.46
5   Oranges            10       $0.78
6   Tomatoes           5        $0.55
7   Onions             5        $0.45

然后，你想使用一个 (*) 符号去标记那些单价大于 $2 的食物，那么你可以通过运行下面的命令来达到此目的：

$ awk '/ *\$[2-9]\.[0-9][0-9] */ { print $1, $2, $3, $4, "*" ; } / *\$[0-1]\.[0-9][0-9] */ { print ; }' food_prices.list

打印出单价大于 $2 的项目

从上面的输出你可以看到在含有 芒果 （ mangoes ） 和 菠萝 （ pineapples ） 的那行末尾都已经有了一个 (*) 标记。假如你检查它们的单价，你可以看到它们的单价的确超过了 $2 。

在这个例子中，我们已经使用了两个模式：

• 第一个模式: / *\$[2-9]\.[0-9][0-9] */ 将会得到那些含有食物单价大于 $2 的行，
• 第二个模式: /*\$[0-1]\.[0-9][0-9] */ 将查找那些食物单价小于 $2 的那些行。

上面的命令具体做了什么呢？这个文件有四个字段，当模式一匹配到含有食物单价大于 $2 的行时，它便会输出所有的四个字段并在该行末尾加上一个 (*) 符号来作为标记。

第二个模式只是简单地输出其他含有食物单价小于 $2 的行，按照它们出现在输入文件 food\_prices.list 中的样子。

这样你就可以使用模式来筛选出那些价格超过 $2 的食物项目，尽管上面的输出还有些问题，带有 (*) 符号的那些行并没有像其他行那样被格式化输出，这使得输出显得不够清晰。

我们在 awk 系列的第二部分中也看到了同样的问题，但我们可以使用下面的两种方式来解决：

1、可以像下面这样使用 printf 命令，但这样使用又长又无聊：

$ awk '/ *\$[2-9]\.[0-9][0-9] */ { printf "%-10s %-10s %-10s %-10s\n", $1, $2, $3, $4 "*" ; } / *\$[0-1]\.[0-9][0-9] */ { printf "%-10s %-10s %-10s %-10s\n", $1, $2, $3, $4; }' food_prices.list 

使用 Awk 和 Printf 来筛选和输出项目

2、 使用 $0 字段。Awk 使用变量 0 来存储整个输入行。对于上面的问题，这种方式非常方便，并且它还简单、快速：

$ awk '/ *\$[2-9]\.[0-9][0-9] */ { print $0 "*" ; } / *\$[0-1]\.[0-9][0-9] */ { print ; }' food_prices.list 

使用 Awk 和变量来筛选和输出项目

结论

这就是全部内容了，使用 awk 命令你便可以通过几种简单的方法去利用模式匹配来筛选文本，帮助你在一个文件中对文本或字符串的某些行做标记。

希望这篇文章对你有所帮助。记得阅读这个系列的下一部分，我们将关注在 awk 工具中使用比较运算符。

via: http://www.tecmint.com/awk-filter-text-or-string-using-patterns/

作者：Aaron Kili 译者：FSSlc 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

在 Awk 系列的这一节中，我们将看到 awk 最重要的特性之一，字段编辑。

首先我们要知道，Awk 能够自动将输入的行，分隔为若干字段。每一个字段就是一组字符，它们和其他的字段由一个内部字段分隔符分隔开来。

Awk 输出字段和列

如果你熟悉 Unix/Linux 或者懂得 bash shell 编程，那么你应该知道什么是内部字段分隔符（IFS）变量。awk 中默认的 IFS 是制表符和空格。

awk 中的字段分隔符的工作原理如下：当读到一行输入时，将它按照指定的 IFS 分割为不同字段，第一组字符就是字段一，可以通过 $1 来访问，第二组字符就是字段二，可以通过 $2 来访问，第三组字符就是字段三，可以通过 $3 来访问，以此类推，直到最后一组字符。

为了更好地理解 awk 的字段编辑，让我们看一个下面的例子：

例 1：我创建了一个名为 tecmintinfo.txt 的文本文件。

# vi tecmintinfo.txt
# cat tecmintinfo.txt

在 Linux 上创建一个文件

然后在命令行中，我试着使用下面的命令从文本 tecmintinfo.txt 中输出第一个，第二个，以及第三个字段。

$ awk '//{print $1 $2 $3 }' tecmintinfo.txt
TecMint.comisthe

从上面的输出中你可以看到，前三个字段的字符是以空格为分隔符输出的：

• 字段一是 “TecMint.com”，可以通过 $1 来访问。
• 字段二是 “is”，可以通过 $2 来访问。
• 字段三是 “the”，可以通过 $3 来访问。

如果你注意观察输出的话可以发现，输出的字段值并没有被分隔开，这是 print 函数默认的行为。

为了使输出看得更清楚，输出的字段值之间使用空格分开，你需要添加 (,) 操作符。

$ awk '//{print $1, $2, $3; }' tecmintinfo.txt

TecMint.com is the

需要记住而且非常重要的是，($) 在 awk 和在 shell 脚本中的使用是截然不同的！

在 shell 脚本中，($) 被用来获取变量的值。而在 awk 中，($) 只有在获取字段的值时才会用到，不能用于获取变量的值。

例 2：让我们再看一个例子，用到了一个名为 my\_shoping.list 的包含多行的文件。

No    Item_Name                 Unit_Price  Quantity    Price
1     Mouse                     #20,000     1           #20,000
2     Monitor                   #500,000    1           #500,000
3     RAM_Chips                 #150,000    2           #300,000
4     Ethernet_Cables           #30,000     4           #120,000        

如果你只想输出购物清单上每一个物品的单价，你只需运行下面的命令：

$ awk '//{print $2, $3 }' my_shopping.txt 

Item_Name Unit_Price
Mouse #20,000
Monitor #500,000
RAM_Chips #150,000
Ethernet_Cables #30,000

可以看到上面的输出不够清晰，awk 还有一个 printf 的命令，可以帮助你将输出格式化。

使用 printf 来格式化 Item\_Name 和 Unit\_Price 的输出：

$ awk '//{printf "%-10s %s\n",$2, $3 }' my_shopping.txt 

Item_Name  Unit_Price
Mouse      #20,000
Monitor    #500,000
RAM_Chips  #150,000
Ethernet_Cables #30,000

总结

使用 awk 过滤文本或字符串时，字段编辑的功能是非常重要的。它能够帮助你从一个表的数据中得到特定的列。一定要记住的是，awk 中 ($) 操作符的用法与其在 shell 脚本中的用法是不同的！

希望这篇文章对您有所帮助。如有任何疑问，可以在评论区域发表评论。

via: http://www.tecmint.com/awk-print-fields-columns-with-space-separator/

作者：Aaron Kili 译者：Cathon，ictlyh 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

当我们在 Unix/Linux 下使用特定的命令从字符串或文件中读取或编辑文本时，我们经常需要过滤输出以得到感兴趣的部分。这时正则表达式就派上用场了。

什么是正则表达式?

正则表达式可以定义为代表若干个字符序列的字符串。它最重要的功能之一就是它允许你过滤一条命令或一个文件的输出、编辑文本或配置文件的一部分等等。

正则表达式的特点

正则表达式由以下内容组合而成：

• 普通字符，例如空格、下划线、A-Z、a-z、0-9。

• 可以扩展为普通字符的元字符，它们包括：

  • (.) 它匹配除了换行符外的任何单个字符。
  • (*) 它匹配零个或多个在其之前紧挨着的字符。
  • [ character(s) ] 它匹配任何由其中的字符/字符集指定的字符，你可以使用连字符(-)代表字符区间，例如 [a-f]、[1-5]等。
  • ^ 它匹配文件中一行的开头。
  • $ 它匹配文件中一行的结尾。
  • \ 这是一个转义字符。

你必须使用类似 awk 这样的文本过滤工具来过滤文本。你还可以把 awk 自身当作一个编程语言。但由于这个指南的适用范围是关于使用 awk 的，我会按照一个简单的命令行过滤工具来介绍它。

awk 的一般语法如下：

# awk 'script' filename

此处 'script' 是一个由 awk 可以理解并应用于 filename 的命令集合。

它通过读取文件中的给定行，复制该行的内容并在该行上执行脚本的方式工作。这个过程会在该文件中的所有行上重复。

该脚本 'script' 中内容的格式是 '/pattern/ action'，其中 pattern 是一个正则表达式，而 action 是当 awk 在该行中找到此模式时应当执行的动作。

如何在 Linux 中使用 awk 过滤工具

在下面的例子中，我们将聚焦于之前讨论过的元字符。

一个使用 awk 的简单示例：

下面的例子打印文件 /etc/hosts 中的所有行，因为没有指定任何的模式。

# awk '//{print}' /etc/hosts

awk 打印文件中的所有行

结合模式使用 awk

在下面的示例中，指定了模式 localhost，因此 awk 将匹配文件 /etc/hosts 中有 localhost 的那些行。

# awk '/localhost/{print}' /etc/hosts 

awk 打印文件中匹配模式的行

在 awk 模式中使用通配符 (.)

在下面的例子中，符号 (.) 将匹配包含 loc、localhost、localnet 的字符串。

这里的正则表达式的意思是匹配 l一个字符c。

# awk '/l.c/{print}' /etc/hosts

使用 awk 打印文件中匹配模式的字符串

在 awk 模式中使用字符 (*)

（LCTT 译者注：此处原文作者理解有误，感谢微信读者“止此而已”的提醒，* 在此处表示其前一个字符重复零次或多次，所以实际上相当于 * 及前面的字符是无用的。）

在下面的例子中，将匹配包含 localhost、localnet、lines, capable 的字符串。将匹配带有 c 字符的字符串。

# awk '/l*c/{print}' /etc/localhost

使用 awk 匹配文件中的字符串

你可能也意识到 (*) 将会尝试匹配它可能检测到的最长的匹配。

让我们看一看可以证明这一点的例子，正则表达式 t*t 的意思是在下面的行中匹配以 t 开始和 t 结束的字符串：将匹配带有 t 字符的字符串：

this is tecmint, where you get the best good tutorials, how to's, guides, tecmint. 

当你使用模式 /t*t/ 时，会得到如下可能的结果：以下字符串只是有 t 字符而已：

this is t
this is tecmint
this is tecmint, where you get t
this is tecmint, where you get the best good t
this is tecmint, where you get the best good tutorials, how t
this is tecmint, where you get the best good tutorials, how tos, guides, t
this is tecmint, where you get the best good tutorials, how tos, guides, tecmint

在 /t*t/ 中的通配符 (*) 将使得 awk 选择匹配的最后一项：以下字符串只是有 t 字符而已：

this is tecmint, where you get the best good tutorials, how to's, guides, tecmint

结合集合 [ character(s) ] 使用 awk

以集合 [al1] 为例，awk 将匹配文件 /etc/hosts 中所有包含字符 a 或 l 或 1 的字符串。

# awk '/[al1]/{print}' /etc/hosts

使用 awk 打印文件中匹配的字符

下一个例子匹配以 K 或 k 开始（非指行首是该字母），后面跟着一个 T 的字符串：

# awk '/[Kk]T/{print}' /etc/hosts 

使用 awk 打印文件中匹配的字符

以范围的方式指定字符

awk 所能理解的字符：

• [0-9] 代表一个单独的数字
• [a-z] 代表一个单独的小写字母
• [A-Z] 代表一个单独的大写字母
• [a-zA-Z] 代表一个单独的字母
• [a-zA-Z 0-9] 代表一个单独的字母或数字

让我们看看下面的例子：

# awk '/[0-9]/{print}' /etc/hosts 

使用 awk 打印文件中匹配的数字

在上面的例子中，文件 /etc/hosts 中的所有行都至少包含一个单独的数字 [0-9]。

结合元字符 (^) 使用 awk

在下面的例子中，它匹配所有以给定模式开头的行：

# awk '/^fe/{print}' /etc/hosts
# awk '/^ff/{print}' /etc/hosts

使用 awk 打印与模式匹配的行

结合元字符 ($) 使用 awk

它将匹配所有以给定模式结尾的行：

# awk '/ab$/{print}' /etc/hosts
# awk '/ost$/{print}' /etc/hosts
# awk '/rs$/{print}' /etc/hosts

使用 awk 打印与模式匹配的字符串

结合转义字符 () 使用 awk

它允许你将该转义字符后面的字符作为文字，即理解为其字面的意思。

在下面的例子中，第一个命令打印出文件中的所有行，第二个命令中我想匹配具有 $25.00 的一行，但我并未使用转义字符，因而没有打印出任何内容。

第三个命令是正确的，因为一个这里使用了一个转义字符以转义 $，以将其识别为 '$'（而非元字符）。

# awk '//{print}' deals.txt
# awk '/$25.00/{print}' deals.txt
# awk '/\$25.00/{print}' deals.txt

结合转义字符使用 awk

总结

以上内容并不是 awk 命令用做过滤工具的全部，上述的示例均是 awk 的基础操作。在下面的章节中，我将进一步介绍如何使用 awk 的高级功能。感谢您的阅读，请在评论区贴出您的评论。

via: http://www.tecmint.com/use-linux-awk-command-to-filter-text-string-in-files/

作者：Aaron Kili 译者：wwy-hust 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

图片来源: Shutterstock

我们不要让下一代 Linux 和 Unix 的管理员忘记初始化脚本和基本工具的好处

我曾经有一次在 Reddit 看到一个帖子，“请问如何操作文本文件”。这是一个很简单的需求，就像我们常用 Unix 的人每天遇到的一样。他的问题是，如何删除文件中的重复行，只保留不重复的。 这听起来似乎很简单，但是当文件足够大时，就会有些复杂。

这个问题有很多种不同的答案。你可以使用几乎任何一种语言来写这样的一个脚本，只是时间的投入和代码的复杂性不同罢了。根据你的个人水平，它大概会花费20-60分钟。但是如果你使用了 Perl、Python、Ruby 中的一种，你可能很快实现它。

或者你可以使用下面的一个方法，让你无比暖心的: 只用 awk。

这个答案是迄今为止最简明、最简单的解决问题的方法。它只要一行！

awk '!seen[$0]++' <filename>

让我们来看看发生了什么：

在这个命令中，其实隐藏了很多代码。awk 是一种文本处理语言，并且它内部有很多预设。首先，你看到的实际上是一个 for 循环的结果。awk 假定你想通过循环处理输入文件的每一行，所以你不需要明确的去指定它。awk 还假定了你需要打印输出处理后的数据，所以你也不需要去指定它。最后，awk 假定循环在最后一句指令执行完结束，这一块也不再需要你去指定它。

这个例子中的字符串 seen 是一个关联数组的名字。$0 是一个变量，表示整个当前行。所以，这个命令翻译成人类语言就是“对这个文件的每一行进行检查，如果你之前没有见过它，就打印出来。” 如果该关联数组的键名还不存在就添加到数组，并增加其取值，这样 awk 下次遇到同样的行时就会不匹配（条件判断为“假”），从而不打印出来。

据微博上 @ZorroLang 的补充：少提了一个重点，要不然只会 C 语言的人很难理解为什么 seen[$0]++ 一行代码就行了，这里隐含了 awk 对于其数组变量的处理方式。awk 的数组是关联数组，且不需要声明，而是引用即创建，注意是创建，后面都不会消失的。也就是你像 str[any] 这样随便写一个数组变量，这个数组元素就此就创建了，且初始化为0或空。

谢谢 @ZorroLang ~

一些人认为这样是优雅的，另外的人认为这可能会造成混淆。任何在日常工作上使用 awk 的都是第一类人。awk 就是设计用来做这个的。在 awk 中，你可以写多行代码。你甚至可以用 awk 写一些让人不安的复杂功能。但终究来说，awk 还是一个进行文本处理的程序，一般是通过管道。去掉（没必要的）循环定义是很常见的快捷用法，不过如果你乐意，你也可以用下面的代码做同样的事情：

awk '{ if (!seen[$0]) print $0; seen[$0]++ }’ 

这会产生相同的结果。

awk 是完成这项工作的完美工具。不过，我相信很多管理员--特别是新管理员会转而使用 Bash 或 Python 来完成这一任务，因为对 awk 的知识和对它的能力的了解看起来随着时间而慢慢被人淡忘。我认为这是标志着一个问题，由于对之前的解决方案缺乏了解，那些已经解决了几十年的问题又突然出现了。

shell、grep、sed 和 awk 是 Unix 的基础。如果你不能非常轻松的使用它们，你将会被自己束缚住，因为它们构成了通过命令行和脚本与 Unix 系统交互的基础。学习这些工具如何工作最好的方法之一就是观察真实的例子和实验，你可以在各种 Unix 衍生系统的初始化系统中找到很多，但在 Linux 发行版中它们已经被 systemd 取代了。

数以百万计的 Unix 管理员了解 Shell 脚本和 Unix 工具如何读、写、修改和用在初始化脚本上。不同系统的初始化脚本有很大不同，甚至是不同的 Linux 发行版也不同。但是它们都源自 sh，而且它们都用像 sed、awk 还有 grep 这样的核心的命令行工具。

我每天都会听到很多人抱怨初始化脚本太“古老”而且很“难”。但是实际上，初始化脚本和 Unix 管理员每天使用的工具一样，还提供了一个非常好的方式来更加熟悉和习惯这些工具。说初始化脚本难于阅读和难于使用实际上是承认你缺乏对 Unix 基础工具的熟悉。

说起在 Reddit 上看到的内容，我也碰到过这个问题，来自一个新入行的 Linux 系统管理员, “问他是否应该还要去学老式的初始化系统 sysvinit”。 这个帖子的大多数的答案都是正面的——是的，应该学习 sysvinit 和 systemd 两个。一位评论者甚至指出，初始化脚本是学习 Bash 的好方法。而另一个消息是，Fortune 50 强的公司还没有计划迁移到以 systemd 为基础的发行版上。

但是，这提醒了我这确实是一个问题。如果我们继续沿着消除脚本和脱离操作系统核心组件的方式发展下去，由于疏于接触，我们将会不经意间使新管理员难于学习基本的 Unix 工具。

我不知道为什么有些人想在一层又一层的抽象化来掩盖 Unix 内部，但是这样发展下去可能会让新一代的系统管理员们变成只会按下按钮的工人。我觉得这不是一件好事情。

via: http://www.infoworld.com/article/2985804/linux/remember-sed-awk-linux-admins-should.html

作者：Paul Venezia 译者：Bestony 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出