Вивчай
· 11 хв читання
gitінструментипочатківцям

Git: як відкотити все, що зламав — reset, revert, reflog і stash

Старий бобінний магнітофон, палець натискає кнопку перемотування назад — метафора відкату змін у GitСтарий бобінний магнітофон, палець натискає кнопку перемотування назад — метафора відкату змін у Git

Знайома ситуація: ти щось зробив у Git, глянув на git log — і там не те. Коміт із дурним повідомленням. Або зайвий файл. Або, найгірше, три коміти зникли, бо ти «просто спробував» reset --hard. Долоні холодіють, у голові одна думка: «я все втратив».

Видихни. Зараз ти дізнаєшся головний секрет Git, після якого ця паніка більше не повернеться: закомічене майже неможливо втратити. А далі — конкретні рецепти на кожну типову аварію. Не теорія, а «що саме набрати в терміналі, коли…».


Чому в Git майже нічого не губиться

У статті про те, що лежить у папці .git, ми розбирали: кожен коміт — це об'єкт у базі, а гілка — лише закладка-вказівник на один із них. Так ось, команди на кшталт reset не видаляють коміти. Вони лише пересувають закладку. Сам коміт залишається лежати в базі, просто на нього більше ніхто не показує.

Уяви бобінний магнітофон із фото вгорі. Ти перемотав стрічку назад — але записане нікуди не зникло, воно досі на плівці. Ти просто дивишся на інше місце.

І найкраще: Git веде журнал кожного переміщення твоєї «головки» (HEAD). Називається він reflog. Кожен коміт, кожен checkout, кожен reset — усе записується. За замовчуванням ці записи зберігаються 90 днів (для вже недосяжних комітів — 30 днів). Це означає: у тебе є мінімум місяць, щоб повернути будь-що, що ти «втратив».

Порада

Єдине, що Git справді не може повернути — те, що ніколи не комітилось. Незбережені зміни в робочій папці після reset --hard або checkout -- file зникають назавжди. Тому золоте правило: сумніваєшся — спочатку закоміть, хоч із повідомленням «wip». Коміт завжди можна виправити, а нескомічене — ні.

Три зони, які треба розрізняти

Перш ніж лікувати, треба розуміти анатомію. У Git-проєкті зміни живуть у трьох місцях:

ЗонаЩо цеАналогія
Робоча папка (working directory)Файли, які ти бачиш і редагуєшСтіл, на якому ти працюєш
Індекс (staging area)Те, що ти відібрав для наступного коміту через git addКоробка «відправити», у яку ти складаєш готове
HEAD (поточний коміт гілки)Останній збережений знімокАрхів із запечатаними коробками

Більшість команд відкату відрізняються лише тим, які з цих трьох зон вони повертають назад. Запам'ятай цю таблицю — і далі все стане передбачуваним. Якщо індекс поки здається магією, спершу стаття про staged vs unstaged розставить усе по місцях за три хвилини.


Сценарій 1: закомітив із кривим повідомленням

Найчастіша і найбезпечніша аварія. Написав git commit -m "fix" замість чогось осмисленого.

git commit --amend -m "виправив відступи в навігації"

--amend замінює останній коміт новим — із тим самим вмістом, але новим повідомленням. Технічно Git створює інший коміт (з іншим хешем), а старий лишається в reflog.

Хочеш відкрити повідомлення в редакторі замість -m? Просто git commit --amend без аргументів.

Увага

--amend змінює історію. Якщо коміт уже запушений і хтось його підтягнув — не роби amend, бо потім доведеться push --force, і колеги отримають конфлікти. Для запушеного — дивись сценарій 6.

Сценарій 2: закомітив зайвий файл

Додав debug.log, .env або node_modules у коміт разом із потрібним кодом. Рецепт із двох кроків: прибрати файл з індексу й «долити» коміт.

git rm --cached debug.log      # забрати з індексу, файл на диску лишається
git commit --amend --no-edit   # переписати останній коміт без зміни повідомлення

