Детали

Git имеет репутацию запутывающего инструмента. Пользователи натыкаются на терминологию и формулировки, которые вводят в заблуждение. Это более всего проявляется в "перезаписывающих" историю командах, таких как git cherry-pick или git rebase. По моему опыту, первопричина путаницы интерпретация коммитов как различий, которые можно перетасовать. Однако коммиты это не различия, а снимки! Я считаю, что Git станет понятным, если поднять занавес и посмотреть, как он хранит данные репозитория. Изучив модель хранения данных мы посмотрим, как новый взгляд помогает понять команды, такие как git cherry-pick и git rebase.

Если хочется углубиться по-настоящему, читайте главу о внутренней работе Git (Git internals) книги Pro Git. Я буду работать с репозиторием git/git версии v2.29.2. Просто повторяйте команды за мной, чтобы немного попрактиковаться.

Хеши идентификаторы объектов

Самое важное, что нужно знать о Git-объектах, это то, что Git ссылается на каждый из них по идентификатору объекта (OID для краткости), даёт объекту уникальное имя.

Чтобы найти OID, воспользуемся командой git rev-parse. Каждый объект, по сути, простой текстовый файл, его содержимое можно проверить командой git cat-file -p.

Мы привыкли к тому, что OID даны в виде укороченной шестнадцатеричной строки. Строка рассчитана так, чтобы только один объект в репозитории имел совпадающий с ней OID. Если запросить объект слишком коротким OID, мы увидим список соответствующих подстроке OID.

$ git cat-file -t e0c03error: short SHA1 e0c03 is ambiguoushint: The candidates are:hint: e0c03f27484 commit 2016-10-26 - contrib/buildsystems: ignore irrelevant files in Generators/hint: e0c03653e72 treehint: e0c03c3eecc blobfatal: Not a valid object name e0c03

Блобы это содержимое файлов

На нижнем уровне объектной модели блобы содержимое файла. Чтобы обнаружить OID файла текущей ревизии, запустите git rev-parse HEAD:<path>, а затем, чтобы вывести содержимое файла git cat-file -p <oid>.

