与其手动执行重复性的任务，不如让 Linux 为你做。

在 2021 年，人们有更多的理由喜欢 Linux。在这个系列中，我将分享使用 Linux 的 21 个不同理由。自动化是使用 Linux 的最佳理由之一。

我最喜欢 Linux 的一个原因是它愿意为我做工作。我不想执行重复性的任务，这些任务会占用我的时间，或者容易出错，或者我可能会忘记，我安排 Linux 为我做这些工作。

为自动化做准备

“自动化”这个词既让人望而生畏，又让人心动。我发现用模块化的方式来处理它是有帮助的。

1、你想实现什么？

首先，要知道你想产生什么结果。你是要给图片加水印吗？从杂乱的目录中删除文件？执行重要数据的备份？为自己明确定义任务，这样你就知道自己的目标是什么。如果有什么任务是你发现自己每天都在做的，甚至一天一次以上，那么它可能是自动化的候选者。

2、学习你需要的应用

将大的任务分解成小的组件，并学习如何手动但以可重复和可预测的方式产生每个结果。在 Linux 上可以做的很多事情都可以用脚本来完成，但重要的是要认识到你当前的局限性。学习如何自动调整几张图片的大小，以便可以方便地通过电子邮件发送，与使用机器学习为你的每周通讯生成精心制作的艺术品之间有天壤之别。有的事你可以在一个下午学会，而另一件事可能要花上几年时间。然而，我们都必须从某个地方开始，所以只要从小做起，并时刻注意改进的方法。

3、自动化

在 Linux 上使用一个自动化工具来定期实现它。这就是本文介绍的步骤!

要想自动化一些东西，你需要一个脚本来自动化一个任务。在测试时，最好保持简单，所以本文自动化的任务是在 /tmp 目录下创建一个名为 hello 的文件。

#!/bin/sh

touch /tmp/hello

将这个简单的脚本复制并粘贴到一个文本文件中，并将其命名为 example。

Cron

每个安装好的 Linux 系统都会有的内置自动化解决方案就是 cron 系统。Linux 用户往往把 cron 笼统地称为你用来安排任务的方法（通常称为 “cron 作业”），但有多个应用程序可以提供 cron 的功能。最通用的是 cronie；它的优点是，它不会像历史上为系统管理员设计的 cron 应用程序那样，假设你的计算机总是开着。

验证你的 Linux 发行版提供的是哪个 cron 系统。如果不是 cronie，你可以从发行版的软件仓库中安装 cronie。如果你的发行版没有 cronie 的软件包，你可以使用旧的 anacron 软件包来代替。anacron 命令是包含在 cronie 中的，所以不管你是如何获得它的，你都要确保在你的系统上有 anacron 命令，然后再继续。anacron 可能需要管理员 root 权限，这取决于你的设置。

$ which anacron
/usr/sbin/anacron

anacron 的工作是确保你的自动化作业定期执行。为了做到这一点，anacron 会检查找出最后一次运行作业的时间，然后检查你告诉它运行作业的频率。

假设你将 anacron 设置为每五天运行一次脚本。每次你打开电脑或从睡眠中唤醒电脑时，anacron都会扫描其日志以确定是否需要运行作业。如果一个作业在五天或更久之前运行，那么 anacron 就会运行该作业。

Cron 作业

许多 Linux 系统都捆绑了一些维护工作，让 cron 来执行。我喜欢把我的工作与系统工作分开，所以我在我的主目录中创建了一个目录。具体来说，有一个叫做 ~/.local 的隐藏文件夹（“local” 的意思是它是为你的用户账户定制的，而不是为你的“全局”计算机系统定制的），所以我创建了子目录 etc/cron.daily 来作为 cron 在我的系统上的家目录。你还必须创建一个 spool 目录来跟踪上次运行作业的时间。

$ mkdir -p ~/.local/etc/cron.daily ~/.var/spool/anacron

你可以把任何你想定期运行的脚本放到 ~/.local/etc/cron.daily 目录中。现在把 example 脚本复制到目录中，然后 用 chmod 命令使其可执行。

$ cp example ~/.local/etc/cron.daily
# chmod +x ~/.local/etc/cron.daily/example

接下来，设置 anacron 来运行位于 ~/.local/etc/cron.daily 目录下的任何脚本。

anacron

默认情况下，cron 系统的大部分内容都被认为是系统管理员的领域，因为它通常用于重要的底层任务，如轮换日志文件和更新证书。本文演示的配置是为普通用户设置个人自动化任务而设计的。

要配置 anacron 来运行你的 cron 作业，请在 /.local/etc/anacrontab 创建一个配置文件：

SHELL=/bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin
1  0  cron.mine    run-parts /home/tux/.local/etc/cron.daily/

这个文件告诉 anacron 每到新的一天（也就是每日），延迟 0 分钟后，就运行（run-parts）所有在 ~/.local/etc/cron.daily 中找到的可执行脚本。有时，会使用几分钟的延迟，这样你的计算机就不会在你登录后就被所有可能的任务冲击。不过这个设置适合测试。

cron.mine 值是进程的一个任意名称。我称它为 cron.mine，但你也可以称它为 cron.personal 或 penguin 或任何你想要的名字。

验证你的 anacrontab 文件的语法：