--cached — ключове слово. Без нього git rm видалить файл і з диска теж. А --no-edit каже: «повідомлення не чіпай, просто онови вміст».

І одразу додай цей файл у .gitignore, щоб історія не повторилась.

Сценарій 3: скасувати останній коміт, але зберегти зміни

Закомітив зарано. Хочеш розбити на два коміти, або щось дописати, або просто «розкомітити». Тут виходить на сцену git reset.

git reset --soft HEAD~1

HEAD~1 означає «коміт на один крок назад». --soft пересуває закладку гілки назад, але індекс і робочу папку не чіпає. Результат: твій код на місці, усе лежить staged, наче ти щойно зробив git add — і можна комітити заново.

Анімація: git reset --soft HEAD~1 скасовує коміт, зміни лишаються staged, далі зайвий файл прибирається з індексу й робиться новий комітАнімація: git reset --soft HEAD~1 скасовує коміт, зміни лишаються staged, далі зайвий файл прибирається з індексу й робиться новий коміт

Є варіант м'якший до логіки, але жорсткіший до індексу:

git reset HEAD~1          # те саме, що --mixed

--mixed (режим за замовчуванням) скидає і закладку, і індекс. Код на диску цілий, але він unstaged — як ніби ти його щойно написав і ще не робив git add. Зручно, коли хочеш перебрати, що саме піде в коміт.

Сценарій 4: викинути все і повернутись до чистого коміту

Експеримент пішов не туди, і ти хочеш, щоб проєкт виглядав точно як у певному коміті. Нескомічені зміни тобі не потрібні.

git reset --hard HEAD~1

--hard скидає всі три зони: і закладку, і індекс, і файли на диску. Це єдиний режим, який реально стирає нескомічене. Тому перед ним завжди git status — щоб бачити, що саме полетить у прірву.

Ось вся різниця між трьома режимами на одній схемі:

Схема: reset --soft чіпає лише HEAD, --mixed — HEAD та індекс, --hard — усі три зони включно з робочою папкоюСхема: reset --soft чіпає лише HEAD, --mixed — HEAD та індекс, --hard — усі три зони включно з робочою папкою

Правило для запам'ятовування: soft — м'яко, лише закладка; mixed — закладка і коробка; hard — усе, включно зі столом.

Сценарій 5: зробив reset --hard і коміти «зникли»

Ось вона, класика паніки. Ти зробив reset --hard HEAD~2, глянув у git log — і двох останніх комітів немає. Але ти вже знаєш: вони не видалені, на них просто не показує жодна гілка. Час відкрити журнал подорожей.

git reflog

Побачиш щось таке:

7b2e041 HEAD@{0}: reset: moving to HEAD~2
f81c2a7 HEAD@{1}: commit: форма зворотного зв'язку
a3f9c12 HEAD@{2}: commit: стилі для hero-секції

HEAD@{1} — це «де була головка один крок тому». Тобто до reset. Повертаємось туди:

git reset --hard HEAD@{1}

Або за хешем: git reset --hard f81c2a7. Коміти знову в git log, наче нічого не було.

Анімація: після git reset --hard два коміти зникають із log, git reflog показує попередню позицію HEAD, reset --hard на попередню позицію повертає їхАнімація: після git reset --hard два коміти зникають із log, git reflog показує попередню позицію HEAD, reset --hard на попередню позицію повертає їх

Інфо

Reflog — локальний. Він живе тільки на твоїй машині й не пушиться. Якщо ти клонував репозиторій заново — старого reflog там не буде. І ще: записи не зберігаються вічно, git gc чистить їх після 90 днів (30 — для недосяжних комітів). Місяць на порятунок у тебе точно є, рік — ні.

Сценарій 6: уже запушив — і треба скасувати