$ git rev-parse HEAD:README.mdeb8115e6b04814f0c37146bbe3dbc35f3e8992e0$ git cat-file -p eb8115e6b04814f0c37146bbe3dbc35f3e8992e0 | head -n 8[![Build status](http://personeltest.ru/aways/github.com/git/git/workflows/CI/PR/badge.png)](http://personeltest.ru/aways/github.com/git/git/actions?query=branch%3Amaster+event%3Apush)Git - fast, scalable, distributed revision control system=========================================================Git is a fast, scalable, distributed revision control system with anunusually rich command set that provides both high-level operationsand full access to internals.

Если я отредактирую файл README.md на моём диске, то git status предупредит, что файл недавно изменился, и хэширует его содержимое. Когда содержимое файла не совпадает с текущим OID в HEAD:README.md, git status сообщает о файле как о "модифицированном на диске". Таким образом видно, совпадает ли содержимое файла в текущей рабочей директории с ожидаемым содержимым в HEAD.

Деревья это списки каталогов

Обратите внимание, что блобы хранят содержание файла, но не его имя. Имена берутся из представления каталогов Git деревьев. Дерево это упорядоченный список путей в паре с типами объектов, режимами файлов и OID для объекта по этому пути. Подкаталоги также представлены в виде деревьев, поэтому деревья могут указывать на другие деревья!

Воспользуемся диаграммами, чтобы визуализировать связи объектов между собой. Красные квадраты наши блобы, а треугольники деревья.

$ git rev-parse HEAD^{tree}75130889f941eceb57c6ceb95c6f28dfc83b609c$ git cat-file -p 75130889f941eceb57c6ceb95c6f28dfc83b609c  | head -n 15100644 blob c2f5fe385af1bbc161f6c010bdcf0048ab6671ed    .cirrus.yml100644 blob c592dda681fecfaa6bf64fb3f539eafaf4123ed8    .clang-format100644 blob f9d819623d832113014dd5d5366e8ee44ac9666a    .editorconfig100644 blob b08a1416d86012134f823fe51443f498f4911909    .gitattributes040000 tree fbe854556a4ae3d5897e7b92a3eb8636bb08f031    .github100644 blob 6232d339247fae5fdaeffed77ae0bbe4176ab2de    .gitignore100644 blob cbeebdab7a5e2c6afec338c3534930f569c90f63    .gitmodules100644 blob bde7aba756ea74c3af562874ab5c81a829e43c83    .mailmap100644 blob 05f3e3f8d79117c1d32bf5e433d0fd49de93125c    .travis.yml100644 blob 5ba86d68459e61f87dae1332c7f2402860b4280c    .tsan-suppressions100644 blob fc4645d5c08bd005238fc72cfa709495d8722e6a    CODE_OF_CONDUCT.md100644 blob 536e55524db72bd2acf175208aef4f3dfc148d42    COPYING040000 tree a58410edddbdd133cca6b3322bebe4fb37be93fa    Documentation100755 blob ca6ccb49866c595c80718d167e40cfad1ee7f376    GIT-VERSION-GEN100644 blob 9ba33e6a141a3906eb707dd11d1af4b0f8191a55    INSTALL

Деревья дают названия каждому подпункту и также содержат такую информацию, как разрешения на файлы в Unix, тип объекта (blob или tree) и OID каждой записи. Мы вырезаем выходные данные из 15 верхних записей, но можем использовать grep, чтобы обнаружить, что в этом дереве есть запись README.md, которая указывает на предыдущий OID блоба.

$ git cat-file -p 75130889f941eceb57c6ceb95c6f28dfc83b609c | grep README.md100644 blob eb8115e6b04814f0c37146bbe3dbc35f3e8992e0    README.md

При помощи путей деревья могут указывать на блобы и другие деревья. Имейте в виду, что эти отношения идут в паре с именами путей, но мы не всегда показываем эти имена на диаграммах.

Само дерево не знает, где внутри репозитория оно находится, то есть указывать на дерево роль объектов. Дерево, на которое ссылается <ref>^{tree}, особое это корневое дерево. Такое обозначение основано на специальной ссылке из вашего коммита.

Коммиты это снапшоты

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

В коммите есть список родительских коммитов, соответствующих предыдущим снимкам. Коммит без родителей это корневой коммит, а коммит с несколькими родителями это коммит слияния.

Коммиты также содержат метаданные, которые описывают снимки, например автора и коммиттера (включая имя, адрес электронной почты и дату) и сообщение о коммите. Сообщение о коммите для автора коммита это возможность описать цель коммита по отношению к родителям.

Например, коммит в v2.29.2 в Git-репозитории описывает этот релиз, также он авторизован, а его автор член команды разработки Git.

$ git rev-parse HEAD898f80736c75878acc02dc55672317fcc0e0a5a6/c/_git/git ((v2.29.2))$ git cat-file -p 898f80736c75878acc02dc55672317fcc0e0a5a6tree 75130889f941eceb57c6ceb95c6f28dfc83b609cparent a94bce62b99be35f2ee2b4c98f97c222e7dd9d82author Junio C Hamano <gitster@pobox.com> 1604006649 -0700committer Junio C Hamano <gitster@pobox.com> 1604006649 -0700Git 2.29.2Signed-off-by: Junio C Hamano <gitster@pobox.com>

Заглянув немного дальше в историю при помощи git log, мы увидим более подробное сообщение о коммите, оно рассказывает об изменении между этим коммитом и его родителем.

$ git cat-file -p 16b0bb99eac5ebd02a5dcabdff2cfc390e9d92eftree d0e42501b1cf65395e91e22e74f75fc5caa0286eparent 56706dba33f5d4457395c651cf1cd033c6c03c7aauthor Jeff King <peff@peff.net> 1603436979 -0400committer Junio C Hamano <gitster@pobox.com> 1603466719 -0700am: fix broken email with --committer-date-is-author-dateCommit e8cbe2118a (am: stop exporting GIT_COMMITTER_DATE, 2020-08-17)rewrote the code for setting the committer date to use fmt_ident(),rather than setting an environment variable and letting commit_tree()handle it. But it introduced two bugs:- we use the author email string instead of the committer email- when parsing the committer ident, we used the wrong variable tocompute the length of the email, resulting in it always being azero-length stringThis commit fixes both, which causes our test of this option via therebase "apply" backend to now succeed.Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Круги на диаграммах будут представлять коммиты:

• Квадраты это блобы. Они представляют содержимое файла.

• Треугольники это деревья. Они представляют каталоги.

• Круги это коммиты. Снапшоты во времени.

Ветви это указатели

В Git мы перемещаемся по истории и вносим изменения, в основном не обращаясь к OID. Это связано с тем, что ветви дают указатели на интересующие нас коммиты. Ветка с именем main на самом деле ссылка в Git, она называется refs/heads/main. Файлы ссылок буквально содержат шестнадцатеричные строки, которые ссылаются на OID коммита. В процессе работы эти ссылки изменяются, указывая на другие коммиты.

Это означает, что ветки существенно отличаются от Git-объектов. Коммиты, деревья и блобы неизменяемы (иммутабельны), это означает, что вы не можете изменить их содержимое. Изменив его, вы получите другой хэш и, таким образом, новый OID со ссылкой на новый объект!

Ветки именуются по смыслу, например, trunk [ствол] или my-special-object. Ветки используются, чтобы отслеживать работу и делиться её результатами. Специальная ссылка HEAD указывает на текущую ветку. Когда коммит добавляется в HEAD, он автоматически обновляется до нового коммита ветки. Создать новую ветку и обновить HEAD можно при помощи флага git -c:

$ git switch -c my-branchSwitched to a new branch 'my-branch'$ cat .git/refs/heads/my-branch1ec19b7757a1acb11332f06e8e812b505490afc6$ cat .git/HEADref: refs/heads/my-branch

Обратите внимание: когда создавалась my-branch, также был создан файл (.git/refs/heads/my-branch) с текущим OID коммита, а файл .git/HEAD был обновлён так, чтобы указывать на эту ветку. Теперь, если мы обновим HEAD, создав новые коммиты, ветка my-branch обновиться так, что станет указывать на этот новый коммит!

Общая картина

Посмотрим на всю картину. Ветви указывают на коммиты, коммиты на другие коммиты и их корневые деревья, деревья указывают на блобы и другие деревья, а блобы не указывают ни на что. Вот диаграмма со всеми объектами сразу:

Время на диаграмме отсчитывается слева направо. Стрелки между коммитом и его родителями идут справа налево. У каждого коммита одно корневое дерево. HEAD указывает здесь на ветку main, а main указывает на самый недавний коммит.

Корневое дерево у этого коммита раскинулось полностью под ним, у остальных деревьев есть указывающие на эти объекты стрелки, потому что одни и те же объекты доступны из нескольких корневых деревьев! Эти деревья ссылаются на объекты по их OID (их содержимое), поэтому снимкам не нужно несколько копий одних и тех же данных. Таким образом, объектная модель Git образует дерево хешей.

Рассматривая объектную модель таким образом, мы видим, почему коммиты это снимки: они непосредственно ссылаются на полное представление рабочего каталога коммита!

Вычисление различий

Несмотря на то, что коммиты это снимки, мы часто смотрим на коммит в его историческом представлении или видим его на GitHub как diff. На самом же деле сообщение о коммите часто ссылается на различие. генерируемое динамически из данных снимка путём сравнения корневых деревьев коммита и его родителя. Git может сравнить не только соседние снимки, но и два любых снимка вообще.

Чтобы сравнить два коммита, сначала рассмотрите их корневые деревья, которые почти всегда отличаются друг от друга. Затем в поддеревьях выполните поиск в глубину, следуя по парам, когда пути для текущего дерева имеют разные OID.

В примере ниже корневые деревья имеют разные значения для docs, поэтому мы рекурсивно обходим их. Эти деревья имеют разные значения для M.md, таким образом, два блоба сравниваются построчно и отображается их различие. Внутри docs N.md по-прежнему тот же самый, так что пропускаем их и возвращаемся к корневому дереву. После этого корневое дерево видит, что каталоги things имеют одинаковые OID, так же как и записи README.md.

На диаграмме выше мы заметили, что дерево things не посещается никогда, а значит, не посещается ни один из его достижимых объектов. Таким образом, стоимость вычисления различий зависит от количества путей с разным содержимым.

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

Одна из моих любимых аналогий дулизм коммитов как дуализм частиц, при котором иногда коммиты рассматриваются как снимки, а иногда как различия. Суть дела в другом виде данных, которые не являются Git-объектами в патчах.

Подождите, а что такое патч?

Патч это текстовый документ, где описывается, как изменить существующую кодовую базу. Патчи это способ самых разрозненных команд делиться кодом без коммитов в Git. Видно, как патчи перетасовываются в списке рассылки Git.

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

Git может преобразовать коммит в патч командой git format-patch. Затем патч может быть применён к Git-репозиторию командой git application. В первые дни существования открытого исходного кода такой способ обмена доминировал, но большинство проектов перешли на обмен коммитами непосредственно через пул-реквесты.

Самая большая проблема с тем, чтобы делиться исправлениями в том, что патч теряет родительскую информацию, а новый коммит имеет родителя, который одинаков с вашим HEAD. Более того, вы получаете другой коммит, даже если работаете с тем же родителем, что и раньше, из-за времени коммита, но при этом коммиттер меняется! Вот основная причина, по которой в объекте коммита Git есть разделение на "автора", и "коммиттера".

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

Идея перемещения патчей с места на место перешла в несколько команд Git как "перемещение коммитов". На самом же деле различие коммитов воспроизводится, создавая новые коммиты.

Если коммиты это не различия, что делает git cherry-pick?

Команда [git cherry-pick создаёт новый коммит с идентичным отличием от <oid>, родитель которого текущий коммит. Git в сущности выполняет такие шаги:

1. Вычисляет разницу между <oid> коммита и его родителя.

2. Применяет различие к текущему HEAD.

3. Создаёт новый коммит, корневое дерево которого соответствует новому рабочему каталогу, а родитель созданного коммита HEAD.

4. Перемещает ссылку HEAD в этот новый коммит.

После создания нового коммита вывод git log -1 -p HEAD должен совпадать с выводом git log -1 -p <oid>.

Важно понимать, что мы не "перемещали" коммит так, чтобы он был поверх нашего текущего HEAD, мы создали новый коммит, и его вывод diff совпадает со старым коммитом.

А что делает git rebase?

Команда git rebase это способ переместить коммиты так, чтобы получить новую историю. В простой форме это на самом деле серия команд git cherry-pick, которая воспроизводит различия поверх другого, отличного коммита.

Самое главное: git rebase <target> обнаружит список коммитов, доступных из HEAD, но недоступных из <target>. С помощью команды git log --online <target>...HEAD вы можете отобразить их самостоятельно.

Затем команда rebase просто переходит в местоположению <target> и выполняет команды git cherry-pick в этом диапазоне коммитов, начиная со старых. В конце мы получили новый набор коммитов с разными OID, но схожих с первоначальным диапазоном.

Для примера рассмотрим последовательность из трёх коммитов в текущей ветке HEAD с момента разветвления target. При запуске git rebase target? чтобы определить список коммитов A, B, и C, вычисляется общая база P. Затем поверх target они выбираются cherry-pick, чтобы создать новые коммиты A', B' и C'.

Коммиты A', B' и C' это совершенно новые коммиты с общим доступом к большому количеству информации через A, B и C, но они представляют собой отдельные новые объекты. На самом деле старые коммиты существуют в вашем репозитории до тех пор, пока не начнётся сбор мусора.

С помощью команды git range-diff мы даже можем посмотреть на различие двух диапазонов коммитов! Я использую несколько примеров коммитов в репозитории Git, чтобы сделать rebase на тег v2.29.2, а затем слегка изменю описание коммита.

$ git checkout -f 8e86cf65816$ git rebase v2.29.2$ echo extra line >>README.md$ git commit -a --amend -m "replaced commit message"$ git range-diff v2.29.2 8e86cf65816 HEAD1:  17e7dbbcbc = 1:  2aa8919906 sideband: avoid reporting incomplete sideband messages2:  8e86cf6581 ! 2:  e08fff1d8b sideband: report unhandled incomplete sideband messages as bugs    @@ Metadata     Author: Johannes Schindelin <Johannes.Schindelin@gmx.de>           ## Commit message ##    -    sideband: report unhandled incomplete sideband messages as bugs    +    replaced commit message         -    It was pretty tricky to verify that incomplete sideband messages are    -    handled correctly by the `recv_sideband()`/`demultiplex_sideband()`    -    code: they have to be flushed out at the end of the loop in    -    `recv_sideband()`, but the actual flushing is done by the    -    `demultiplex_sideband()` function (which therefore has to know somehow    -    that the loop will be done after it returns).    -    -    To catch future bugs where incomplete sideband messages might not be    -    shown by mistake, let's catch that condition and report a bug.    -    -    Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>    -    Signed-off-by: Junio C Hamano <gitster@pobox.com>    + ## README.md ##    +@@ README.md: and the name as (depending on your mood):    + [Documentation/giteveryday.txt]: Documentation/giteveryday.txt    + [Documentation/gitcvs-migration.txt]: Documentation/gitcvs-migration.txt    + [Documentation/SubmittingPatches]: Documentation/SubmittingPatches    ++extra line           ## pkt-line.c ##     @@ pkt-line.c: int recv_sideband(const char *me, int in_stream, int out)

Обратите внимание: результирующий range-diff утверждает, что коммиты 17e7dbbcbc и 2aa8919906 "равны", а это означает, что они будут генерировать один и тот же патч. Вторая пара коммитов различается: показано, что сообщение коммита изменилось, есть правка в README.md, которой не было в исходном коммите.

Если пройти вдоль дерева, вы увидите, что история коммитов всё ещё существует у обоих наборов коммитов. Новые коммиты имеют тег v2.29.2 в истории это третий коммит, тогда как старые имеют тег v2.28.0 болеее ранний, а в истории он также третий.

$ git log --oneline -3 HEADe08fff1d8b2 (HEAD) replaced commit message2aa89199065 sideband: avoid reporting incomplete sideband messages898f80736c7 (tag: v2.29.2) Git 2.29.2$ git log --oneline -3 8e86cf658168e86cf65816 sideband: report unhandled incomplete sideband messages as bugs17e7dbbcbce sideband: avoid reporting incomplete sideband messages47ae905ffb9 (tag: v2.28.0) Git 2.28

Если коммиты не отличия, тогда как Git отслеживает переименования?

Внимательно посмотрев на объектную модель, вы заметите, что Git никогда не отслеживает изменения между коммитами в сохранённых объектных данных. Можно задаться вопросом: "Откуда Git знает, что произошло переименование?"

Git не отслеживает переименования. В нём нет структуры данных, которая хранила бы запись о том, что между коммитом и его родителем имело место переименование.

Вместо этого Git пытается обнаружить переименования во время динамического вычисления различий. Есть два этапа обнаружения переименований: именно переименования и редактирования.

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

На первом этапе этого алгоритма сопоставления рассматриваются OID добавленных и удалённых путей и проверяется их точное соответствие. Такие точные совпадения соединяются в пары.

Вторая стадия дорогая часть вычислений: как обнаружить файлы, которые были переименованы и отредактированы? Посмотреть каждый добавленный файл и сравните этот файл с каждым удалённым, чтобы вычислить показатель схожести в процентах к общему количеству строк. По умолчанию что-либо, что превышает 50 % общих строк, засчитывается как потенциальное редактирование с переименованием. Алгоритм сравнивает эти пары до момента, пока не найдёт максимальное совпадение.

Вы заметили проблему? Этот алгоритм прогоняет A * D различий, где A количество добавлений и D количество удалений, то есть у него квадратичная сложность! Чтобы избежать слишком долгих вычислений по переименованию, Git пропустит часть с обнаружением редактирований с переименованием, если A + D больше внутреннего лимита. Ограничение можно изменить настройкой опции diff.renameLimit в конфигурации. Вы также можете полностью отказаться от алгоритма, просто отключив diff.renames.

Я воспользовался знаниями о процессе обнаружения переименований в своих собственных проектах. Например, форкнул VFS for Git, создал проект Scalar и хотел повторно использовать большое количество кода, но при этом существенно изменить структуру файла. Хотелось иметь возможность следить за историей версий в VFS for Git, поэтому рефакторинг состоял из двух этапов:

1. Переименовать все файлы без изменения блобов.

2. Заменить строки, чтобы изменить блобы без изменения файлов.

Эти два шага позволили мне быстро выполнить git log --follow -- <path>, чтобы посмотреть историю переименовывания.

$ git log --oneline --follow -- Scalar/CommandLine/ScalarVerb.cs4183579d console: remove progress spinners from all commands5910f26c ScalarVerb: extract Git version check...9f402b5a Re-insert some important instances of GVFS90e8c1bd [REPLACE] Replace old name in all filesfb3a2a36 [RENAME] Rename all filescedeeaa3 Remove dead GVFSLock and GitStatusCache codea67ca851 Remove more dead hooks code...

Я сократил вывод: два этих последних коммита на самом деле не имеют пути, соответствующего Scalar/CommandLine/ScalarVerb.cs, вместо этого отслеживая предыдущий путь GVSF/GVFS/CommandLine/GVFSVerb.cs, потому что Git распознал точное переименование содержимого из коммита fb3a2a36 [RENAME] Rename all files.

Не обманывайтесь больше

Теперь вы знаете, что коммиты это снапшоты, а не различия! Понимание этого поможет вам ориентироваться в работе с Git.

И теперь мы вооружены глубокими знаниями объектной модели Git. Не важно, какая у вас специализация, frontend, backend, или вовсе fullstack вы можете использовать эти знания, чтобы развить свои навыки работы с командами Git'а или принять решение о рабочих процессах в вашей команде. А к нам можете приходить за более фундаментальными знаниями, чтобы иметь возможность повысить свою ценность как специалиста или вовсе сменить сферу.

Узнайте, как прокачаться в других специальностях или освоить их с нуля:

• Профессия Data Scientist

• Профессия Data Analyst

• Курс по Data Engineering