$ anacron -T -t ~/.local/etc/anacrontab \
  -S /home/tux/.var/spool/anacron

沉默意味着成功。

在 .profile 中添加 anacron

最后，你必须确保 anacron 以你的本地配置运行。因为你是以普通用户而不是 root 用户的身份运行 anacron，所以你必须将它引导到你的本地配置：告诉 anacron 要做什么的 anacrontab 文件，以及帮助 anacron 跟踪每一个作业最后一次执行是多少天的 spool 目录：

anacron -fn -t /home/tux/.local/etc/anacrontab \
  -S /home/tux/.var/spool/anacron

-fn 选项告诉 anacron 忽略 时间戳，这意味着你强迫它无论如何都要运行你的 cron 作业。这完全是为了测试的目的。

测试你的 cron 作业

现在一切都设置好了，你可以测试作业了。从技术上讲，你可以在不重启的情况下进行测试，但重启是最有意义的，因为这就是设计用来处理中断和不规则的登录会话的。花点时间重启电脑、登录，然后寻找测试文件：

$ ls /tmp/hello
/tmp/hello

假设文件存在，那么你的示例脚本已经成功执行。现在你可以从 ~/.profile 中删除测试选项，留下这个作为你的最终配置。

anacron -t /home/tux/.local/etc/anacrontab \
  -S /home/tux/.var/spool/anacron

使用 anacron

你已经配置好了你的个人自动化基础设施，所以你可以把任何你想让你的计算机替你管理的脚本放到 ~/.local/etc/cron.daily 目录下，它就会按计划运行。

这取决于你希望作业运行的频率。示例脚本是每天执行一次。很明显，这取决于你的计算机在任何一天是否开机和醒着。如果你在周五使用电脑，但把它设置在周末，脚本就不会在周六和周日运行。然而，在周一，脚本会执行，因为 anacron 会知道至少有一天已经过去了。你可以在 ~/.local/etc 中添加每周、每两周、甚至每月的目录，以安排各种各样的间隔。

要添加一个新的时间间隔：

1. 在 ~/.local/etc 中添加一个目录（例如 cron.weekly）。
2. 在 ~/.local/etc/anacrontab 中添加一行，以便在新目录下运行脚本。对于每周一次的间隔，其配置如下。7 0 cron.mine run-parts /home/tux/.local/etc/cron.weekly/（0 的值可以选择一些分钟数，以适当地延迟脚本的启动）。
3. 把你的脚本放在 cron.weekly 目录下。

欢迎来到自动化的生活方式。它不会让人感觉到，但你将会变得更有效率。

via: https://opensource.com/article/21/2/linux-automation

作者：Seth Kenlon 选题：lujun9972 译者：wxy 校对：wxy

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

了解 Lua 如何处理数据的读写。

有些数据是临时的，存储在 RAM 中，只有在应用运行时才有意义。但有些数据是要持久的，存储在硬盘上供以后使用。当你编程时，无论是简单的脚本还是复杂的工具套件，通常都需要读取和写入文件。有时文件可能包含配置选项，而另一些时候这个文件是你的用户用你的应用创建的数据。每种语言都会以不同的方式处理这项任务，本文将演示如何使用 Lua 处理文件数据。

安装 Lua

如果你使用的是 Linux，你可以从你的发行版软件库中安装 Lua。在 macOS 上，你可以从 MacPorts 或 Homebrew 安装 Lua。在 Windows 上，你可以从 Chocolatey 安装 Lua。

安装 Lua 后，打开你最喜欢的文本编辑器并准备开始。

用 Lua 读取文件

Lua 使用 io 库进行数据输入和输出。下面的例子创建了一个名为 ingest 的函数来从文件中读取数据，然后用 :read 函数进行解析。在 Lua 中打开一个文件时，有几种模式可以启用。因为我只需要从这个文件中读取数据，所以我使用 r（代表“读”）模式：

function ingest(file)
   local f = io.open(file, "r")
   local lines = f:read("*all")
   f:close()
   return(lines)
end

myfile=ingest("example.txt")
print(myfile)

在这段代码中，注意到变量 myfile 是为了触发 ingest 函数而创建的，因此，它接收该函数返回的任何内容。ingest 函数返回文件的行数（从一个称为 lines 的变量中0。当最后一步打印 myfile 变量的内容时，文件的行数就会出现在终端中。

如果文件 example.txt 中包含了配置选项，那么我会写一些额外的代码来解析这些数据，可能会使用另一个 Lua 库，这取决于配置是以 INI 文件还是 YAML 文件或其他格式存储。如果数据是 SVG 图形，我会写额外的代码来解析 XML，可能会使用 Lua 的 SVG 库。换句话说，你的代码读取的数据一旦加载到内存中，就可以进行操作，但是它们都需要加载 io 库。

用 Lua 将数据写入文件

无论你是要存储用户用你的应用创建的数据，还是仅仅是关于用户在应用中做了什么的元数据（例如，游戏保存或最近播放的歌曲），都有很多很好的理由来存储数据供以后使用。在 Lua 中，这是通过 io 库实现的，打开一个文件，将数据写入其中，然后关闭文件：

function exgest(file)
   local f = io.open(file, "a")
   io.output(f)
   io.write("hello world\n")
   io.close(f)
