如何在Linux中将补丁应用到文件（和创建补丁）

￡神魔★判官ぃ 2021-07-27 02:04 401阅读 0赞

![PC showing a shell prompt on a Linux desktop][][Fatmawati Achmad Zaenuri/Shutterstock.com][Fatmawati Achmad Zaenuri_Shutterstock.com] [Fatmawati Achmad Zaenuri / Shutterstock.com][Fatmawati Achmad Zaenuri_Shutterstock.com]

The Linux `patch` command lets you transfer the changes from one set of files to another set of files quickly and safely. Learn how to use `patch` the simple way.

Linux `patch`命令可让您快速安全地将更改从一组文件转移到另一组文件。 了解如何使用`patch`的简单方法。

## patch和diff命令 **(**The patch and diff Commands**)** ##

Imagine you have a text file on your computer. You receive a modified version of that text file from someone else. How do you quickly transfer all of the changes from the modified file to your original file? That’s where `patch` and `diff` come into play. `patch` and `diff` are found in Linux and other [Unix-Like operating systems][], such as macOS.

假设您的计算机上有一个文本文件。 您会从其他人那里收到该文本文件的修改版本。 您如何快速将所有更改从修改后的文件转移到原始文件？ 那就是`patch`和`diff`发挥作用的地方。 在Linux和其他[类似Unix的操作系统][Unix-Like operating systems] (例如macOS)中可以找到`patch`和`diff` 。

The `diff` command examines [two different versions of a file][] and lists the differences between them. The differences can be stored in a file called a patch file.

`diff`命令检查[文件的两个不同版本][two different versions of a file]并列出它们之间的差异。 差异可以存储在称为补丁文件的文件中。

The `patch` command can read a patch file and use the contents as a set of instructions. By following those instructions, the changes in the modified file are [replicated in the original][] file.

`patch`命令可以读取补丁文件，并将其内容用作一组指令。 按照这些说明，将修改后的文件中的更改[复制到原始][replicated in the original]文件中。

Now imagine that process happening to an entire directory of text files. All in one go. That’s the power of `patch`.

现在，假设该过程发生在整个文本文件目录中。 一口气。 这就是`patch`的力量。

Sometimes you don’t get sent the modified files. All you get sent is the patch file. Why send dozens of files round when you can send one file, or post one file for easy download?

有时您不会收到修改后的文件。 您发送的只是补丁文件。 当您可以发送一个文件或发布一个文件以便于下载时，为什么还要发送几十个文件呢？

What do you do with the patch file to actually patch your files? Apart from almost being a tongue-twister, that’s also a good question. We’ll walk you through it in this article.

您如何使用补丁文件来实际补丁文件？ 除了几乎是个绕口令，这也是一个好问题。 在本文中，我们将逐步引导您。

The `patch` command is most often used by people working with software source code files, but it works equally well with any set of text files whatever their purpose, source code or not.

`patch`命令最常用于处理软件源代码文件的人员，但它与任何文本文件集(无论其用途是什么)(源代码或不源代码)都同样有效。

## 我们的示例场景 **(**Our Example Scenario**)** ##

In this scenario, we are in a directory called work which contains two other directories. One is called *working,* and the other one is called *latest*. The working directory holds a set of source code files. The latest directory holds the most recent version of those source code files, some of which have been modified.

在这种情况下，我们位于一个名为work的目录中，该目录包含另外两个目录。 一种称为*工作，*另一种称为*最新* 。 工作目录包含一组源代码文件。 最新目录包含这些源代码文件的最新版本，其中一些已被修改。

To be safe, the working directory is a copy of the current version of the text files. It isn’t the only copy of them.

为了安全起见，工作目录是文本文件当前版本的副本。 它不是它们的唯一副本。

## 查找文件的两个版本之间的差异 **(**Finding the Differences Between Two Versions of a File**)** ##

The `diff` command finds the differences between two files. Its default action is to list the modified lines in the terminal window.

`diff`命令查找两个文件之间的差异。 它的默认操作是在终端窗口中列出修改后的行。

One file is called `slang.c`. We’ll compare the version in the working directory to the one in the latest directory.

一个文件称为`slang.c` 。 我们将工作目录中的版本与最新目录中的版本进行比较。