Тут правила змінюються. Поки коміти лише у тебе — переписуй історію як завгодно. Але щойно ти зробив git push, вони стали спільними. Якщо ти зробиш reset і push --force, у колеги, який уже підтягнув ці коміти, історія розійдеться з твоєю — і почнеться хаос із конфліктами.

Тому для запушеного є окрема команда, яка нічого не стирає, а додає новий коміт із протилежними змінами:

git revert HEAD            # скасувати останній коміт
git revert a3f9c12         # скасувати конкретний коміт
git push

Уяви, що ти надіслав листа. Забрати його з чужої скриньки не можна. Але можна надіслати наступний: «попередній лист не враховуйте». Це і є revert. Історія чесна, обидва коміти видно, нічиє дерево не ламається.

СитуаціяКоманда
Коміт тільки у менеreset / amend — переписуй сміливо
Коміт уже на GitHubrevert — додавай скасування зверху

Сценарій 7: закомітив у main замість окремої гілки

Зробив три коміти, глянув у промпт — а ти в main. А мало бути у feature/gallery. Виправити — два кроки, і жоден коміт не постраждає.

git branch feature/gallery      # створити гілку, яка показує на поточний (помилковий) коміт
git reset --hard origin/main    # повернути main до стану на сервері
git switch feature/gallery      # перейти в нову гілку — коміти там

Логіка: спочатку ставимо нову закладку на твої коміти, щоб вони не стали «сиротами», і лише потім відкочуємо main. Якщо main ще не пушився, замість origin/main постав HEAD~3 — на скільки комітів відкотити.

Сценарій 8: треба терміново перемкнутись, а робота недороблена

Ти в розпалі роботи над галереєю, а колега пише: «на проді баг, треба фіксити в main зараз». Комітити напівзламаний код не хочеться. Для цього є stash — полиця тимчасового зберігання.

git stash push -u -m "галерея, в процесі"   # сховати зміни (-u — включно з новими файлами)
git switch main                            # … фіксимо баг, комітимо …
git switch feature/gallery
git stash pop                              # дістати зміни назад

Анімація: git stash ховає незакомічені зміни, робоча папка чиста, після повернення на гілку git stash pop повертає все назадАнімація: git stash ховає незакомічені зміни, робоча папка чиста, після повернення на гілку git stash pop повертає все назад

stash — це стек: можна скласти кілька порцій і подивитись список через git stash list. pop дістає верхню і видаляє її зі стеку; apply — дістає, але залишає копію на полиці, якщо раптом ти захочеш застосувати її ще раз.

Порада

Прапорець -u (--include-untracked) важливий: без нього нові, ще не додані в Git файли не потраплять у stash і залишаться на диску. Повідомлення через -m теж не зайве — через тиждень stash@{3} без підпису ні про що не скаже.

Сценарій 9: «detached HEAD» — що це взагалі

Зробив git checkout a3f9c12, щоб подивитись старий код, і отримав страшне попередження: You are in 'detached HEAD' state. Звучить як травма, насправді — нічого страшного.

Зазвичай HEAD показує на гілку, а гілка — на коміт. «Відчеплений» HEAD показує напряму на коміт, оминаючи гілку. Ти ніби зійшов із потяга на проміжній станції: можеш озиратися, але якщо щось тут побудуєш (закомітиш) і поїдеш далі — воно залишиться без адреси.

Вийти просто:

git switch main                 # повернутись на гілку, нічого не зберігаючи
# або, якщо ти тут щось закомітив і хочеш це залишити:
git switch -c experiment        # створити гілку прямо тут — коміти прив'язані

А якщо ти вже пішов із detached HEAD і згадав про коміти потім — так, git reflog знайде їх і тут.


Чеклист: що робити ПЕРЕД тим, як щось відкочувати