end

exgest("example.txt")

为了从文件中读取数据，我以 r 模式打开文件，但这次我使用 a （用于”追加“）将数据写到文件的末尾。因为我是将纯文本写入文件，所以我添加了自己的换行符（/n）。通常情况下，你并不是将原始文本写入文件，你可能会使用一个额外的库来代替写入一个特定的格式。例如，你可能会使用 INI 或 YAML 库来帮助编写配置文件，使用 XML 库来编写 XML，等等。

文件模式

在 Lua 中打开文件时，有一些保护措施和参数来定义如何处理文件。默认值是 r，允许你只读数据：

• r 只读
• w 如果文件不存在，覆盖或创建一个新文件。
• r+ 读取和覆盖。
• a 追加数据到文件中，或在文件不存在的情况下创建一个新文件。
• a+ 读取数据，将数据追加到文件中，或文件不存在的话，创建一个新文件。

还有一些其他的(例如，b 代表二进制格式)，但这些是最常见的。关于完整的文档，请参考 Lua.org/manual 上的优秀 Lua 文档。

Lua 和文件

和其他编程语言一样，Lua 有大量的库支持来访问文件系统来读写数据。因为 Lua 有一个一致且简单语法，所以很容易对任何格式的文件数据进行复杂的处理。试着在你的下一个软件项目中使用 Lua，或者作为 C 或 C++ 项目的 API。

via: https://opensource.com/article/21/3/lua-files

作者：Seth Kenlon 选题：lujun9972 译者：geekpi 校对：wxy

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

学习 Bash 读取和写入数据的不同方式，以及何时使用每种方法。

当你使用 Bash 编写脚本时，有时你需要从一个文件中读取数据或向一个文件写入数据。有时文件可能包含配置选项，而另一些时候这个文件是你的用户用你的应用创建的数据。每种语言处理这个任务的方式都有些不同，本文将演示如何使用 Bash 和其他 POSIX shell 处理数据文件。

安装 Bash

如果你在使用 Linux，你可能已经有了 Bash。如果没有，你可以在你的软件仓库里找到它。

在 macOS 上，你可以使用默认终端，Bash 或 Zsh，这取决于你运行的 macOS 版本。

在 Windows 上，有几种方法可以体验 Bash，包括微软官方支持的 Windows Subsystem for Linux（WSL）。

安装 Bash 后，打开你最喜欢的文本编辑器并准备开始。

使用 Bash 读取文件

除了是 shell 之外，Bash 还是一种脚本语言。有几种方法可以从 Bash 中读取数据。你可以创建一种数据流并解析输出, 或者你可以将数据加载到内存中。这两种方法都是有效的获取信息的方法，但每种方法都有相当具体的用例。

在 Bash 中援引文件

当你在 Bash 中 “ 援引 source ” 一个文件时，你会让 Bash 读取文件的内容，期望它包含有效的数据，Bash 可以将这些数据放入它建立的数据模型中。你不会想要从旧文件中援引数据，但你可以使用这种方法来读取配置文件和函数。

（LCTT 译注：在 Bash 中，可以通过 source 或 . 命令来将一个文件读入，这个行为称为 “sourcing”，英文原意为“一次性（试）采购”、“寻找供应商”、“获得”等，考虑到 Bash 的语境和发音，我建议可以翻译为“援引”，或有不当，供大家讨论参考 —— wxy）

例如，创建一个名为 example.sh 的文件，并输入以下内容：

#!/bin/sh

greet opensource.com

echo "The meaning of life is $var"

运行这段代码，看见失败了：

$ bash ./example.sh
./example.sh: line 3: greet: command not found
The meaning of life is

Bash 没有一个叫 greet 的命令，所以无法执行那一行，也没有一个叫 var 的变量记录，所以文件没有意义。为了解决这个问题，建立一个名为 include.sh 的文件：

greet() {
    echo "Hello ${1}"
}

var=42

修改你的 example.sh 脚本，加入一个 source 命令：

#!/bin/sh

source include.sh

greet opensource.com

echo "The meaning of life is $var"

运行脚本，可以看到工作了：

$ bash ./example.sh
Hello opensource.com
The meaning of life is 42

greet 命令被带入你的 shell 环境，因为它被定义在 include.sh 文件中，它甚至可以识别参数（本例中的 opensource.com）。变量 var 也被设置和导入。

在 Bash 中解析文件

另一种让数据“进入” Bash 的方法是将其解析为数据流。有很多方法可以做到这一点. 你可以使用 grep 或 cat 或任何可以获取数据并管道输出到标准输出的命令。另外，你可以使用 Bash 内置的东西：重定向。重定向本身并不是很有用，所以在这个例子中，我也使用内置的 echo 命令来打印重定向的结果：

#!/bin/sh

echo $( < include.sh )

将其保存为 stream.sh 并运行它来查看结果：

$ bash ./stream.sh
greet() { echo "Hello ${1}" } var=42
$

对于 include.sh 文件中的每一行，Bash 都会将该行打印（或 echo）到你的终端。先用管道把它传送到一个合适的解析器是用 Bash 读取数据的常用方法。例如, 假设 include.sh 是一个配置文件, 它的键和值对用一个等号（=）分开. 你可以用 awk 甚至 cut 来获取值：