The `-u` (unified) option tells `diff` to also list some of the un-modified text lines from before and after each of the changed sections. These lines are called context lines. They help the `patch` command locate precisely where a change must be made in the original file.

`-u` (统一)选项告诉`diff`还列出每个已更改部分之前和之后的一些未修改的文本行。 这些行称为上下文行。 它们帮助`patch`命令精确定位必须在原始文件中进行更改的位置。

We provide the names of the files so that `diff` knows which files to compare. The original file is listed first, then the modified file. This is the command we issue to `diff`:

我们提供文件名，以便`diff`知道要比较的文件。 首先列出原始文件，然后列出修改后的文件。 这是我们发出给`diff`的命令：

diff -u working/slang.c latest/slang.c

![diff -u working/slang.s latest/slang.c in a terminal window][diff -u working_slang.s latest_slang.c in a terminal window]

`diff` produces an output listing showing the differences between the files. If the files were identical, there would be no output listed at all. Seeing this type of output from `diff` confirms that there are differences between the two file versions and that the original file needs patching.

`diff`产生一个输出列表，显示文件之间的差异。 如果文件相同，则根本不会列出任何输出。 从`diff`看到这种类型的输出，确认两个文件版本之间存在差异，并且原始文件需要打补丁。

![output from diff in a terminal window][]

## 制作补丁文件 **(**Making a Patch FIle**)** ##

To capture those differences in a patch file, use the following command. It’s the same command as above, with the output from `diff` redirected into a file called slang.patch.

要捕获补丁文件中的这些差异，请使用以下命令。 与上面的命令相同， `diff`的输出重定向到名为slang.patch的文件中。

diff -u working/slang.c latest/slang.c > slang.patch

![diff -u working/slang.c latest/slang.c > slang.patch in a terminal window][diff -u working_slang.c latest_slang.c _ slang.patch in a terminal window]

The name of the patch file is arbitrary. You can call it anything you like. Giving it a “.patch” extension is a good idea; however, as it does make it clear what type of file it is.

补丁文件的名称是任意的。 您可以随便叫它。 给它一个“ .patch”扩展名是一个好主意。 但是，因为它确实清楚了文件的类型。

To make `patch` act upon the patch file and modify the working/slang.c file, use the following command. The `-u` (unified) option lets `patch` know that the patch file contains unified context lines. In other words, we used the -u option with diff, so we use the `-u` option with `patch`.

要使`patch`作用于补丁程序文件并修改working / slang.c文件，请使用以下命令。 `-u` (统一)选项使`patch`知道修补程序文件包含统一的上下文行。 换句话说，我们将-u选项与diff一起使用，因此将`-u`选项与`patch` 。

patch -u working.slang.c -i slang.patch

补丁-u working.slang.c -i slang.patch

![patch -u working.slang.c -i slang.patch in a terminal window][]

If all goes well, there’s a single line of output telling you `patch` is patching the file.

如果一切顺利，则只有一行输出告诉您`patch`正在修补文件。

## 备份原始文件 **(**Making a Backup of the Original FIle**)** ##

We can instruct `patch` to make a backup copy of patched files before they are changed by using the `-b` (backup) option. The `-i` (input) option tells patch the name of the patch file to use:

通过使用`-b` (备份)选项，我们可以指示`patch`在修补文件更改之前对其进行备份。 `-i` (输入)选项告诉修补程序要使用的修补程序文件的名称：

patch -u -b working.slang.c -i slang.patch

![patch -u working.slang.c -i slang.patch in a terminal window][patch -u working.slang.c -i slang.patch in a terminal window 1]

The file is patched as before, with no visible difference in the output. However, if you look into the working folder, you’ll see that file called slang.c.orig has been created. The date and time stamps of the files show that slang.c.orig is the original file and slang.c is a new file created by `patch`.

该文件像以前一样打过补丁，输出没有明显差异。 但是，如果查看工作文件夹，则会看到名为slang.c.orig的文件已创建。 文件的日期和时间戳显示slang.c.orig是原始文件，而slang.c是`patch`创建的新文件。

![output of ls in a terminal window][]

## 对目录使用diff **(**Using diff With Directories**)** ##

