Patch with diff in linux

How to Run “patch” Command in Linux?

The “patch” is a command for adding patch files to source code or text files. It takes input as a patch file and applies differences to original files. We use the “diff” tool to get the difference.

The “diff” is abbreviated as “differences” and is used to compare the content of two files and list the changes in standard output.

A set of source codes makes up a piece of software. Developers build the source code that evolves over time. Getting a new file for each update is unrealistic or time-consuming. Therefore, the safest method is to distribute improvements only. The modifications are made to the old file, and then a new or patched file is created for the new software version.

This guide shows you how to use the “diff” command to generate a patch file and then apply it with the “patch” command.

Syntax:

The syntax of the “patch” command is as follows:

$ patch [ options ] [ originalfile [ patchfile ] ]

Creating a Patch File Using “diff”:

Source Code File 1:

Firstly, two different versions of a source code are required to create a patch file. The source code file I have created is named as “myfile.c”:s

Source Code File 2:

Now, copy the content of myfile.c in the new_myfile.c, using:

Make some changes in the newly-created file:

Checking Difference:

Let’s create a patch file named as myfile.patch:

You can print the patch file by executing the command below:

Applying the Patch File:

Ensure that the patch file is in the directory where the source code file is placed.

Take a Backup Before Applying Patch:

Use “-b” option to build a backup of the patch file:

Setting Backup File Version

If you need multiple backups of a single backup file, then use the “-V” option. It sets the version number of each backup file. Execute the command given below:

Validate Patch Files

If you want to verify or observe the outcome of patching, then use “–dry-run” option. It does not make any modification to the original file:

Reverse/Undo a Patch

The “-R” option is used to reverse or undo a patch that has already been applied.

Conclusion:

In Linux operating system, “patch” is a command that allows us to apply patch files to the source codes or configuration files. The patch file is used for software updating purposes. The difference between the original and new files is held in patch files and the “diff” command is used to get the difference or patch. We discussed the usage of the “diff” and the “patch” commands with a number of options such as making backups, dry-running, and reversing the applied patch.

About the author

Aqsa Maqbool

As a Software engineer, I am passionate to write about various IT related
articles but have deep interest in Linux. I spend most of my time reading Linux related blogs and IT related books. I want to serve the world with my writing skills.

Источник

Merge changes with git diff and patch

Collaborate on file changes, with no Git hosting service necessary, using the Linux git diff and patch commands.

Sysadmins modify lots of files. Sometimes they’re code. Other times they’re configuration files, YAML playbooks, XML, policy documents, kickstart files, and probably a few takeaway lunch orders, too. It’s important to track what you’ve changed and share your changes with others who may need to adjust their local copies of files.

Great Linux resources

To make this process seamless, many online Git repository providers have adopted the «merge request» or «pull request» model, in which they expect contributors to clone (often called «fork,» even though the intent is actually not to fork the project) the entire repository and then submit a request through the online platform to integrate the changed branch back into the original repo. But what do you do when you’re not using a Git platform-as-a-service (PaaS) provider or when you want a streamlined process for submitting changes?

You use diff and patch . These are the tools everyone used before online Git hosts moved the process into the browser, and they’re just as valid today as ever. With the git diff command, you can create a record of how the file has changed, and the owner of a repository can use the patch command to «replay» those changes over the old version to bring it up to date with the new version.

Set up an example file

Suppose you and I are collaborating on a project to calculate prime numbers. I’ll use an example written in Lua because it’s easy to read. You don’t actually need to know Lua for this example to be relevant. So far, the file prime.lua contains:

function prime(num) if num%2 == 0 then return false end return true end

It’s valid code, it works as expected, but it’s incomplete. So you send the file to me, and I save it as prime_revision.lua and make some changes to it. I change some of your existing code, and I add some of my own:

function prime(num) if num= 0 ) do if prime(num) then print(num .. " is prime") end num=num+1 end

With a small file such as this, it’s relatively trivial to see what’s changed. The if statement was updated, and a bunch of code was added at the end. However, with larger files, updating the original file to match the new one would be difficult and prone to mistakes. The git diff and patch commands solve this problem.

Create a patch with git diff

When you change a committed file in Git, you can see the changes you’ve made using git diff :

$ git diff prime.lua diff --git a/prime.lua b/prime.lua index b4c3d7c..6dea598 100644 --- a/prime.lua +++ b/prime.lua @@ -1,6 +1,15 @@ function prime(num) - if num%2 == 0 then + if num= 0 ) do + if prime(num) then + print(num .. " is prime") + end + num=num+1 +end

This is the same view as the one provided by the diff command using the —unified option, and it’s also the correct syntax to use with the patch command. A plus sign ( + ) at the beginning of a line indicates something added to the old file. A minus sign ( — ) at the beginning of a line indicates a line that was removed or changed.