Половина катастроф із Git — не від команд, а від поспіху. Три дії перед будь-яким відкатом:

  1. git status — що зараз unstaged, що staged, чи є нескомічене. Саме нескомічене — єдине, що можна реально втратити.
  2. git log --oneline -5 — де ти, і які коміти останні. Переконайся, що HEAD~1 — це справді той коміт, про який ти думаєш.
  3. Чи це вже запушено? Якщо так — тільки revert. Якщо ні — reset і amend до твоїх послуг.

І бонусна звичка: якщо збираєшся зробити щось ризиковане, спочатку git branch backup. Це 41 байт на диску й нуль секунд часу, а сон стає значно спокійнішим.

Шпаргалка на одному екрані

Що сталосяЩо набрати
Криве повідомлення комітуgit commit --amend -m "…"
Зайвий файл у комітіgit rm --cached file → git commit --amend --no-edit
Розкомітити, зміни лишити stagedgit reset --soft HEAD~1
Розкомітити, зміни лишити unstagedgit reset HEAD~1
Викинути все до комітуgit reset --hard HEAD~1
Повернути «зниклі» комітиgit reflog → git reset --hard HEAD@{n}
Скасувати запушений комітgit revert <hash> → git push
Коміти в main замість гілкиgit branch X → git reset --hard origin/main → git switch X
Тимчасово сховати роботуgit stash push -u -m "…" → git stash pop
Вийти з detached HEADgit switch main або git switch -c нова-гілка
Відкотити один файл до комітуgit restore file (або git checkout -- file)
Для допитливих

Повна й безкоштовна глибина — книга Pro Git, є українською: розділ Скасування змін і Reset demystified — той самий поділ на три дерева, тільки ще детальніше. Офіційні довідки: git-reset, git-reflog, git-gc (саме там живуть 90 і 30 днів). Цікавинка: команди switch і restore з'явилися у Git 2.23 (2019) як зручніша заміна перевантаженому checkout, який робив і перемикання гілок, і відкат файлів — сьогодні саме їх радять новачкам.

Часті питання

Чи видаляє git reset коміти?+
Ні. Reset лише пересуває вказівник гілки на інший коміт. Самі коміти лишаються в базі об’єктів Git і записані в reflog, тому їх можна повернути через git reflog і git reset --hard із потрібною позицією з журналу. Зникнути можуть лише незакомічені зміни — і тільки при reset --hard.
Яка різниця між git reset і git revert?+
Reset переписує історію: пересуває гілку назад, і скасовані коміти зникають із log. Revert історію не чіпає — створює новий коміт, який скасовує зміни вибраного. Reset — для локальних, ще не запушених комітів; revert — для тих, що вже на сервері й у колег.
Скільки часу зберігається reflog?+
За замовчуванням git gc прибирає записи reflog старші за 90 днів, а записи про коміти, недосяжні з жодної гілки, — старші за 30 днів. Reflog локальний: він не пушиться і не з’являється у свіжому клоні.
Що робити, якщо зробив reset --hard і втратив незакомічені зміни?+
На жаль, зміни, які ніколи не потрапляли в коміт або stash, Git відновити не може — reflog записує лише коміти. Іноді допомагає історія файлів у редакторі (VS Code: Timeline) або автозбереження. На майбутнє: перед ризикованими командами робити git stash або wip-коміт.
Що таке detached HEAD і чи це небезпечно?+
Це стан, коли HEAD показує напряму на коміт, а не на гілку — зазвичай після git checkout з хешем або тегом. Небезпеки немає: можна дивитись і тестувати. Але коміти, зроблені в цьому стані, не належать жодній гілці, тож перед виходом створи гілку через git switch -c назва, інакше їх доведеться шукати в reflog.

Git — не поле з мінами, а магнітофон із журналом: кожна «втрата» — це просто головка, перемотана не туди. Знаєш три зони, знаєш reflog — і будь-яка аварія перетворюється на дві команди в терміналі.

Щоб база була міцною, пройди уроки Основи Git та GitHub і віддалені репозиторії, а шпаргалку Git-команд тримай під рукою — тепер у ній не буде жодної страшної команди.