We can use `diff` to create a patch file that contains all of the differences between the files in two directories. We can then use that patch file with `patch` to have those differences applied to the files in the working folder with a single command.

我们可以使用`diff`创建一个补丁文件，其中包含两个目录中文件之间的所有差异。 然后，我们可以将该补丁文件与`patch`一起使用，以通过单个命令将那些差异应用于工作文件夹中的文件。

The options we’re going to use with `diff` are the `-u` (unified context) option we have used earlier, the `-r` (recursive) option to make `diff` look into any sub-directories and the `-N` (new file) option.

我们将与`diff`一起使用的选项是我们先前使用的`-u` (统一上下文)选项，使`-r` (递归)选项使`diff`查看任何子目录的选项，以及`-N` (新文件)选项。

The `-N` option tells `diff` how to handle files in the latest directory that are not in the working directory. It forces `diff` to put instructions in the patch file so that`patch` creates files that are present in the latest directory but missing from the working directory.

`-N`选项告诉`diff`如何处理最新目录中不在工作目录中的文件。 它强制`diff`将指令放入修补程序文件中，以便`patch`创建最新目录中存在但工作目录中缺少的文件。

You can bunch the options together so that they use a single hyphen (`-`).

您可以将选项捆绑在一起，以便它们使用单个连字符( `-` )。

Note that we’re only providing the directory names, we’re not telling `diff` to look at specific files:

请注意，我们仅提供目录名称，而不是告诉`diff`查看特定文件：

diff -ruN working/ latest/ > slang.patch

![diff -ruN working/ latest/ > slang.patch][diff -ruN working_ latest_ _ slang.patch]

## 在修补程序文件中偷看 **(**Peeking Inside the Patch File**)** ##

Let’s have a quick look into the patch file. We’ll use `less` to look at its contents.

让我们快速浏览一下补丁文件。 我们将`less`使用它来查看其内容。

![less slang.patch in a terminal window][]

The top of the file shows the differences between the two versions of slang.c.

文件顶部显示slang.c的两个版本之间的差异。

![less slang.patch showing top of ile in a terminal window][]

Scrolling further down through the patch file, we see that it then describes the changes in another file called structs.h. This verifies that the patch file definitely contains the differences between different versions of multiple files.

向下滚动浏览补丁文件，我们看到它随后描述了另一个文件structs.h中的更改。 这可以验证补丁文件是否确实包含多个文件的不同版本之间的差异。

![less slang.patch showing the middle of the file in a terminal window][]

## 三思而后行 **(**Look Before You Leap**)** ##

Patching a large collection of files can be a little unnerving, so we’re going to use the `--dry-run` option to check everything is fine before we take the plunge and commit ourselves to making the changes.

修补大量文件可能会有些令人不安，因此我们将使用`--dry-run`选项检查一切是否正常，然后再尝试并做出更改。

The `--dry-run` option tells `patch` to do everything apart from actually modifying the files. `patch` will perform all of its pre-flight checks on the files and if it encounters any problems, it reports them. Either way, no files are modified.

`--dry-run`选项告诉`patch`执行除实际修改文件之外的所有操作。 `patch`将对文件执行所有的飞行前检查，如果遇到任何问题，它将报告它们。 无论哪种方式，都不会修改文件。

If no problems are reported, we can repeat the command without the `--dry-run` option and confidently patch our files.

如果未报告任何问题，我们可以不带`--dry-run`选项而重复执行该命令，并放心地修补文件。

The `-d` (directory) option tell `patch` which directory to work on.

`-d` (目录)选项告诉`patch`要在哪个目录上工作。

Note that we’re *not* using the `-i` (input) option to tell `patch` which patch file contains the instructions from `diff`. Instead, we’re redirecting the patch file into `patch` with `<`.

请注意，我们*没有*使用`-i` (输入)选项来告诉`patch`哪个补丁文件包含`diff`的指令。 相反，我们将补丁文件重定向到带有`<`的补丁`patch` 。

patch --dry-run -ruN -d working < slang.patch

![patch --dry-run -ruN -d working < slang.patch in a terminal window][patch --dry-run -ruN -d working _ slang.patch in a terminal window]