#!/bin/sh

myVar=`grep var include.sh | cut -d'=' -f2`

echo $myVar

试着运行这个脚本：

$ bash ./stream.sh
42

用 Bash 将数据写入文件

无论你是要存储用户用你的应用创建的数据，还是仅仅是关于用户在应用中做了什么的元数据（例如，游戏保存或最近播放的歌曲），都有很多很好的理由来存储数据供以后使用。在 Bash 中，你可以使用常见的 shell 重定向将数据保存到文件中。

例如, 要创建一个包含输出的新文件, 使用一个重定向符号：

#!/bin/sh

TZ=UTC
date > date.txt

运行脚本几次：

$ bash ./date.sh
$ cat date.txt
Tue Feb 23 22:25:06 UTC 2021
$ bash ./date.sh
$ cat date.txt
Tue Feb 23 22:25:12 UTC 2021

要追加数据，使用两个重定向符号：

#!/bin/sh

TZ=UTC
date >> date.txt

运行脚本几次：

$ bash ./date.sh
$ bash ./date.sh
$ bash ./date.sh
$ cat date.txt
Tue Feb 23 22:25:12 UTC 2021
Tue Feb 23 22:25:17 UTC 2021
Tue Feb 23 22:25:19 UTC 2021
Tue Feb 23 22:25:22 UTC 2021

Bash 轻松编程

Bash 的优势在于简单易学，因为只需要一些基本的概念，你就可以构建复杂的程序。完整的文档请参考 GNU.org 上的 优秀的 Bash 文档。

via: https://opensource.com/article/21/3/input-output-bash

作者：Seth Kenlon 选题：lujun9972 译者：geekpi 校对：wxy

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

来学习下搜索文件中内容的基本操作，然后下载我们的备忘录作为 grep 和正则表达式的快速参考指南。

grep（ 全局正则表达式打印 Global Regular Expression Print ）是由 Ken Thompson 早在 1974 年开发的基本 Unix 命令之一。在计算领域，它无处不在，通常被用作为动词（“搜索一个文件中的内容”）。如果你的谈话对象有极客精神，那么它也能在真实生活场景中使用。（例如，“我会 grep 我的内存条来回想起那些信息。”）简而言之，grep 是一种用特定的字符模式来搜索文件中内容的方式。如果你感觉这听起来像是文字处理器或文本编辑器的现代 Find 功能，那么你就已经在计算行业感受到了 grep 的影响。

grep 绝不是被现代技术抛弃的远古命令，它的强大体现在两个方面：

• grep 可以在终端操作数据流，因此你可以把它嵌入到复杂的处理中。你不仅可以在一个文本文件中查找文字，还可以提取文字后把它发给另一个命令。
• grep 使用正则表达式来提供灵活的搜索能力。

虽然需要一些练习，但学习 grep 命令还是很容易的。本文会介绍一些我认为 grep 最有用的功能。

• 下载我们免费的 grep 备忘录

安装 grep

Linux 默认安装了 grep。

MacOS 默认安装了 BSD 版的 grep。BSD 版的 grep 跟 GNU 版有一点不一样，因此如果你想完全参照本文，那么请使用 Homebrew 或 MacPorts 安装 GNU 版的 grep。

基础的 grep

所有版本的 grep 基础语法都一样。入参是匹配模式和你需要搜索的文件。它会把匹配到的每一行输出到你的终端。

$ grep gnu gpl-3.0.txt
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
<http://www.gnu.org/licenses/>.
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

grep 命令默认大小写敏感，因此 “gnu”、“GNU”、“Gnu” 是三个不同的值。你可以使用 --ignore-case 选项来忽略大小写。

$ grep --ignore-case gnu gpl-3.0.txt
                    GNU GENERAL PUBLIC LICENSE
  The GNU General Public License is a free, copyleft license for
the GNU General Public License is intended to guarantee your freedom to
GNU General Public License for most of our software; it applies also to
[...16 more results...]
<http://www.gnu.org/licenses/>.
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

你也可以通过 --invert-match 选项来输出所有没有匹配到的行：

$ grep --invert-match \
--ignore-case gnu gpl-3.0.txt
                      Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
[...648 lines...]
Public License instead of this License.  But first, please read

管道

能搜索文件中的文本内容是很有用的，但是 POSIX 的真正强大之处是可以通过“管道”来连接多条命令。我发现我使用 grep 最好的方式是把它与其他工具如 cut、tr 或 curl 联合使用。

假如现在有一个文件，文件中每一行是我想要下载的技术论文。我可以打开文件手动点击每一个链接，然后点击火狐浏览器的选项把每一个文件保存到我的硬盘，但是需要点击多次且耗费很长时间。而我还可以搜索文件中的链接，用 --only-matching 选项只打印出匹配到的字符串。

$ grep --only-matching http\:\/\/.*pdf example.html
http://example.com/linux_whitepaper.pdf
http://example.com/bsd_whitepaper.pdf
http://example.com/important_security_topic.pdf

输出是一系列的 URL，每行一个。而这与 Bash 处理数据的方式完美契合，因此我不再把 URL 打印到终端，而是把它们通过管道传给 curl：

