• 8 минут чтения

• Git, JavaScript, Инструменты

• Поделись Твиттер, Линкедин

Работа с кодом — рискованное предприятие: существует бесчисленное множество способов выстрелить себе в ногу! Но если вы используете Git в качестве системы контроля версий, у вас есть отличная подстраховка. Множество инструментов «отмены» помогут вам восстановиться практически после любой аварии.

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

Отменить незафиксированные изменения в файле

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

Хорошая новость заключается в том, что если вы не зафиксировали изменения, отменить их довольно легко. Но есть и плохие новости: вы не могу вернуть модификации как только вы их отменили! Поскольку они не были сохранены в «базе данных» Git, восстановить их невозможно!

После этого небольшого предупреждения давайте отменим наши изменения в index.html:

$ git restore index.html

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

Восстановить удаленный файл

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

Вам будет приятно это услышать git restore оснащен, чтобы справиться с этой ситуацией так же легко:

$ git restore index.html

То restore команду это не волнует Какие именно вы сделали с этим бедным файлом. Он просто воссоздает свое последнее зафиксированное состояние!

Отменить некоторые из ваших изменений

Большинство дней представляют собой смесь хорошей и плохой работы. А иногда и то, и другое в одном файле: какие-то ваши модификации будут великолепны (давайте будем великодушны и назовем их гениальными), а другие сгодятся на помойку.

Git позволяет работать с изменениями очень детально. С использованием git restore с -p flag делает весь этот процесс уничтожения более тонким:

$ git restore -p index.html

Git берет нас за руку и проводит через каждую порция изменений в файле, спрашивая, хотим ли мы его выбросить (в этом случае мы должны ввести y) или сохранить его (введя n):

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

Исправить самый последний коммит

Поднимите руку, если вы никогда не делали опечаток в сообщении коммита или никогда не забывали добавить последнее изменение. Без рук? Это то, о чем я думал. Так как испорченные коммиты очень распространены, Git очень легко исправляет такие ошибки.

Давайте посмотрим на яркий пример плохого сообщения коммита:

С помощью --amend опция позволяет вам изменить этот самый последний коммит (и Только Вот этот):

$ git commit --amend -m "A message without typos"

В случае, если вы также забыл добавить определенное изменение, вы можете легко это сделать. Просто инсценируйте его, как и любое другое изменение, с помощью git add команду, а затем запустить git commit --amend снова:

$ git add otten-change.txt

$ git commit --amend --no-edit

То --no-edit option сообщает Git, что на этот раз мы не хотим изменять сообщение коммита.

Восстановить последствия плохого коммита

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

Конечно, и у этой проблемы есть решение: git revert команда! И это решает нашу проблему очень неразрушающим образом. Вместо того, чтобы вырвать наш плохой коммит из истории, он создает новый коммит содержит противоположные изменения.

Выполнение этого в командной строке так же просто, как предоставление хэша ревизии этого плохого коммита в git revert команда:

$ git revert 2b504bee

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

Восстановить предыдущее состояние проекта

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

К счастью, эту проблему довольно легко решить. Нам просто нужно предоставить хеш SHA-1 ревизии, к которой мы хотим вернуться, когда мы используем git reset команда. Любые коммиты, сделанные после этой ревизии, исчезнут:

$ git reset --hard 2b504bee

То --hard опция гарантирует, что у нас останется чистый рабочая копия. В качестве альтернативы мы можем использовать --mixed вариант для большей гибкости (и безопасности): --mixed сохранит изменения, содержащиеся в удаленных коммитах, как локальные изменения в нашей рабочей копии.

Восстановление потерянных коммитов с помощью Reflog

Вы, наверное, уже заметили, что когда дело доходит до исправления ошибок, с Git возможно практически все! Это включает в себя отмена отмены. Допустим, мы поняли, что git reset то, что мы только что исполнили выше, было не самой яркой нашей идеей. Мы боимся, что потеряли ценные коммиты, что повергло нас в состояние паники.

Как вы уже догадались, мы можем решить и эту проблему — с помощью определенного инструмента. reflog это своего рода журнал, в котором Git протоколирует все движения HEAD указатель. Другими словами, каждый раз, когда мы фиксируем, извлекаем, объединяем, перебазируем, выбираем вишни и т. д., в этом журнале будет создаваться новая запись. К счастью, это также происходит, когда мы используем git reset!

Давайте откроем reflog с помощью простой команды git reflog. Взгляните на то, что у нас есть:

Первое, что нужно знать о reflog, это то, что он в хронологическом порядке. Поэтому неудивительно, что наши недавние git reset ошибка в самом верху. Если мы сейчас хотим отменить это, мы можем просто вернуться в состояние раньше, которое также протоколируется здесь, прямо внизу!

Теперь мы можем скопировать хэш коммита этого безопасного состояния и создать на его основе новую ветку:

$ git branch happy-ending e5b19e4

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

Восстановить один файл из предыдущего состояния

До сих пор, когда мы работали с зафиксированными состояниями, мы всегда работали с полным проектом. Но что, если мы хотим восстановить один файл, а не весь проект? Например, предположим, что мы удалили файл только для того, чтобы намного позже узнать, что нам не следовало этого делать. Чтобы избавить нас от этого несчастья, нам придется решить две проблемы:

1. найти коммит, где мы удалили файл,
2. затем (и только тогда) восстановить его.

Давайте поищем в истории коммитов наш несчастный потерянный файл:

$ git log -- <filename>

В выводе перечислены все коммиты, в которых этот файл был изменен. И потому что log вывод отсортирован в хронологическом порядке, нам не нужно долго искать — коммит, в котором мы удалили файл, скорее всего, будет самым верхним (потому что после его удаления файл, вероятно, больше не будет отображаться в новых коммитах).

С хешем этого коммита и именем нашего файла у нас есть все, что нужно, чтобы вернуть его из мертвых:

$ git checkout <deletion commit hash>~1 -- <filename>

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

Теперь вы (почти) непобедимы

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

Но чтобы действительно стать непобедимым (то есть в Git), вам придется дождаться вторая часть этой серии. Мы рассмотрим еще несколько сложных проблем, например, как восстановить удаленные ветки, как переместить коммиты между ветками и как объединить несколько коммитов в один!

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

До скорой встречи во второй части этой серии! Подпишитесь на Smashing Newsletter, чтобы не пропустить это. 😉

(вф, иль, ал)