Out of the entire directory, `diff` found two files to patch. The instructions regarding the modifications for those two files have been checked by `patch` , and no problems have been reported.

在整个目录中， `diff`找到了两个要修补的文件。 `patch`已检查有关对这两个文件进行修改的说明，并且未报告任何问题。

Pre-flight checks are OK; we’re ready for take-off.

飞行前检查还可以； 我们准备起飞。

## 修补目录 **(**Patching a Directory**)** ##

To genuinely apply the patches to the files we use the previous command without the `--dry-run` option.

为了将补丁真正地应用到文件，我们使用了不带`--dry-run`选项的上一个命令。

patch -ruN -d working < slang.patch

![patch -ruN -d working < slang.patch in a terminal window][patch -ruN -d working _ slang.patch in a terminal window]

This time each line of output doesn’t start with “checking,” each line starts with “patching.”

这次输出的每一行都不以“检查”开头，而是每一行以“ patching”开头。

And no problems are reported. We can compile our source code, and we’ll be on the latest version of the software.

并且没有问题的报告。 我们可以编译我们的源代码，并且将使用该软件的最新版本。

## 解决分歧 **(**Settle Your Differences**)** ##

This is by far the easiest and safest way to use `patch`. Copy your target files to a folder and patch that folder. Copy them back when you’re happy that the patching process completed error free.

到目前为止，这是使用`patch`的最简单，最安全的方法。 将目标文件复制到一个文件夹并对该文件夹进行修补。 当您对修补过程完成无错误感到满意时，将它们复制回去。

> 翻译自: [https://www.howtogeek.com/415442/how-to-apply-a-patch-to-a-file-and-create-patches-in-linux/][https_www.howtogeek.com_415442_how-to-apply-a-patch-to-a-file-and-create-patches-in-linux]

[PC showing a shell prompt on a Linux desktop]: /images/20210726/814b13db93fd450fbc4258a73bc9dc95.png
[Fatmawati Achmad Zaenuri_Shutterstock.com]: https://www.shutterstock.com/image-vector/linux-interface-screen-notebook-world-map-321627716
[Unix-Like operating systems]: https://www.howtogeek.com/182649/htg-explains-what-is-unix/
[two different versions of a file]: http://man7.org/linux/man-pages/man1/diff.1.html
[replicated in the original]: http://man7.org/linux/man-pages/man1/patch.1.html
[diff -u working_slang.s latest_slang.c in a terminal window]: /images/20210726/6f5580fcb00d41a0b665f7fe495126b6.png
[output from diff in a terminal window]: /images/20210726/8f812af14e624b7a8c5f564adeac6366.png
[diff -u working_slang.c latest_slang.c _ slang.patch in a terminal window]: /images/20210726/d322e6d3fd654432b9fdfd6c5b676736.png
[patch -u working.slang.c -i slang.patch in a terminal window]: /images/20210726/1aa02a26926e41498a5188b08480eb8f.png
[patch -u working.slang.c -i slang.patch in a terminal window 1]: /images/20210726/524c341a98634b9a88e3e74d93065e80.png
[output of ls in a terminal window]: /images/20210726/e0e2443c62624cdaa9d6400a448c53d9.png
[diff -ruN working_ latest_ _ slang.patch]: /images/20210726/aaf22d650abc4dbe9f9ddcfdf2a2b1fe.png
[less slang.patch in a terminal window]: /images/20210726/1bc6253a87514850ae42faddbcb6abf9.png
[less slang.patch showing top of ile in a terminal window]: /images/20210726/aa5227031f3549bfb46c02b56f08c618.png
[less slang.patch showing the middle of the file in a terminal window]: /images/20210726/75ad986a944f451390240632c77b36f0.png
[patch --dry-run -ruN -d working _ slang.patch in a terminal window]: /images/20210726/b05ca241c1894139aa065602f668d4b2.png
[patch -ruN -d working _ slang.patch in a terminal window]: /images/20210726/f8e0a33a90114050a95e2ff19943cd01.png
[https_www.howtogeek.com_415442_how-to-apply-a-patch-to-a-file-and-create-patches-in-linux]: https://www.howtogeek.com/415442/how-to-apply-a-patch-to-a-file-and-create-patches-in-linux/