$ grep --only-matching http\:\/\/.*pdf \
example.html | curl --remote-name

这条命令可以下载每一个文件，然后以各自的远程文件名命名保存在我的硬盘上。

这个例子中我的搜索模式可能很晦涩。那是因为它用的是正则表达式，一种在大量文本中进行模糊搜索时非常有用的”通配符“语言。

正则表达式

没有人会觉得 正则表达式 regular expression （简称 “regex”）很简单。然而，我发现它的名声往往比它应得的要差。诚然，很多人在使用正则表达式时“过于炫耀聪明”，直到它变得难以阅读，大而全，以至于复杂得换行才好理解，但是你不必过度使用正则。这里简单介绍一下我使用正则表达式的方式。

首先，创建一个名为 example.txt 的文件，输入以下内容：

Albania
Algeria
Canada
0
1
3
11

最基础的元素是不起眼的 . 字符。它表示一个字符。

$ grep Can.da example.txt
Canada

模式 Can.da 能成功匹配到 Canada 是因为 . 字符表示任意一个字符。

可以使用下面这些符号来使 . 通配符表示多个字符：

• ? 匹配前面的模式零次或一次
• * 匹配前面的模式零次或多次
• + 匹配前面的模式一次或多次
• {4} 匹配前面的模式 4 次（或是你在括号中写的其他次数）

了解了这些知识后，你可以用你认为有意思的所有模式来在 example.txt 中做练习。可能有些会成功，有些不会成功。重要的是你要去分析结果，这样你才会知道原因。

例如，下面的命令匹配不到任何国家：

$ grep A.a example.txt

因为 . 字符只能匹配一个字符，除非你增加匹配次数。使用 * 字符，告诉 grep 匹配一个字符零次或者必要的任意多次直到单词末尾。因为你知道你要处理的内容，因此在本例中零次是没有必要的。在这个列表中一定没有单个字母的国家。因此，你可以用 + 来匹配一个字符至少一次且任意多次直到单词末尾：

$ grep A.+a example.txt
Albania
Algeria

你可以使用方括号来提供一系列的字母：

$ grep [A,C].+a example.txt
Albania
Algeria
Canada

也可以用来匹配数字。结果可能会震惊你：

$ grep [1-9] example.txt
1
3
11

看到 11 出现在搜索数字 1 到 9 的结果中，你惊讶吗？

如果把 13 加到搜索列表中，会出现什么结果呢？

这些数字之所以会被匹配到，是因为它们包含 1，而 1 在要匹配的数字中。

你可以发现，正则表达式有时会令人费解，但是通过体验和练习，你可以熟练掌握它，用它来提高你搜索数据的能力。

下载备忘录

grep 命令还有很多文章中没有列出的选项。有用来更好地展示匹配结果、列出文件、列出匹配到的行号、通过打印匹配到的行周围的内容来显示上下文的选项，等等。如果你在学习 grep，或者你经常使用它并且通过查阅它的帮助页面来查看选项，那么你可以下载我们的备忘录。这个备忘录使用短选项（例如，使用 -v，而不是 --invert-matching）来帮助你更好地熟悉 grep。它还有一部分正则表达式可以帮你记住用途最广的正则表达式代码。 现在就下载 grep 备忘录！

via: https://opensource.com/article/21/3/grep-cheat-sheet

作者：Seth Kenlon 选题：lujun9972 译者：lxbwolf 校对：wxy

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

了解如何在 Bash 中编写定制程序以自动执行重复性操作任务。

Unix 最初的希望之一是，让计算机的日常用户能够微调其计算机，以适应其独特的工作风格。几十年来，人们对计算机定制的期望已经降低，许多用户认为他们的应用程序和网站的集合就是他们的 “定制环境”。原因之一是许多操作系统的组件未不开源，普通用户无法使用其源代码。

但是对于 Linux 用户而言，定制程序是可以实现的，因为整个系统都围绕着可通过终端使用的命令啦进行的。终端不仅是用于快速命令或深入排除故障的界面；也是一个脚本环境，可以通过为你处理日常任务来减少你的工作量。

如何学习编程

如果你以前从未进行过任何编程，可能面临考虑两个不同的挑战：一个是了解怎样编写代码，另一个是了解要编写什么代码。你可以学习 语法，但是如果你不知道 语言 中有哪些可用的关键字，你将无法继续。在实践中，要同时开始学习这两个概念，是因为如果没有关键字的堆砌就无法学习语法，因此，最初你要使用基本命令和基本编程结构来编写简单的任务。一旦熟悉了基础知识，就可以探索更多编程语言的内容，从而使你的程序能够做越来越重要的事情。

在 Bash 中，你使用的大多数 关键字 是 Linux 命令。 语法 就是 Bash。如果你已经频繁地使用过了 Bash，则向 Bash 编程的过渡相对容易。但是，如果你不曾使用过 Bash，你会很高兴地了解到它是一种为清晰和简单而构建的简单语言。

交互设计

有时，学习编程时最难搞清楚的事情就是计算机可以为你做些什么。显然，如果一台计算机可以自己完成你要做的所有操作，那么你就不必再碰计算机了。但是现实是，人类很重要。找到你的计算机可以帮助你的事情的关键是注意到你一周内需要重复执行的任务。计算机特别擅长于重复的任务。

