Git: історія, гілки й скасування змін
20 питань · ~20 хв · Версія v3.0
Увійдіть, щоб продовжити
Коміти й індекс, злиття й rebase, конфлікти, stash, reset, revert і reflog, пошук в історії - питання всіх рівнів, від junior до senior.
- За спробу
- 20
- У пулі
- 68
- Проходжень
- 0
- Середній бал
- -
- Пройшли на 70%+
- -
Питання для підготовки
30 питаньКоміти в Git майже ніколи не зникають одразу. reset --hard, rebase чи видалення гілки лише прибирають посилання на коміти, а самі об'єкти лишаються в репозиторії, доки їх не прибере збирач сміття (за замовчуванням недосяжні записи reflog живуть 30 днів).
git reflog - журнал того, куди вказував HEAD (і кожна гілка) після кожної операції:
git reflog
9f8e7d6 HEAD@{0}: reset: moving to HEAD~3
a1b2c3d HEAD@{1}: commit: Send invoice email
d4e5f6a HEAD@{2}: commit: Add invoice model
Знайшли стан до помилки - повертаємося:
git reset --hard HEAD@{1} # повернути гілку туди
# або обережніше:
git branch rescue a1b2c3d # створити гілку на втраченому коміті
Після невдалого rebase шукають у reflog запис перед rebase (start). Ще простіше - ORIG_HEAD: rebase, merge і reset зберігають у ньому попереднє положення.
Що reflog не врятує:
- Незакомічені зміни після
reset --hardчиcheckout -- file: їх у репозиторії не було. Лише якщо їх додавали в індекс (git add), об'єкти можна знайти черезgit fsck --lost-found. - Чужий репозиторій: reflog локальний. Коміт, втрачений на сервері після force push, шукають у reflog того, хто його мав.
- Записи, старші за термін зберігання, після
git gc.
Висновок для команди: закомітьте - і зміни майже неможливо втратити. Небезпечна лише незакомічена робота.
Обидві команди переносять зміни з однієї гілки в іншу, але по-різному формують історію.
git merge main (у своїй гілці) створює коміт злиття з двома батьками. Історія показує, як було насправді: дві гілки розвивалися паралельно і зійшлися.
git rebase main переписує коміти гілки так, ніби вона почалася з останнього коміту main: кожен коміт застосовується заново й отримує новий хеш. Історія стає лінійною, без комітів злиття.
git switch feature
git rebase main # перебудувати feature поверх свіжого main
git switch main
git merge --ff-only feature # тепер злиття - просте перемотування
Що обирати:
- Rebase - для власної гілки, щоб підтягнути свіжий
mainі отримати чисту історію перед pull request. - Merge - для злиття спільних гілок і коли важливо зберегти, як саме йшла робота.
Головне правило rebase: не переписувати коміти, які вже опубліковані й використовуються іншими. Після rebase гілку доведеться відправляти з --force-with-lease, а в колег, що працювали поверх старих комітів, історія розійдеться.
Конфлікти бувають і там, і там. Але при rebase їх розв'язують по коміту: якщо гілка з 10 комітів зачіпає те саме місце, конфлікт може з'явитися кілька разів.
Спосіб залежить від того, чи коміт уже відправлено в спільний репозиторій.
Коміт ще локальний - git reset пересуває гілку назад:
git reset --soft HEAD~1 # коміт скасовано, зміни лишилися в індексі (staged)
git reset HEAD~1 # (--mixed) зміни лишилися у файлах, але не staged
git reset --hard HEAD~1 # коміт і зміни видалено повністю
Найчастіше потрібен --soft чи --mixed: виправити повідомлення, додати забутий файл, розбити коміт. --hard знищує незбережену роботу.
Виправити лише останній коміт - git commit --amend: змінити повідомлення чи додати файли.
Коміт уже в спільній гілці - git revert створює новий коміт, що скасовує зміни старого. Історія не переписується, тож колегам нічого не ламається:
git revert a1b2c3d
git push
Головна відмінність: reset переписує історію (коміт ніби зник), revert додає до неї (коміт є, і є його скасування). Для main, з якого вже розгорнуто прод, - лише revert.
Для окремих файлів є git restore: git restore app/User.php - відкинути незакомічені зміни у файлі, git restore --staged app/User.php - прибрати з індексу.
Git - це сховище об'єктів, адресованих за хешем вмісту, і набір вказівників на них.
Чотири типи об'єктів:
- blob - вміст файлу (без імені й прав).
- tree - каталог: список імен з посиланнями на blob-и й вкладені tree.
- commit - посилання на кореневий tree (повний знімок проєкту), на батьківські коміти, автор, дата, повідомлення.
- tag (анотований) - іменований вказівник на об'єкт з власними метаданими.
Ідентифікатор кожного об'єкта - хеш його вмісту (SHA-1, у нових репозиторіях можливий SHA-256). Однаковий файл у двох комітах - той самий blob, збережений один раз. Змінити старий коміт неможливо: інший вміст - інший хеш, тобто вже інший об'єкт.
Гілка - файл з одним хешем. refs/heads/main містить хеш останнього коміту. Новий коміт просто переписує цей хеш. Тому створення гілки миттєве й нічого не копіює.
HEAD - вказівник на поточну гілку (ref: refs/heads/main) або напряму на коміт («detached HEAD»).
git cat-file -p HEAD # вміст коміту: tree, parent, author
git cat-file -p HEAD^{tree} # дерево каталогу
cat .git/refs/heads/main # гілка - це просто хеш
Що з цього випливає:
- Коміт зберігає знімок, а не різницю. Diff Git обчислює на льоту, порівнюючи дерева. (Для економії місця об'єкти пакуються в pack-файли з дельта-стисненням, але це деталь зберігання.)
- Rebase не «переносить» коміти - він створює нові з іншими батьками й хешами.
- Видалення гілки не видаляє коміти, лише вказівник - звідси можливість їх відновити.
rerere - «reuse recorded resolution», повторне використання записаних розв'язань конфліктів. Git запам'ятовує, як ви розв'язали конфлікт, і коли той самий конфлікт виникає знову, застосовує розв'язання автоматично.
git config --global rerere.enabled true
Як це працює:
- виникає конфлікт - Git записує «образ» конфлікту (обидві версії фрагмента) в
.git/rr-cache; - ви розв'язуєте конфлікт і робите коміт - Git записує результат;
- наступного разу при такому самому конфлікті Git підставляє збережене розв'язання:
Resolved 'app/Models/Invoice.php' using previous resolution.
Файл лишається не доданим до індексу - розв'язання варто переглянути й зробити git add (з rerere.autoUpdate true Git додає сам).
Коли це заощаджує час:
- довгоживуча гілка, яку регулярно оновлюють rebase-ом на
main: при кожному rebase ті самі конфлікти повторюються коміт за комітом; - пробне злиття: злити гілку, щоб перевірити, чи все збирається, скасувати злиття - а при справжньому злитті пізніше конфлікти вже розв'язані;
- скасований rebase: розв'язали половину конфліктів, зробили
git rebase --abort, почали знову - розв'язане вже не треба повторювати; - інтеграційні гілки (як у Git Flow чи при підготовці релізу), куди ті самі гілки зливаються багато разів.
Команди:
git rerere status # файли, для яких записано розв'язання
git rerere diff # що саме буде застосовано
git rerere forget app/Models/Invoice.php # забути неправильне розв'язання
Ризики:
- збережене помилкове розв'язання застосовуватиметься знову й знову - тому
forget; - rerere зіставляє текст конфлікту, а не зміст: якщо код навколо змінився, розв'язання може бути формально застосовне, але логічно хибне. Тести після злиття обов'язкові;
- кеш локальний і не передається колегам; старі записи прибирає
git gc(за замовчуванням через 60 днів для розв'язаних і 15 - для нерозв'язаних).
Прочитати - ще не значить знати
20 питань, по одному на екран, ~20 хв. Після завершення - розбір кожної помилки з посиланням на питання.