Create a patch file with git diff

The git diff command output is a valid patch file, in addition to being informative to the Git repo owner. You can do this using standard Bash redirection:

$ git diff prime.lua > prime.patch

The contents of the file are exactly the same as what was output to the terminal.

[ Download the free Bash shell scripting cheat sheet to keep the basics close at hand. ]

Create a patch with diff

Once I have a patch file containing all of my changes, I can send it to you to review and, optionally, apply to your old file. You apply a patch with the patch command:

$ patch prime.lua prime.patch

Lines were added, lines were subtracted, and in the end, you end up with a file identical to my version:

$ cat prime.lua function prime(num) if num= 0 ) do if prime(num) then print(num .. " is prime") end num=num+1 end

Источник

Команда diff в Linux: сравниваем два файла

Представьте, что однажды утром вы просыпаетесь и обнаруживаете, чтоб ваши продакшен-системы «лежат» из-за бага, который только предстоит найти. Один из наихудших кошмаров, верно?

Также оказывается, что для восстановления системы вам нужно сравнить код в двух версиях. Давление растет, все вокруг паникуют (и это понятно).

К счастью, в Linux есть утилита под названием diff, которая вам поможет.

Что из себя представляет команда diff в Linux?

Сравнение файлов и поиск различий между ними — широко распространенная операция. Она особенно полезна, когда нужно сравнить сложный код или конфигурационные файлы.

Сравнивать вручную долго и тяжело, к тому же велика вероятность ошибок. Поэтому Linux предоставляет вам мощную встроенную утилиту под названием diff. Ее применение позволяет сэкономить время и силы.

В Linux также есть еще одна команда, которая отлично дополняет diff, — patch. Она позволяет применить изменения из одного файла в другом. В этой статье мы рассмотрим обе команды и их применение на практике.

Синтаксис команды diff

Команда diff имеет следующий синтаксис:

Команда diff сравнивает два файла построчно. При этом первый из файлов она считает нуждающимся в редактировании и приведении к виду второго файла. Второй файл для diff — образец для сравнения.

Поэтому в выводе команды даются указания, что и как нужно изменить, чтобы первый файл стал таким же, как второй.

Указания даются при помощи специальных символов:

• c — CHANGE — изменение, которое нужно внести в указанной строке первого файла
• d — DELETE — то, что нужно удалить в первом файле
• a — ADD — то, что нужно добавить в первый файл

Давайте рассмотрим несколько примеров использования команды diff.

Примеры использования команды diff

Чтобы выяснить, являются ли файлы одинаковыми, команда diff дополняется флагом -s . В нашем примере содержимое файлов fileA и sameAsfileA совпадает.

А в следующем примере файлы имеют разный контент. Вывод команды diff говорит, что строки 11 и 14 в showList_v2.js нужно изменить, чтобы они совпадали со строками 11 и 13 в showList_v1.js.

Далее мы рассмотрим мой любимый способ использования команды diff — параллельный просмотр изменений. Для этого нужно применить флаг -y:

И последний пример — с объединенным выводом. Такой output часто используется как input для команды patch (ее мы тоже рассмотрим):

Вот еще несколько полезных флагов, которые можно применять с командой diff:

• -i — для игнорирования регистра. По умолчанию команда diff учитывает регистр.
• -w — для игнорирования пробелов в файле. По умолчанию пробелы тоже учитываются и могут считаться различием.

Синтаксис команды patch

Изменения в коде происходят постоянно. Расшаривать отредактированные файлы после внесения каждого изменения нереально. Обычно разработчики расшаривают сами изменения в коде.

Использование патчей («заплаток») — самый безопасный способ делиться только лишь изменениями.

Давайте посмотрим, как работают патчи:

Примеры использования команды patch

Предположим, у нас есть простой JavaScript-код в файле print_in_js.js, который выводит строку.

Но в функции вывода что-то сломалось, и нам нужно внести исправления. Мы отсылаем файл print_in_js.js коллеге, который может исправить код.

Наш коллега находит опечатку в строке № 3 и исправляет файл.

Когда файл исправлен и код работает корректно, наш коллега создает патч:

diff -u print_in_js.js print_in_js_Fixed.js > patched_print_js.diff

Давайте посмотрим содержимое патча:

Получив патч, мы применяем его:

И — вуаля! — наш код исправлен!

Итоги

Создавать и применять патчи при помощи команд patch и diff довольно просто.

Похожий подход применяется, когда вы пользуетесь системами контроля версий вроде Git или SVN. Знание основ (т. е. работы соответствующих команд Linux) поможет вам лучше понять работу систем контроля версий, а это важно для разработчиков.

Источник