但是，为了能告知计算机为你做某事，你必须知道怎么做。这就是 Bash 擅长的领域：交互式编程。在终端中执行一个动作时，你也在学习如何编写脚本。

例如，我曾经负责将大量 PDF 书籍转换为低墨和友好打印的版本。一种方法是在 PDF 编辑器中打开 PDF，从数百张图像（页面背景和纹理都算作图像）中选择每张图像，删除它们，然后将其保存到新的 PDF中。仅仅是一本书，这样就需要半天时间。

我的第一个想法是学习如何编写 PDF 编辑器脚本，但是经过数天的研究，我找不到可以编写编辑 PDF 应用程序的脚本（除了非常丑陋的鼠标自动化技巧）。因此，我将注意力转向了从终端内找出完成任务的方法。这让我有了几个新发现，包括 GhostScript，它是 PostScript 的开源版本（PDF 基于的打印机语言）。通过使用 GhostScript 处理了几天的任务，我确认这是解决我的问题的方法。

编写基本的脚本来运行命令，只不过是复制我用来从 PDF 中删除图像的命令和选项，并将其粘贴到文本文件中而已。将这个文件作为脚本运行，大概也会产生同样的结果。

向 Bash 脚本传参数

在终端中运行命令与在 Shell 脚本中运行命令之间的区别在于前者是交互式的。在终端中，你可以随时进行调整。例如，如果我刚刚处理 example_1.pdf 并准备处理下一个文档，以适应我的命令，则只需要更改文件名即可。

Shell 脚本不是交互式的。实际上，Shell 脚本 存在的唯一原因是让你不必亲自参与。这就是为什么命令（以及运行它们的 Shell 脚本）会接受参数的原因。

在 Shell 脚本中，有一些预定义的可以反映脚本启动方式的变量。初始变量是 $0，它代表了启动脚本的命令。下一个变量是 $1 ，它表示传递给 Shell 脚本的第一个 “参数”。例如，在命令 echo hello 中，命令 echo 为 $0,，关键字 hello 为 $1，而 world 是 $2。

在 Shell 中交互如下所示：

$ echo hello world
hello world

在非交互式 Shell 脚本中，你 可以 以非常直观的方式执行相同的操作。将此文本输入文本文件并将其另存为 hello.sh：

echo hello world

执行这个脚本：

$ bash hello.sh
hello world

同样可以，但是并没有利用脚本可以接受输入这一优势。将 hello.sh 更改为：

echo $1

用引号将两个参数组合在一起来运行脚本：

$ bash hello.sh "hello bash"
hello bash

对于我的 PDF 瘦身项目，我真的需要这种非交互性，因为每个 PDF 都花了几分钟来压缩。但是通过创建一个接受我的输入的脚本，我可以一次将几个 PDF 文件全部提交给脚本。该脚本按顺序处理了每个文件，这可能需要半小时或稍长一点时间，但是我可以用半小时来完成其他任务。

流程控制

创建 Bash 脚本是完全可以接受的，从本质上讲，这些脚本是你开始实现需要重复执行任务的准确过程的副本。但是，可以通过控制信息流的方式来使脚本更强大。管理脚本对数据响应的常用方法是：

• if/then 选择结构语句
• for 循环结构语句
• while 循环结构语句
• case 语句

计算机不是智能的，但是它们擅长比较和分析数据。如果你在脚本中构建一些数据分析，则脚本会变得更加智能。例如，基本的 hello.sh 脚本运行后不管有没有内容都会显示：

$ bash hello.sh foo
foo
$ bash hello.sh

$

如果在没有接收输入的情况下提供帮助消息，将会更加容易使用。如下是一个 if/then 语句，如果你以一种基本的方式使用 Bash，则你可能不知道 Bash 中存在这样的语句。但是编程的一部分是学习语言，通过一些研究，你将了解 if/then 语句：

if [ "$1" = "" ]; then
        echo "syntax: $0 WORD"
        echo "If you provide more than one word, enclose them in quotes."
else
        echo "$1"
fi

运行新版本的 hello.sh 输出如下：

$ bash hello.sh
syntax: hello.sh WORD
If you provide more than one word, enclose them in quotes.
$ bash hello.sh "hello world"
hello world

利用脚本工作

无论你是从 PDF 文件中查找要删除的图像，还是要管理混乱的下载文件夹，抑或要创建和提供 Kubernetes 镜像，学习编写 Bash 脚本都需要先使用 Bash，然后学习如何将这些脚本从仅仅是一个命令列表变成响应输入的东西。通常这是一个发现的过程：你一定会找到新的 Linux 命令来执行你从未想象过可以通过文本命令执行的任务，你会发现 Bash 的新功能，使你的脚本可以适应所有你希望它们运行的不同方式。

学习这些技巧的一种方法是阅读其他人的脚本。了解人们如何在其系统上自动化死板的命令。看看你熟悉的，并寻找那些陌生事物的更多信息。

另一种方法是下载我们的 Bash 编程入门 电子书。它向你介绍了特定于 Bash 的编程概念，并且通过学习的构造，你可以开始构建自己的命令。当然，它是免费的，并根据 创作共用许可证 进行下载和分发授权，所以今天就来获取它吧。

• 下载我们介绍用 Bash 编程的电子书！

via: https://opensource.com/article/20/4/bash-programming-guide

作者：Seth Kenlon 选题：lujun9972 译者：stevenzdg988 校对：wxy

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

使用 GNU 调试器来解决你的代码问题。

GNU 调试器常以它的命令 gdb 称呼它，它是一个交互式的控制台，可以帮助你浏览源代码、分析执行的内容，其本质上是对错误的应用程序中出现的问题进行逆向工程。

故障排除的麻烦在于它很复杂。GNU 调试器 并不是一个特别复杂的应用程序，但如果你不知道从哪里开始，甚至不知道何时和为何你可能需要求助于 GDB 来进行故障排除，那么它可能会让人不知所措。如果你一直使用 print、echo 或 printf 语句来调试你的代码，当你开始思考是不是还有更强大的东西时，那么本教程就是为你准备的。

有错误的代码

要开始使用 GDB，你需要一些代码。这里有一个用 C++ 写的示例应用程序（如果你一般不使用 C++ 编写程序也没关系，在所有语言中原理都是一样的），其来源于 猜谜游戏系列 中的一个例子。

#include <iostream>
#include <stdlib.h> //srand
#include <stdio.h>  //printf

using namespace std;

int main () {

srand (time(NULL));
int alpha = rand() % 8;
cout << "Hello world." << endl;
int beta = 2;

printf("alpha is set to is %s\n", alpha);
printf("kiwi is set to is %s\n", beta);

 return 0;
} // main

这个代码示例中有一个 bug，但它确实可以编译（至少在 GCC 5 的时候）。如果你熟悉 C++，你可能已经看到了，但这是一个简单的问题，可以帮助新的 GDB 用户了解调试过程。编译并运行它就可以看到错误：

$ g++ -o buggy example.cpp
$ ./buggy
Hello world.
Segmentation fault

排除段故障

从这个输出中，你可以推测变量 alpha 的设置是正确的，因为否则的话，你就不会看到它后面的那行代码执行。当然，这并不总是正确的，但这是一个很好的工作理论，如果你使用 printf 作为日志和调试器，基本上也会得出同样的结论。从这里，你可以假设 bug 在于成功打印的那一行之后的某行。然而，不清楚错误是在下一行还是在几行之后。

GNU 调试器是一个交互式的故障排除工具，所以你可以使用 gdb 命令来运行错误的代码。为了得到更好的结果，你应该从包含有调试符号的源代码中重新编译你的错误应用程序。首先，看看 GDB 在不重新编译的情况下能提供哪些信息：

$ gdb ./buggy
Reading symbols from ./buggy...done.
(gdb) start
Temporary breakpoint 1 at 0x400a44
Starting program: /home/seth/demo/buggy

Temporary breakpoint 1, 0x0000000000400a44 in main ()
(gdb)

当你以一个二进制可执行文件作为参数启动 GDB 时，GDB 会加载该应用程序，然后等待你的指令。因为这是你第一次在这个可执行文件上运行 GDB，所以尝试重复这个错误是有意义的，希望 GDB 能够提供进一步的见解。很直观，GDB 用来启动它所加载的应用程序的命令就是 start。默认情况下，GDB 内置了一个断点，所以当它遇到你的应用程序的 main 函数时，它会暂停执行。要让 GDB 继续执行，使用命令 continue：

(gdb) continue
Continuing.
Hello world.

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff71c0c0b in vfprintf () from /lib64/libc.so.6
(gdb)

毫不意外：应用程序在打印 “Hello world” 后不久就崩溃了，但 GDB 可以提供崩溃发生时正在发生的函数调用。这有可能就足够你找到导致崩溃的 bug，但为了更好地了解 GDB 的功能和一般的调试过程，想象一下，如果问题还没有变得清晰，你想更深入地挖掘这段代码发生了什么。

用调试符号编译代码

要充分利用 GDB，你需要将调试符号编译到你的可执行文件中。你可以用 GCC 中的 -g 选项来生成这个符号：

$ g++ -g -o debuggy example.cpp
$ ./debuggy
Hello world.
Segmentation fault

将调试符号编译到可执行文件中的结果是得到一个大得多的文件，所以通常不会分发它们，以增加便利性。然而，如果你正在调试开源代码，那么用调试符号重新编译测试是有意义的：

$ ls -l *buggy* *cpp
-rw-r--r--    310 Feb 19 08:30 debug.cpp
-rwxr-xr-x  11624 Feb 19 10:27 buggy*
-rwxr-xr-x  22952 Feb 19 10:53 debuggy*

用 GDB 调试

加载新的可执行文件（本例中为 debuggy）以启动 GDB：

$ gdb ./debuggy
Reading symbols from ./debuggy...done.
(gdb) start
Temporary breakpoint 1 at 0x400a44
Starting program: /home/seth/demo/debuggy

Temporary breakpoint 1, 0x0000000000400a44 in main ()
(gdb)

如前所述，使用 start 命令进行：

(gdb) start
Temporary breakpoint 1 at 0x400a48: file debug.cpp, line 9.
Starting program: /home/sek/demo/debuggy

Temporary breakpoint 1, main () at debug.cpp:9
9       srand (time(NULL));
(gdb)

这一次，自动的 main 断点可以指明 GDB 暂停的行号和该行包含的代码。你可以用 continue 恢复正常操作，但你已经知道应用程序在完成之前就会崩溃，因此，你可以使用 next 关键字逐行步进检查你的代码：

(gdb) next
10  int alpha = rand() % 8;
(gdb) next
11  cout << "Hello world." << endl;
(gdb) next
Hello world.
12  int beta = 2;
(gdb) next
14      printf("alpha is set to is %s\n", alpha);
(gdb) next

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff71c0c0b in vfprintf () from /lib64/libc.so.6
(gdb)

从这个过程可以确认，崩溃不是发生在设置 beta 变量的时候，而是执行 printf 行的时候。这个 bug 在本文中已经暴露了好几次（破坏者：向 printf 提供了错误的数据类型），但暂时假设解决方案仍然不明确，需要进一步调查。

设置断点

一旦你的代码被加载到 GDB 中，你就可以向 GDB 询问到目前为止代码所产生的数据。要尝试数据自省，通过再次发出 start 命令来重新启动你的应用程序，然后进行到第 11 行。一个快速到达 11 行的简单方法是设置一个寻找特定行号的断点：

(gdb) start
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Temporary breakpoint 2 at 0x400a48: file debug.cpp, line 9.
Starting program: /home/sek/demo/debuggy

Temporary breakpoint 2, main () at debug.cpp:9
9       srand (time(NULL));
(gdb) break 11
Breakpoint 3 at 0x400a74: file debug.cpp, line 11.

建立断点后，用 continue 继续执行：

(gdb) continue
Continuing.

Breakpoint 3, main () at debug.cpp:11
11      cout << "Hello world." << endl;
(gdb)

现在暂停在第 11 行，就在 alpha 变量被设置之后，以及 beta 被设置之前。

用 GDB 进行变量自省

要查看一个变量的值，使用 print 命令。在这个示例代码中，alpha 的值是随机的，所以你的实际结果可能与我的不同：

(gdb) print alpha
$1 = 3
(gdb)

当然，你无法看到一个尚未建立的变量的值：

(gdb) print beta
$2 = 0

使用流程控制

要继续进行，你可以步进代码行来到达将 beta 设置为一个值的位置：

(gdb) next
Hello world.
12  int beta = 2;
(gdb) next
14  printf("alpha is set to is %s\n", alpha);
(gdb) print beta
$3 = 2

另外，你也可以设置一个观察点，它就像断点一样，是一种控制 GDB 执行代码流程的方法。在这种情况下，你知道 beta 变量应该设置为 2，所以你可以设置一个观察点，当 beta 的值发生变化时提醒你：

(gdb) watch beta > 0
Hardware watchpoint 5: beta > 0
(gdb) continue
Continuing.

Breakpoint 3, main () at debug.cpp:11
11      cout << "Hello world." << endl;
(gdb) continue
Continuing.
Hello world.

Hardware watchpoint 5: beta > 0

Old value = false
New value = true
main () at debug.cpp:14
14      printf("alpha is set to is %s\n", alpha);
(gdb)

你可以用 next 手动步进完成代码的执行，或者你可以用断点、观察点和捕捉点来控制代码的执行。

用 GDB 分析数据

你可以以不同格式查看数据。例如，以八进制值查看 beta 的值：

(gdb) print /o beta
$4 = 02

要查看其在内存中的地址：

(gdb) print /o &beta
$5 = 0x2

你也可以看到一个变量的数据类型：

(gdb) whatis beta
type = int

用 GDB 解决错误

这种自省不仅能让你更好地了解什么代码正在执行，还能让你了解它是如何执行的。在这个例子中，对变量运行的 whatis 命令给了你一个线索，即你的 alpha 和 beta 变量是整数，这可能会唤起你对 printf 语法的记忆，使你意识到在你的 printf 语句中，你必须使用 %d 来代替 %s。做了这个改变，就可以让应用程序按预期运行，没有更明显的错误存在。

当代码编译后发现有 bug 存在时，特别令人沮丧，但最棘手的 bug 就是这样，如果它们很容易被发现，那它们就不是 bug 了。使用 GDB 是猎取并消除它们的一种方法。

下载我们的速查表

生活的真相就是这样，即使是最基本的编程，代码也会有 bug。并不是所有的错误都会导致应用程序无法运行（甚至无法编译），也不是所有的错误都是由错误的代码引起的。有时，bug 是基于一个特别有创意的用户所做的意外的选择组合而间歇性发生的。有时，程序员从他们自己的代码中使用的库中继承了 bug。无论原因是什么，bug 基本上无处不在，程序员的工作就是发现并消除它们。

GNU 调试器是一个寻找 bug 的有用工具。你可以用它做的事情比我在本文中演示的要多得多。你可以通过 GNU Info 阅读器来了解它的许多功能：

$ info gdb

无论你是刚开始学习 GDB 还是专业人员的，提醒一下你有哪些命令是可用的，以及这些命令的语法是什么，都是很有帮助的。

• 下载 GDB 速查表

via: https://opensource.com/article/21/3/debug-code-gdb

作者：Seth Kenlon 选题：lujun9972 译者：wxy 校对：wxy

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