Git как откатиться к коммиту

Операции отмены

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

Эта команда использует область подготовки (индекс) для внесения правок в коммит. Если вы ничего не меняли с момента последнего коммита (например, команда запущена сразу после предыдущего коммита), то снимок состояния останется в точности таким же, а всё что вы сможете изменить — это ваше сообщение к коммиту.

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

Например, если вы сделали коммит и поняли, что забыли проиндексировать изменения в файле, который хотели добавить в коммит, то можно сделать следующее:

В итоге получится единый коммит — второй коммит заменит результаты первого.

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

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

Отмена индексации файла

Следующие два раздела демонстрируют как работать с индексом и изменениями в рабочем каталоге. Радует, что команда, которой вы определяете состояние этих областей, также подсказывает вам как отменять изменения в них. Например, вы изменили два файла и хотите добавить их в разные коммиты, но случайно выполнили команду git add * и добавили в индекс оба. Как исключить из индекса один из них? Команда git status напомнит вам:

Прямо под текстом «Changes to be committed» говорится: используйте git reset HEAD …​ для исключения из индекса. Давайте последуем этому совету и отменим индексирование файла CONTRIBUTING.md :

Команда выглядит несколько странно, но — работает! Файл CONTRIBUTING.md изменен, но больше не добавлен в индекс.

Отмена изменений в файле

В выводе команды из последнего примера список изменений выглядит примерно так:

Здесь явно сказано как отменить существующие изменения. Давайте так и сделаем:

Как видите, откат изменений выполнен.

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

Отмена действий с помощью git restore

Отмена индексации файла с помощью git restore

Файл CONTRIBUTING.md изменен, но снова не индексирован.

Откат измененного файла с помощью git restore

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

Важно понимать, что git restore — опасная команда. Любые локальные изменения, внесенные в этот файл, исчезнут — Git просто заменит файл последней зафиксированной версией. Никогда не используйте эту команду, если точно не знаете, нужны ли вам эти несохраненные локальные изменения.

Источник

Отмена действий в Git

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

Не существует какого-то одного традиционного способа отмены действий в Git. Отмена производится с помощью некоторых других команд. Мы рассмотрим “первую пятерку” сценариев, которые помогут вам исправить ошибку и двинуться дальше.

Отмена Git Add

Один из самых распространенных вопросов в сообществе Git звучит так: “Как откатить git add перед коммитом?” Вы можете отменить действия над конкретным файлом или все внесенные изменения.

Решение, которое потребуется для этого, весьма простое. Чтобы откатить один файл, просто вызовите команду git reset :

Для отмены всех изменений запустите следующее:

Как откатить Git Merge

Объединение может привести к нежелаемым результатам. Но, как уже было сказано, вы можете с легкостью исправить свою ошибку! Давайте представим сценарий, в котором вы уже отправили изменения и осознали, что вам нужно отменить сделанное объединение.

Затем вернитесь к упомянутому коммиту, выполнив следующее:

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

Как откатить Git Reset

Предлагаем суперкороткий способ отменить команду git reset:

Отмена последних коммитов в Git

Команду git reset можно использовать для отмены внесенных изменений:

x введите число. Например, если вы укажете

Другой метод — это команда git revert HEAD

Этот метод лучше всего работает в случае с общими публичными репозиториями.

Отмена Git Rebase

Допустим, вы выполнили команду git rebase в локальной ветке git и отправили ее в удаленную ветку. Следом вы поняли, что это не отвечает вашим ожиданиям, и захотели отменить сделанное.

Самый простой способ — найти главный коммит вашей ветки, запустив команду:

Заключение

Вот и все о том, как вы можете отменить наиболее часто используемые команды в Git. Хоть никакой традиционной команды отмены и нет, другие команды git могут помочь вам откатить то, что вы могли сделать по ошибке.

Источник

Отмена коммитов и изменений

В этом разделе мы обсудим доступные стратегии и команды Git для выполнения отмены изменений. Прежде всего необходимо отметить, что в Git не существует традиционной системы отмены, как в текстовых редакторах. Лучше воздержаться от сопоставления операций Git с какой бы то ни было традиционной концепцией отмены изменений. Кроме того, Git имеет собственную систему терминов для операций отмены, и в обсуждении лучше всего использовать их. В числе таких терминов — сброс (reset), возврат (revert), переключение (checkout), очистка (clean) и другие.

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

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

Поиск утерянного: просмотр старых коммитов

Просмотр старых версий

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

Допустим, история вашего проекта выглядит примерно так:

Для просмотра коммита «Make some important changes to hello.txt» можно использовать команду git checkout в следующем виде:

Предположим, вы ведете разработку в главной ветке main по умолчанию. При каждом возвращении в ветку main можно использовать команду git revert или git reset для отмены нежелательных изменений.

Отмена коммита снимка

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

Отмена коммита с помощью git checkout

Отмена публичного коммита с помощью git revert

Отмена коммита с помощью git reset

Отмена последнего коммита

Отмена неотправленных изменений

Рабочий каталог

Раздел проиндексированных файлов

Отмена публичных изменений

Резюме

Помимо основных команд отмены, мы рассмотрели другие команды Git: git log для поиска потерянных коммитов, git clean для отмены изменений, не подтвержденных коммитами, и git add для изменения индексирования.

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

Источник

Git, я хочу все отменить! Команды исправления допущенных ошибок

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

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

Черт, я сделал что-то не то. Дайте мне волшебную машину времени!

Эта команда позволяет восстановить случайно удаленные данные, откатив слияние, после которого случилась неприятность. refLog используется ну очень часто — давайте скажем спасибо тому, что предложил добавить эту команду.

Я сделал коммит, но сразу же заметил ошибку, ее нужно исправить!

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

Хочу изменить сообщение последнего коммита!

Это просто… глупые требования к оформлению сообщений.

Я случайно закоммитил в мастер, хотя это должен был в новую ветку!

Если вы уже закоммитили в публичную ветку, команды не сработают. В этом случае поможет git reset HEAD@ <укажите количество коммитов, на которое нужно вернуться>вместо HEAD

Ну вот, я ошибочно закоммитил не в ту ветку

Есть еще один способ, который использует большое количество разработчиков — это cherry-pick.

Мне нужно запустить diff, но ничего не получается

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

В общем, это не баг, а фича, но она чертовски неочевидная ¯\_(ツ)_/¯

Мне срочно нужно отменить коммит, который сделан 5 коммитов назад

К счастью, не нужно отказываться назад на 5 коммитов, занимаясь копипастом старых и новых файлов. Отменить все это можно при помощи revert.

Кроме того, откатить можно не только коммит, но и целый файл. Правда, это уже будут другие команды…

Отменить изменения в файле

А вот и они, эти другие команды.

Когда я впервые нашел эту возможность, это было КРУТО, КРУТО, К-Р-У-Т-О. Но если задуматься — почему именно checkout — лучший вариант для отмены изменений в файле? :shakes-fist-at-linus-torvalds:

Спасибо Eric V. За этот способ. И все жалобы по поводу использования sudo адресуйте ему.

Если вам нужно обнулить изменения и полностью откатиться до исходной версии, то можно попробовать сделать именно так. Но помните — эти команды разрушительны и необратимы.

Внимание! Эта статья не является исчерпывающим руководством. И да, есть и другие способы сделать то же самое, причем еще лучше. Но я пришел именно к этим вариантам методом проб и ошибок. Потом у меня появилась сумасшедшая идея поделиться находками. Берите это или уходите!

Даниил Пилипенко, директор центра подбора IT-специалистов SymbioWay и евангелист бэкенд-направления онлайн-университета Skillbox, дополнил перевод мнением о Git и его актуальности для разработчиков.

Git появился в 2005-ом году, и он далеко не сразу занял рынок. Помню, когда мы ещё в 2008-ом году в команде разработчиков внедряли SVN. И даже в 2012-ом одна близкая ко мне компания усиленно внедряла Mercurial. С годами для многих стало очевидным, что Git — это лучшая система контроля версий, и её теперь используют практически все разработчики.

Если вы начинающий разработчик и собираетесь устраиваться на работу, обязательно изучите Git! Вы должны знать, что такое система контроля версий и зачем она нужна, что такое коммит, ветка, как клонировать репозиторий и отправлять сделанные изменения на сервер, как получать новые изменения с сервера, как делать merge, какие бывают виды “reset”. Поначалу эта тема вам может показаться непонятной и сложной, но вам нужно лишь привыкнуть пользоваться Git, и отвыкнуть вы уже не сможете.

Источник

Как вернуться (откатиться) к более раннему коммиту?

Я хочу вернуться к более раннему коммиту. Как мне это сделать?

Вот что показывает команда git log :

1 ответ 1

Этот вопрос можно понять по-разному:

Обозначим начальную ситуацию на следующей схеме:

Вот решения, в зависимости от задачи:

1. Временно переключиться на другой коммит

Если вам нужно просто переключиться на другой коммит, чтобы, например, посмотреть на его содержимое, достаточно команды git checkout :

Сейчас репозиторий находится в состоянии «detached HEAD». Чтобы переключиться обратно, используйте имя ветки (например, master ):

2. Переключиться на коммит и продолжить работу с него

Если вы хотите продолжить работу с другого коммита, вам понадобится новая ветка. Можно переключиться и создать ее одной командой:

3. Удалить изменения в рабочей области и вернуть ее к состоянию как при последнем коммите.

3.1 Безопасно — с помощью кармана (stash)

3.1.1 Только неиндексированные

Можно удалить прикарманить только те изменения, которые еще не были индексированы (командой add ):

3.1.2 Индексированные и нет

Эта команда отменяет все индексированные и неиндексированные изменения в рабочей области, сохраняя их в карман (stash).

Восстановление несохраненных изменений: легко и просто.

Если stash совсем не нужен, его можно удалить.

После этого восстановить изменения всё ещё можно, но сложнее: How to recover a dropped stash in Git?

3.2 Опасный способ

Восстановление несохраненных изменений: неиндексированные потеряны полностью, но вы можете восстановить то, что было проиндексировано.

4. Перейти к более раннему коммиту в текущей ветке и удалить из нее все последующие (неопубликованные)

Осторожно! Эта команда переписывает историю Git-репозитория. Если вы уже опубликовали ( git push ) свои изменения, то этот способ использовать нельзя (см. почему). Используйте вариант из пункта 5 ( git revert ).

4.1 При этом сохранить изменения в индекс репозитория:

4.2 Сохранить изменения в рабочей области, но не в индексе.

Эта команда просто перемещает указатель ветки, но не отражает изменения в индексе (он будет пустым).

4.3 Просто выбросить изменения.

Осторожно! Эта команда безвозвратно удаляет несохраненные текущие изменения. Если удаляемые коммиты не принадлежат никакой другой ветке, то они тоже будут потеряны.

Восстановление коммитов: Используйте git reflog и этот вопрос чтобы найти и восстановить коммиты; иначе сборщик мусора удалит их безвозвратно через некоторое время.

Восстановление несохраненных изменений: неиндексированные потеряны полностью, но вы можете восстановить то, что было проиндексировано.

5. Отменить уже опубликованные коммиты с помощью новых коммитов

Восстановление: Если revert-коммит оказался ошибочным, используйте этот ответ.

Источник

Как откатиться до определенного коммита? (много гуглил не могу найти ответа)

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

должна же быть команда типа такой:

неужели такого не сделали?

а так же нужно это всё выгрузить на github, хотя при git push система пишет что новых коммитов нет и выгружать нечего, а при попытке создат новый коммит система пишет что новых файлов не обнаружено(

3 ответа 3

Если ситуация такая:

И все это уже отправлено в удаленный репозиторий, то используйте команду git revert.

У вас по сути 2 задачи:

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

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

Чтобы в будущем иметь меньше проблем с git, рекомедую использовать какую либо стратегию версионирования, тот же git feature branching или gitflow позволяют вам работать в своей ветке и делать в ней всё, что необходимо, без влияния на коллег.

Источник

Шпаргалка по Git. Решение основных проблем

Поговорим о решении проблем с Git.

Восстановление накопленных изменений

В том случае, если изменения, внесённые пользователем, находятся в режиме накопления, применить их к ветке можно с помощью команды git stash apply. Также можно запустить git diff — эта команда поможет выявить различия. Для того, чтобы затем избавиться от накопленных данных, нужно запустить команду:

Если существует более одного накопления, найти нужное можно с помощью команды:

git stash list затем можно применить его, воспользовавшись его индексом:

Необходимо учитывать, что отсчёт индексов ведётся от нуля.

Восстановление удалённого тега

В том случае, если необходимо восстановить случайно удалённый тег, начать можно с его поиска:

После того, как нужный тег найден, его следует восстановить:

Восстановление удалённого файла

Если вы случайно удалили файл, его можно быстро восстановить:

Если требуется восстановить файл из конкретной временной точки истории коммитов, следует узнать хеш нужного коммита и запустить команду:

Восстановление удалённой ветки

С помощью комманды git reflog можно узнать хеш (SHA1) последнего коммита в удалённой ветке. Скопируйте этот хеш и используйте в команде:

После этого восстановить удалённую ветку можно будет вот такой командой:

Изменение сообщения коммита перед его отправкой

Сообщение можно изменить и напрямую с помощью команды

Изменение сообщения коммита после его отправки

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

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

Устали каждый раз печатать git status? Этой команде можно присвоить простой алиас, который проще и быстрее вбивать в git.

— теперь нужно писать только git st

Можно пойти дальше и присвоить алиасы более сложным командам:

Теперь алиас git logme будет выводить все наши коммиты.

Коммит в неправильную ветку

Нужно переключиться на новую ветку, которую вы забыли предварительно создать:

А затем переключиться к оригинальной ветке:

. и «откатиться» до последнего коммита, который нужно сохранить.

Чтобы это сделать, можно воспользоваться командой git log и сохранить хеш (SHA1) последнего коммита, который нужно оставить.. Например, это a31a45c.

Предупреждение: Убедитесь в том, что никто не отправлял коммиты в оригинальную ветку во время выполнения вышеописанных процедур, в противном случае эти изменения будут потеряны!

Обновление конкретного подмодуля

Чтобы обновить конкретный подмодуль в репозитории, нужно добавить путь к подмодулю:

Откат к конкретному коммиту в истории

Если вас не очень беспокоят изменения в локальном репозитории, то можно «откатиться» к конкретному коммиту в истории с помощью команды:

Эта команда установит HEAD на конкретный коммит. Также можно воспользоваться хешем коммита.

Отмена коммита до публикации изменений

Если вы сделали коммит, который впоследствии понадобилось отредактировать или полностью стереть, поможет команда git reset.

Будьте осторожны используя второй вариант, поскольку изменения ваших локальных файлов будут потеряны.

Чтобы сохранить сообщение коммита, наберите: :

Отмена коммита после отправки его в master-репозиторий

Рассмотрим процедуру возврата одного или нескольких коммитов, которые нужно стереть из удалённой ветки. Обозначить конкретный коммит можно с помощью его хеша:

Отмена только коммита, который является вторым после последнего:

Простая отмена последнего коммита:

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

Простейшим способом избавиться от нежелательных изменений для файлов и папок является восстановление состояния последнего коммита. Сделать это можно с помощью специальной команды:

Кроме того, можно восстановить конкретный путь к файлу:

Отображение всех коммитов одного файла

Аргумент —follow позволяет вывести все изменения над файлом, даже если в процессе работы он был переименован.

Отображения числа коммитов от каждого участника

Хотите узнать, сколько коммитов сделал каждый участник команды?

Отобразить коммиты, содержащие удалённые файлы

Узнать, в каких коммитах содержатся удалённые файлы, можно с помощью команды:

Она покажет список коммитов, в которых удалялись файлы.

Отсортировать коммиты по автору

Чтобы вывести список коммитов, отфильтрованных по автору, следует воспользоваться следующей командой:

Очистка всех скрытых состояний

Очистить все скрытые состояния можно следующей командой:

Переименование локальной и удалённой ветки

Предложим, у вас есть ветка «fix-bug25», которую вы захотели переименовать в «hotfix-users». Прежде всего, нужно будет изменить локальную ветку:

А затем — удалённую ветку: переименовать её напрямую нельзя, поэтому нужно будет её удалить, и затем опубликовать заново уже с новым именем. Прежде чем приступать к этим процедурам, следует убедиться, что никто из членов команды не работает с этой веткой! Удаляем ветку: git push origin :fix-bug25

А теперь заново публикуем её с новым именем: git push origin hotfix-users

Переименование тега

Чтобы переименовать существующий тег:

Перестать отслеживать существующие файлы

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

Она удалит изменённые файлы из зоны подготовленных файлов (staging area). Затем нужно запустить команду:

и отправить изменения.

Подготовка удалённых файлов

Чтобы подготовить к коммиту файлы и папки, которые были удалены локально, можно использовать специальную команду:

Если требуется подготовить только используемый в данный момент путь, воспользуйтесь командой

Поиск конкретного сообщения во всех коммитах

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

Пометить конфликтующий файл, как разрешённый

Чтобы пометить один или несколько конфликтующих файлов, как разрешённые, чтобы их можно было нормально изменять, воспользуйтесь командой:

Затем можно запустить git commit, чтобы разрешить конфликты и опубликовать изменения.

Просмотр всех неотправленных коммитов

Чтобы просмотреть все коммиты, которые ещё не были отправлены в соответствующие ветки, воспользуйтесь следующей командой:

Кроме того, можно использовать:

Просмотр старой ревизии файла

Существует возможность просмотреть содержимое файла в конкретный момент времени в прошлом. Для этого нужно использовать команду:

Публикация локальной ветки для удалённого редактирования

Если вы создали локальную ветку, и хотите, чтобы другие пользователи могли с ней работать, воспользуйтесь командой:

Теперь они тоже смогут вносить изменения в эту ветку.

Сброс локальной ветки до состояния удалённой

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

Прежде всего нужно получить свежие обновления из удалённой ветки:

А затем нужно сообщить git, что локальную ветку следует «откатить» до состояния удалённой:

Синхронизировать ветку с master-репозиторием

Чтобы синхронизировать последние изменения в репозитории master (или с любой другой веткой, с которой вы работали) необходимо «перебазировать» локальную ветку. Предположим, вы работаете над веткой foobar:

А затем осуществляете «перебазирование»:

После этого будут применены коммиты origin из master. После разрешения конфликтов процесс можно продолжить с помощью команды git rebase —continue. Теперь можно продолжать работу над своей веткой или осуществить её слияние (merge) с главным репозиторием.

Слияние локальных изменений с другой веткой

Это можно сделать прямо в процессе стандартного слияния (merge). Вам стоит сохранить историю слияний используя флаг —no-ff, что означает no fast forward.

Перейдите в ветку, в которую будут вливаться изменения, убедитесь в её актуальности и запустите процесс:

Затем появится сообщение о коммите merge X into Y branch, после чего вы можете смело запушить ваше слияние.>

Совмещение двух и более коммитов

Если есть необходимость в совмещении двух последних коммитов, можно использовать команду

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

Совмещение коммитов по конкретной функции для добавления в ветку релиза

Если вы решите совместить и опубликовать коммиты, то возникнет новый коммит в ветке релиза, поэтому история ветки конкретной функции останется неизменной.

Ниже представлен пример того, как достичь подобного эффекта:

В конечном итоге останется только один коммит в ветке релиза, а история изменений в ветке разработки конкретной функции останется нетронутой.

Создание новой ветки с изменениями текущей

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

Эта команда перенесёт файлы из текущей ветки в новую, которую потом уже можно «закоммитить».

Убрать файл из буфера

Чтобы убрать добавленный по ошибке файл из буфера, нужно воспользоваться простой командой:

Удаление внешней ветки

Если вы хотите удалить ветку, введите команду:

Удаление неотслеживаемых файлов и папок

Чтобы удалить неотслеживаемые файлы и папки из рабочей копии наберите следующую команду:

Чтобы в принципе удалить их:

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

Удаление старых веток, стёртых из внешнего репозитория

Если ветка удалена из внешнего репозитория, её также можно стереть из локального репозитория с помощью команды

Она удалит старую ветку под названием название-удалённой-ветки, которая уже была стёрта из внешнего репозитория, но всё ещё доступна локально в remotes/название-удалённой-ветки.

Удаление файла из git с сохранением его локальной копии

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

Без Гита и жизнь не та

Получите практику в Git на курсах HTML Academy. Мы расскажем всё, что знаем сами, чтобы вы прокачали навыки в веб-разработке.

Источник

Откат коммитов на GitHub

April 07, 2015

Небольшая статья, посвященная вопросу отката коммитов в GitHub.

В чем заключается вопрос, собственно? В том, что имеется определенный репозиторий, размещенный на сервере GitHub. У этого удаленного репозитория есть локальная синхронизированная версия на рабочей машине автора. Этот репозиторий изменяется с большей или меньшей периодичностью; все изменения фиксируются соответствующими коммитами.

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

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

Шаг первый

Шаг второй

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

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

Шаг третий

Заключение

Источник

Git: вернуться к предыдущему коммиту

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

Удалить неопубликованные коммиты

Если вы еще не опубликовали свои коммиты в удаленном репозитории, таком как GitHub, вы можете по существу удалить предыдущие коммиты с помощью команды reset.

Команда reset имеет три различных параметра, два из которых мы опишем здесь:

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

Это означает, что с помощью этой команды вы не только вернетесь к предыдущей фиксации, но и потеряете все рабочие изменения в процессе. Чтобы не потерять какие-либо рабочие изменения, вы можете использовать команды stash и stash pop:

Команда stash сохраняет ваши рабочие изменения (без каких-либо комитов или изменений в дереве), а затем stash pop возвращает их обратно.

Удаление опубликованных коммитов

Допустим, вы зафиксировали свой код, а затем отправили его в удаленный репозиторий. На этом этапе настоятельно рекомендуется не использовать что-то вроде git reset, поскольку вы переписываете историю.

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

Допустим, в вашем репозитории есть текстовый файл со следующим содержанием

И вы изменяете его на:

Ваша история коммитов может выглядеть примерно так:

Если мы решили, что нам больше ненужно слово «awesome» в нашем тексте, но мы не хотим удалять коммит 676ec, мы можем использовать revert, чтобы отменить это изменение:

Получив приглашение ввести сообщение о коммите, мы теперь можем видеть в нашей истории коммитов, что фактически существует новый коммит:

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

Обратите внимание, что есть несколько других способов использовать эту команду, например, если вы хотите вернуть обратно 2 коммита, вы можете использовать:

Или, если вы хотите отменить много непостоянных коммитов, вы указываете их индивидуально:

Временно оформить предыдущий коммит

«Отмена фиксации» означает, что вы временно хотите вернуться к предыдущему состоянию в своем репозитории, но без внесения каких-либо реальных изменений в дерево. В этом случае вы, вероятно, просто захотите проверить фиксацию, что позволит вам вернуться к мастеру или любому другому состоянию, когда вы закончите:

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

Источник

Как это отменить?! Git-команды для исправления своих ошибок

Если вы ошиблись в Git’е, разобраться, что происходит и как это исправить, — непростая задача. Документация Git — это кроличья нора, из которой вы вылезете только зная конкретное название команды, которая решит вашу проблему.

Рассказываем о командах, которые помогут вам выбраться из проблемных ситуаций.

Вот блин, я сделал что-то не то… У Git ведь есть машина времени?!

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

Я только что сделал коммит и заметил, что нужно кое-что поправить!

Внимание Никогда не изменяйте коммиты в публичной ветке. Используйте эту команду только для коммитов в локальной ветке, иначе вам конец.

Мне нужно изменить сообщение последнего коммита!

Тупые требования к оформлению сообщений…

Я случайно закоммитил что-то в мастер, хотя должен был в новую ветку!

Команды не сработают, если вы уже закоммитили в публичную ветку. В таком случае может помочь git reset HEAD@ <какое-то-количество-коммитов-назад>вместо HEAD

Ну отлично. Я закоммитил не в ту ветку!

Я пытаюсь запустить diff, но ничего не происходит

Если вы знаете, что изменения были внесены, но diff пуст, то возможно вы индексировали изменения (через add ). Поэтому вам нужно использовать специальный флаг.

Конечно, «это не баг, а фича», но с первого взгляда это чертовски неоднозначно.

Мне нужно каким-то образом отменить коммит, который был сделан 5 коммитов назад

Помимо этого, откатить можно не целый коммит, а отдельный файл. Но следуя канону Git’а, это будут уже совсем другие команды…

Мне нужно отменить изменения в файле

Именно поэтому checkout — лучший инструмент для отката изменений в файлах.

Давай по новой, Миша, всё х**ня

Если вам нужно полностью откатиться до исходной версии (т. е. отменить все изменения), то можете попробовать сделать так.

Будьте осторожны, эти команды разрушительны и необратимы.

Эти команды Git нужны для экстренных ситуаций, но пригодиться могут не только они. Про другие команды с пояснениями писали тут:

Источник

Что такое коммит git? Как вернуться (откатиться) к более раннему коммиту?

Git — это виртуальная систем а управления версией исходного кода программы. С помощью Git можно создавать «контрольные точки» в разработке. Например, над программой работают несколько разработчиков какое-то время. Появились первые результаты, которые удовлетворяют требования к программе, тогда их фиксируют. Далее над программой продолжается работа. Если что-то пошло не так, тогда всегда есть возможность вернуться в «контрольную точку» и продолжать работать над программой. Если изменения всех устраивают, тогда фиксируют следующую «контрольную точку» и т. д. Таким образом появляется ветвь развития программы с «контрольными точками», к которым всегда можно вернуться.

Благодаря Git, над программами можно экспериментировать. Например, с определенной «контрольной точки» можно развивать несколько ветвей программы с различным экспериментальным функционалом, а потом выбрать что лучше.

Что такое коммит в Git?

Когда над программой ведется активная работа, коммиты создаются довольно часто. Среди разработчиков ходит негласное правило, что в один коммит добавляют до 10 важных изменений программы, но в каждой команде цифра изменений может быть разная. Из-за небольшого количества вносимых изменений коммитов получается много. Однако такое положение нужно для того, чтобы всегда была возможность откатить изменения до последнего работающего коммита с минимальными потерями в коде. К примеру, если вносить по 100 изменений в один коммит и на каком-то этапе обнаружить о ш ибку в программе, тогда нужно будет откатить Git-комит и потерять сразу 100 изменений, а если в коммите содержатся только по 10 изменений, тогда будет потеряно только 10.

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

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

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

Git: откатить изменения до работающего коммита

На самом деле, откатить коммит в Git — это не совсем простая задача. Вернее она может быть простой в определенных ситуациях, например, когда вы работаете над программой самостоятельно и от вашего коммита зависит только ваша работа. Таким образом вы легко можете удалять, добавлять, откатывать коммиты — всё это происходит исключительно под вашим контролем. Сложнее в Git откатить изменения до какого-то коммита, когда над программой работают несколько разработчиков в нескольких ветках и каждый ваш коммит может быть использован другими разработчиками. В общем, ситуации могут быть разными, поэтому будьте осторожны и внимательны. А мы покажем как можно откатиться к коммиту несколькими способами, а вы уже выберите тот, который подходит именно вам.

Удаляем неопубликованные коммиты

Этот способ вам подойдет, если вы пока еще не опубликовали коммиты в репозитории, например в GitHub. Для этого действия используется простая команда:

Работать с этой командой нужно осторожно, потому что она безвозвратно удаляет неопубликованные коммиты и можно потерять что-то стоящее, из того что было в коде. Если вы не до конца уверены, что хотите полностью удалить неопубликованный коммит или просто хотите пока сохранить новые изменения, чтобы потом их доработать, если что, тогда воспользуйтесь более щадящей командой:

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

Удаляем опубликованные коммиты

Может быть такая ситуация, что вы внесли изменения в код и отправили их в GitHub. В этом случае, если использовать команду «reset», тогда можно нарваться на большие неприятности, потому что с помощью этой команды переписывается история. Не будем вдаваться в подробности, но скажем, что вам это не нужно

В данном случае лучше воспользоваться командой:

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

Временно откатить коммит в Git

Для этого используется команда:

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

Заключение

Сегодня мы вас познакомили с коммитами в Git. Теперь вы знаете, что коммит в Git — это «контрольная точка», к которой вы можете всегда вернуться и продолжить работу над программой именно с нее.

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

Мы будем очень благодарны

если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.

Источник

Машина времени в git

В последнее время мои коллеги начинают знакомство с git’ом. И один из интересующих их вопросов — как откатиться до определённой ревизии. В интернете можно найти набор команд, но хочется, чтобы было понимание каждой из них. Баловство с комадами git’а без понимания может привести к потере истории разработки.

Здесь кружочками обозначены коммиты. Чем правее коммит, тем он новее. Коммит с хэшем 6e04e..-это самый первый коммит. Одно из основных понятий, которое стоит уяснить себе новичку, — это указатели на коммиты, а точнее некоторое «прозвище» того или иного коммита. Их тьма тьмущая, например: HEAD, master, FETCH_HEAD, ORIG_HEAD и т.д. Это я перечислил крупицу стандартных прозвищ. Их можно создавать и самим, но об этом впереди.

Заострим наше внимание на двух указателях: master и HEAD. master указывает на самый старший коммит в ветке под названием master (эта ветка создаётся при инициализации репозитория). HEAD указывает на указатель master (читай, текущее состояние файлов). После появления первого коммита в репозитории, HEAD и master указывают на один и тот же коммит. И так будет продолжать до тех пор, пока не переключимся на другую ветку, не откатимся по истории, либо не совершим ряд необдуманных действий. Итак, проиллюстрируем нашу историю с указателями:

Перенос указателя HEAD ( git checkout )

Откат по истории коммитов:

Неужели мы потеряли всю историю? Как узнать самый «новый» коммит? Это не проблема — есть выход, и их несколько:

Для прояснения механизма git checkout создадим новую ветку devel:

Заметим, что указатель HEAD указывает на вершину ветки devel.

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

Возвращение в ветку master происходит также безболезненно:

2 :

2 :

ORIG_HEAD полезен для редактирования неверных коммитов на локальной машине (!). Предположим, что мы хотим объединить два последних коммита в единый. Для этого, сохраняя текущее состояние файлов, переводим указатель master на два коммита назад:

Посмотрим на изменения:

Ну а теперь сделаем трюк — объединяем коммиты

Вводим сообщение, сохраняемся. Теперь наша история выглядит вот так:

Важное замечание — ORIG_HEAD по-прежнему указывает на коммит d79fb… Если мы сейчас выполним команду git checkout ORIG_HEAD, то мы получим так называемое состояние detach HEAD. Оно характеризуется тем, что HEAD указывает не на вершину ветки, а просто на коммит. HEAD всегда должен указывать только на вершину какой-либо ветки!

Удачных вам путешествий по истории своего репозитория!

При подготовке материала использовались следующие источники:
Самый лучший manual — книга: ProGit
Наглядная справка по git: A Visual Git Reference (Русская версия)

UPD:
В комментариях посоветовали ещё один полезный ресурс по git`у: githowto

Источник

Артём Саннников

Блог о программировании

Языки программирования

Формат данных

Базы данных

Программное обеспечение

Операционные системы

Мобильная разработка

Менеджеры пакетов

Сетевые технологии

CMS системы

Математика

SEO продвижение

Социальные сети

Психология

Хостинг провайдер

Смартфоны

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

Откат в предыдущее состояние можно осуществить двумя способами:

1. Отменяет все коммиты после заданного, оставляя все изменения в рабочей директории.

2. Сбрасывает всю историю вместе с состоянием рабочей директории до указанного коммита.

Практический пример

Перейдём в существующий репозиторий и выведем всю историю коммитов в текущей ветке при помощи команды git log.

Есть два коммита: первый (Create README.md) и второй (Edit README.md)

В нашем случае мы произведем откат к коммиту (Create README.md).

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

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

Источник

Как отменить коммит в Git

Иногда случаются ситуации, что вы закомитили что-то не то, не туда или не так. Такой коммит надо удалить или отменить. В этой небольшой статье мы рассмотрим как отменить коммит Git. Обратите внимание, что если вам надо внести изменения, то коммит не обязательно отменять, можно его поправить. Но об этом в следующей статье.

Как отменить коммит в Git

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

Команда вернет список коммитов с их описанием и идентификаторами (хешами), которые можно использовать для того чтобы посмотреть подробную информацию о коммите с помощью команды show. По умолчанию команда показывает изменения в последнем коммите:

Теперь можно использовать идентификатор коммита для того чтобы его отменить.

1. Отменить коммит, но оставить изменения

. Таким образом ссылка на предыдущий коммит будет выглядеть как HEAD

или HEAD

2 и так далее. Для отмены последнего коммита достаточно выполнить команду:

Как видите, все файлы сохранились, а если посмотреть отличия HEAD и текущего состояния проекта, то будет видно, добавление файла file3:

Аналогичного результата можно добиться, передав идентификатор коммита, например, давайте отменим коммит, добавляющий file2. Для этого посмотрите идентификатор коммита перед ним, в данном случае, это «Inital Commit» с помощью следующей команды:

А затем передайте его в команду git reset. Например:

И снова все файлы на месте, а в HEAD теперь будет добавлено два файла: file2 и file3:

Таким образом вы можете отменить несколько коммитов за раз, надо только указать идентификатор самого раннего коммита.

Обратите внимание, что файлы, которые ранее были в коммите, сейчас всё ещё добавлены в индекс, поэтому вам не надо вызывать git add, можно сразу создавать новый коммит. Но у команды reset есть ещё одна опция: —mixed. Она используется по умолчанию. При использовании этой опции ваши изменения тоже сохраняются, но перед следующим коммитом их снова надо будет добавить в индекс с помощью git add. При выполнении команды git status эти файлы будут отображаться как не отслеживаемые:

2. Отменить коммит и удалить изменения

Отмена коммита git с удалением изменений работает аналогично. Только здесь необходимо вместо опции —soft указывать опцию —hard. Например, при той же структуре коммитов, можно удалить последний коммит с добавлением файла file3 вместе с этим файлом:

Теперь файла нет. Аналогично, вы можете указать идентификатор коммита, до которого надо отменить коммиты. Обратите внимание, что указывается не тот коммит, который надо отменить, а коммит перед ним. Ещё важно отметить, что это всё работает пока вы не отправили свои коммиты в удалённый репозиторий. Если коммиты уже отправлены, их идентификаторы сохранены там, а поэтому менять их нельзя, иначе могут возникнуть конфликты слияния, которые будет сложно решить. Теперь вы знаете отменить последний локальный коммит git.

3. Как вернуть отмененный коммит

Аналогично можно использовать адрес:

Срок хранения удалённых коммитов ограничен. Время от времени git удаляет мусор, так что если ждать слишком долго, то нужных данных уже может и не быть. Но найти удалённые коммиты, если git их ещё не удалил можно с помощью такой команды:

Затем просто используйте идентификатор коммита для того чтобы посмотреть какие в нём были изменения:

git show 8a996dd76fbacb05a2df91c0f2d19b1a3afd8451

Затем можно переключиться на этот коммит с помощью команды:

git rebase 8a996dd76fbacb05a2df91c0f2d19b1a3afd8451

Это всё тоже безопасно делать только с коммитами, ещё не отправленными в удалённый репозиторий.

4. Отменить изменения но не отменять коммит

Если вы уже отправили коммит в удалённый репозиторий, удалять его не желательно, потому что если кто-то успеет скачать репозиторий до отмены коммита, то потом у него возникнут проблемы. Однако изменения, сделанные в коммите можно отменить новым коммитом. Для того чтобы не делать это вручную существует специальная команда revert. Её уже нужно передать идентификатор именно того коммита, изменения из которого надо отменить. Для этого сначала найдите хэш коммита:

Затем выполните команду revert, например:

git revert 8a996dd76fbacb05a2df91c0f2d19b1a3afd8451

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

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

Выводы

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

Источник

Git. Урок 4.
Перемещение курсора и отмена изменений. Команды git restore, git rm, git reset, git checkout, git commit, git revert.

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

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

Когда мы делаем файл отслеживаемым или подготавливаем его к коммиту, информация об этом файле записывается в индекс (файл .git/index ). Эта информация никуда не денется, даже если мы удалили файл из рабочей копии. Рассмотрим пример. Допустим, мы выполним следующие действия:

1. Создадим файл sample.txt и внесем в него какие-то изменения;
2. Сделаем его отслеживаемым;
3. Удалим файл sample.txt ;
4. Сделаем коммит;

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

В Git существует специальная команда, чтобы удалять файлы «правильно».

Команда git rm

—cached
С этим ключом команда очистит только информацию о файле в индексе. Сам файл в рабочей копии останется нетронутым, независимо от того, изменен он или нет. При этом файл из области «подготовленный к коммиту» (англ. staged ) перейдет в область «неотслеживаемый» (англ. untracked ).

Команда git restore

— worktree (англ. рабочая копия)
—staged (англ. область индекса)

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

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

Подведем итог

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

позволяет вам указать число коммитов. Например, запись HEAD

7 означает «7 коммитов назад от коммита, на который указывает HEAD «.

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

Команда git checkout

2
HEAD is now at 7194f7e L-04: Fixing gradient bug

2.1. История выводится не полностью

2.2. Как переключиться обратно

2.3. Зачем может понадобиться переключать указатель на старые коммиты, и важные особенности состояния «detached head».

На самом деле, все зависит от конкретной задачи и проекта, над которым вы работаете. Вообще состояние detached head на практике используется довольно-таки редко. Но все же можно привести несколько примеров использования этого состояния:

Пример 1
Самый банальный пример – просмотр файлов в определенном коммите. Допустим, вы хотите просмотреть содержимое файла main.py в коммите с определенным хэшем.
Просто выполните:

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

Пример 2
Кроме того, когда вы работаете над большим проектом, может быть нужно вернуться на несколько коммитов назад и создать свою ветку оттуда: например, чтобы протестировать экспериментальную функцию в том состоянии проекта. Сделать это можно так:

Поэтому с состоянием detached head следует быть очень осторожным: если забыть создать новую ветку и начать делать коммиты, их можно с легкостью потерять.

На самом деле, если вы сделали несколько коммитов из состояния detached head и забыли создать ветку, ничего страшного: ветку можно создать прямо сейчас. Рассмотрим пример с тем же репозиторием:

Суть работы данной команды в том, что она создает новый коммит, который отменяет изменения внесенные в переданном коммите (последовательности коммитов).

Команда git revert

-n
Не делает коммит. С данным ключом изменения коснутся только рабочей копии.

—abort
Данный ключ используется только при разрешении конфликтов.
Прерывает выполнение команды после разрешения конфликтов.

—continue
Данный ключ используется только при разрешении конфликтов.
Продолжает выполнение команды после разрешения конфликтов.

2

# Отменим все изменения в коммитах, начиная с пятого с конца и заканчивая вторым с конца.
$ git revert HEAD

Иногда при отмене изменений может возникнуть ситуация, когда в файл в рабочей копии были внесены изменения с момента коммита находится не в том же состоянии, как в коммите, который мы отменяем. Звучит сложно, поэтому давайте приведем пример. Допустим, у нас есть следующий репозиторий.

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

Подведем итог

Команда git reset

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

—hard
С этим ключом команда удалит все изменения так, чтобы состояние индекса и рабочей копии полностью соответствовали коммиту, к которому мы сделали reset

3
HEAD is now at 2f96b73 L-04: Create main.py

Кстати, если мы сейчас сделаем коммит:

4.1. Редактирование или отмена последнего коммита

Команда git commit

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

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

—amend
С этим ключом коммит будет объединен с последним коммитом на текущей ветке. Этот ключ используется для редактирования содержимого и сообщения последнего коммита.

4.2. Объединение нескольких коммитов в один.

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

4.3. Удаление последних нескольких коммитов.

4.4. Отмена изменений команды git reset.

Изученные команды

В случае, если вы не передали ссылку, вместо нее будет подставлен HEAD. То есть она обновит индекс так, чтобы он соответствовал коммиту, на который указывает HEAD. Иначе говоря, скопирует файл из HEAD в индекс. То есть ее действие противоположно git add : она отменит добавление файла в индекс.

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

Источник

Команды reset, checkout и revert

Переключение версий (команда checkout) перемещает указатель HEAD на указанный коммит. Покажем это на следующем примере.

Это обновление дерева «истории коммитов». Команду git checkout можно использовать на уровне коммита или файла. При переключении на уровне файла его содержимое будет отражать состояние при конкретном коммите.

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

Операция сброса (команда reset) принимает в качестве аргумента коммит и сбрасывает «три дерева» до состояния репозитория при указанном коммите. Ее можно выполнить в трех разных режимах, соответствующих трем деревьям.

Команды checkout и reset обычно используются для локальных или частных отмен. Эти команды изменяют историю репозитория, что может вызвать конфликты при отправке в удаленные общие репозитории. Команда revert считается безопасной операцией для публичных отмен, поскольку добавляет в историю новые данные, которыми можно делиться удаленно, а не перезаписывает старые, от которых могут зависеть участники команды.

Справка по различиям git reset, git revert и git checkout

В таблице ниже приведены наиболее распространенные сценарии использования всех этих команд. Обязательно держите ее под рукой для справки, поскольку вам, несомненно, придется использовать хотя бы некоторые из этих сценариев при работе с Git.

Операции на уровне коммитов

Сброс до конкретного коммита

На уровне коммитов команда reset позволяет перенести конец ветки на другой коммит. Таким образом можно удалить коммиты из текущей ветки. Например, следующая команда перемещает ветку hotfix на два коммита назад.

Команда git reset — это простой способ отменить изменения, которые еще никто не получал. Она прекрасно подойдет в случае, когда вы начали работать над функцией и вдруг подумали: «Ой, ну что я делаю? Лучше начать все сначала».

Помимо перемещения текущей ветки, с помощью команды git reset можно также изменить снимок состояния индекса и (или) рабочий каталог, передав ей один из следующих флагов:

Переключение на старые коммиты

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

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

Отмена публичных коммитов с помощью команды revert

При использовании команды revert коммит отменяется путем создания нового коммита. Это безопасный способ отменить изменения, поскольку при нем невозможно перезаписать историю коммитов. Например, следующая команда определит изменения, содержащиеся во втором с конца коммите, создаст новый коммит, в котором эти изменения будут отменены, и добавит его к проекту.

Выглядит это следующим образом:

Или можно рассматривать git revert как инструмент для отмены изменений, попавших в коммиты, в то время как команда git reset HEAD предназначена для отмены изменений, не попавших в коммиты.

Операции на уровне файлов

Команды git reset и git checkout также могут принимать путь к файлу в качестве необязательного параметра. Это резко меняет их поведение. Вместо того чтобы действовать на снимки состояния целиком, их работа будет ограничена одним файлом.

git reset для определенного файла

При вызове с указанием пути к файлу команда git reset обновляет снимок состояния индекса, чтобы он соответствовал версии из указанного коммита. Например, следующая команда получит версию foo.py во втором с конца коммите и занесет ее в индекс для следующего коммита:

git checkout для файла

Например, после выполнения следующей команды файл foo.py в рабочем каталоге будет совпадать с его версией из второго коммита с конца:

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

Если вы выполните индексирование и коммит для файла, на который переключились, это приведет к восстановлению старой версии файла. Обратите внимание, что при этом удаляются все последующие изменения в файле, тогда как команда git revert отменяет только изменения, внесенные указанным коммитом.

Резюме

Источник

Раскрытие тайн reset

Три дерева

Разобраться с командами reset и checkout будет проще, если считать, что Git управляет содержимым трёх различных деревьев. Здесь под «деревом» мы понимаем «набор файлов», а не специальную структуру данных. (В некоторых случаях индекс ведет себя не совсем так, как дерево, но для наших текущих целей его проще представлять именно таким.)

В своих обычных операциях Git управляет тремя деревьями:

Снимок последнего коммита, родитель следующего

Снимок следующего намеченного коммита

Указатель HEAD

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

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

Команды cat-file и ls-tree являются «служебными» (plumbing) командами, которые используются внутри системы и не требуются при ежедневной работе, но они помогают нам разобраться, что же происходит на самом деле.

Индекс

Git заполняет индекс списком изначального содержимого всех файлов, выгруженных в последний раз в ваш рабочий каталог. Затем вы заменяете некоторые из таких файлов их новыми версиями и команда git commit преобразует изменения в дерево для нового коммита.

Технически, индекс не является древовидной структурой, на самом деле, он реализован как сжатый список (flattened manifest) — но для наших целей такого представления будет достаточно.

Рабочий Каталог

Технологический процесс

Основное предназначение Git — это сохранение снимков последовательно улучшающихся состояний вашего проекта, путём управления этими тремя деревьями.

На данном этапе только дерево Рабочего Каталога содержит данные.

Теперь мы хотим закоммитить этот файл, поэтому мы используем git add для копирования содержимого Рабочего Каталога в Индекс.

Теперь мы хотим внести изменения в файл и закоммитить его. Мы пройдём через всё ту же процедуру; сначала мы отредактируем файл в нашем рабочем каталоге. Давайте называть эту версию файла v2 и обозначать красным цветом.

Сейчас команда git status не показывает ничего, так как снова все три дерева одинаковые.

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

Назначение команды reset

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

В следующих примерах предположим, что мы снова изменили файл file.txt и закоммитили его в третий раз. Так что наша история теперь выглядит так:

Шаг 1: Перемещение указателя HEAD

Шаг 2: Обновление Индекса (—mixed)

), выполнение команды также остановится на этом шаге.

Шаг 3: Обновление Рабочего Каталога (—hard)

Резюме

Команда reset в заранее определённом порядке перезаписывает три дерева Git, останавливаясь тогда, когда вы ей скажете:

Делает Рабочий Каталог таким же как и Индекс.

Reset с указанием пути

Перемещает ветку, на которую указывает HEAD (будет пропущено)

Делает Индекс таким же как и HEAD (остановится здесь)

То есть, фактически, она копирует файл file.txt из HEAD в Индекс.

Именно поэтому в выводе git status предлагается использовать такую команду для отмены индексации файла. (Смотрите подробности в Отмена индексации файла.)

Слияние коммитов

Давайте посмотрим, как, используя вышеизложенное, сделать кое-что интересное — слияние коммитов.

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

Затем просто снова выполните git commit :

Сравнение с checkout

Без указания пути

Второе важное отличие заключается в том, как эти команды обновляют HEAD. В то время как reset перемещает ветку, на которую указывает HEAD, команда checkout перемещает сам HEAD так, чтобы он указывал на другую ветку.

Итак, в обоих случаях мы перемещаем HEAD на коммит A, но важное отличие состоит в том, как мы это делаем. Команда reset переместит также и ветку, на которую указывает HEAD, а checkout перемещает только сам HEAD.

С указанием пути

Заключение

Ниже приведена памятка того, как эти команды воздействуют на каждое из деревьев. В столбце «HEAD» указывается «REF» если эта команда перемещает ссылку (ветку), на которую HEAD указывает, и «HEAD» если перемещается только сам HEAD. Обратите особое внимание на столбец «Сохранность РК?» — если в нем указано NO, то хорошенько подумайте прежде чем выполнить эту команду.

Источник

Отмена коммитов — Введение в Git

Что делать, если коммит уже сделан, но он нас по каким-то причинам не устраивает? Ситуаций может быть много, и все они возникают регулярно даже у профессиональных разработчиков:

Git по большей части система «только вперёд». Правильный подход при работе с гитом — создание нового, а не изменение старого. Все ситуации, описанные выше, можно решить новым коммитом, изменяющим код в нужном направлении. Это не только удобно, но и безопасно. Изменение истории коммитов — операция опасная и чревата проблемами при синхронизации с удалёнными репозиториями. Об этом мы поговорим позже.

Несмотря на сказанное выше, внутри git существуют специальные команды, позволяющие упростить отмену, либо изменение коммита. С их помощью можно сделать историю коммитов понятной, а сам процесс «отката» быстрым.

Git revert

Самая простая ситуация — отмена изменений. Фактически она сводится к созданию ещё одного коммита, который выполняет изменения противоположные тому коммиту, который отменяется. Руками создавать подобный коммит довольно сложно, поэтому в git добавили команду, автоматизирующую откат. Эта команда называется git revert :

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

Git reset

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

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

git reset — мощная команда, имеющая множество различных флагов и способов работы. С её помощью удаляются или отменяются (без удаления) коммиты, восстанавливаются файлы из истории и так далее. Работа с ней относится к продвинутому использованию git, здесь же мы затрагиваем только самую базу.

означает «один коммит от последнего коммита». Если бы мы хотели удалить два последних коммита, то могли бы написать HEAD

HEAD (голова) — так обозначается последний сделанный коммит. Подробнее эту терминологию мы разберем в уроке, посвященном внутреннему устройству git.

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

Самостоятельная работа

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.

Источник

Откатить уже опубликованный коммит и опубликовать новый, не вызывая мержа у других

Предположим, я сделал коммит X и опубликовал его на удаленный репозиторий ( git push ). Все, у кого есть доступ к репозиторию обновились.

Как этого избежать?

2 ответа 2

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

Если вы абсолютно уверены, что вы запушили «лишний» коммит в собственную ветку, что её никто не замержил в стабильную ветку и просто так не начал разработку от последнего вашего коммита, можно откатить локальную ветку к предыдущему коммиту, а потом переписать изменения в удалённой (подробнее тут, пункт 4.2)

Если это категорически необходимо, обязательно и сразу же предупредите всех, кто работает с этим репозиторием. После переписывания последнего коммита в стабильной ветке им придётся вручную обновлять эту ветку на своей машине. Если у них есть какие-то новые коммиты, предком которых является удаляемый коммит, им придётся делать rebase на коммит.

Вот вам моя любимая схема, иллюстрирующая разные варианты решения.

Источник

30 команд Git, необходимых для освоения интерфейса командной строки Git

Git — самая популярная в мире распределённая система контроля версий. Линус Торвальдс, разработчик ядра ОС Linux, создал этот инструмент ещё в 2005 году, а сегодня Git активно поддерживается как проект с открытым исходным кодом. Огромное количество открытых и коммерческих проектов используют Git для контроля версий.

В данной статье перечисляются самые основные команды, которые следует знать разработчику, чтобы освоить управление репозиториями GitHub на высоком уровне. Ознакомиться с ними будет полезно как новичкам, так и опытным разработчикам.

30 основных команд, которые сделают из вас мастера Git

1. Как задать имя пользователя и адрес электронной почты

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

2. Кэширование учётных данных

3. Инициализация репозитория

4. Добавление отдельных файлов или всех файлов в область подготовленных файлов

Добавить отдельный файл в область подготовленных файлов можно параметром add с указанием имени файла. Просто замените somefile.js на актуальное имя.

5. Проверка статуса репозитория

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

6. Внесение изменений однострочным сообщением или через редактор

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

7. Просмотр истории коммитов с изменениями

8. Просмотр заданного коммита

Также можно использовать сокращённый хеш.

9. Просмотр изменений до коммита

Также можно указать имя файла как параметр и просмотреть изменения, внесённые только в этот файл.

10. Удаление отслеживаемых файлов из текущего рабочего дерева

Можно также использовать маски файлов (например *.js) для удаления всех файлов, соответствующих критерию.

11. Переименование файлов

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

12. Отмена подготовленных и неподготовленных изменений

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

13. Изменение последнего коммита

Внимание! Не изменяйте публичные коммиты.

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

14. Откат последнего коммита

▍ Разница между revert и reset

У команды revert есть два крупных преимущества по сравнению с reset. Во-первых, она не меняет историю проекта и производит операцию, безопасную для коммитов. Во-вторых, её объектом выступает конкретный коммит, созданный в любой момент истории, а git reset всегда берёт за точку отсчёта текущий коммит. К примеру, если нужно отменить старый коммит с помощью git reset, придётся удалить все коммиты, поданные после целевого, а затем выполнить их повторно. Следовательно, команда git revert — гораздо более удобный и безопасный способ отмены изменений.

15. Откат заданного коммита

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

16. Создание новой ветки и переход в неё

17. Просмотр списка веток

18. Удаление ветки

Вышеуказанные команды удаляют только локальную копию ветки. В удалённом репозитории она может сохраниться. Если хотите стереть удалённую ветку, выполните следующую команду:

19. Слияние двух веток

Объединить две ветки можно параметром merge с указанием имени ветки. Команда объединит указанную ветку с основной.

Указанная команда объединит заданную ветку с основной и произведёт коммит слияния. Это необходимо для фиксации всех слияний в вашем репозитории.

20. Отображение журнала фиксации в виде графика для текущей или всех веток

21. Прекращение слияния при конфликте

22. Добавление удалённого репозитория

23. Просмотр удалённых URL-адресов

24. Получение дополнительных сведений об удалённом репозитории

Эта команда отображает список веток, связанных с удалённым репозиторием, а также рабочих станций, подключённых для получения и отправки файлов.

25. Отправка изменений в удалённый репозиторий

Отправлять изменения в удалённый репозиторий можно параметром push с указанием имени репозитория и ветки.

Эта команда передаёт локальные изменения в центральный репозиторий, где с ними могут ознакомиться другие участники проекта.

26. Получение изменений из удалённого репозитория

27. Слияние удалённого репозитория с локальным

Слияние удалённого репозитория с локальным выполняется параметром merge с указанием имени удалённого репозитория.

28. Отправка новой ветки в удалённый репозиторий

29. Удаление удалённой ветки

30. Использование перебазирования

Для доступа к этой функции используйте параметр rebase с указанием имени ветки. Перебазирование — это процесс объединения или перемещения последовательности коммитов на новый родительский снимок.

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

▍ Спасибо за внимание!

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

Источник

moByz/git_commands

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

Система контроля версий Git

Исправление предыдущего коммита

Получение изменений из другой ветки (подмодули)

About

Resources

Stars

Watchers

Forks

Releases

Packages 0

Footer

© 2022 GitHub, Inc.

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.

Источник

git reset

Git reset и три дерева Git

Начнем работу с создания нового репозитория с помощью приведенных ниже команд.

Рабочий каталог

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

Раздел проиндексированных файлов

Далее мы добавим измененный файл reset_lifecycle_file в раздел проиндексированных файлов.

История коммитов

Последнее дерево — история коммитов. Команда git commit добавляет изменения в постоянный снимок, который находится в истории коммитов. Этот снимок также включает состояние раздела проиндексированных файлов на момент выполнения коммита.

Порядок действий

git checkout b

git reset b

Основные параметры

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

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

—mixed

Это режим работы по умолчанию. Указатели ссылок обновляются. Раздел проиндексированных файлов сбрасывается до состояния указанного коммита. Любые изменения, которые были отменены в разделе проиндексированных файлов, перемещаются в рабочий каталог. Давайте продолжим.

Теперь давайте мягко сбросим текущее состояние репозитория.

Прежде чем вернуться назад во времени, проверим текущее состояние репозитория.

Чтобы выяснить, что произошло при этом сбросе, выполним команду git log:

Разница между командами git reset и git revert

Команда revert предназначена для безопасной отмены публичных коммитов, а git reset — для отмены локальных изменений в разделе проиндексированных файлов и рабочем каталоге. Поскольку они предназначены для разных целей, их реализация также различается: команда reset полностью удаляет набор изменений, тогда как команда revert оставляет исходный набор изменений и использует новый коммит для применения отмены.

Не используйте reset в публичной истории

При удалении коммита, после которого другие участники команды начали работу, могут возникнуть серьезные проблемы. Когда коллеги попытаются синхронизироваться с вашим репозиторием, часть истории проекта будет просто отсутствовать. На следующей схеме показано, что происходит при использовании команды reset для публичного коммита. Ветка origin/main является версией вашей локальной главной ветки main в центральном репозитории.

Примеры

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

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

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

Удаление файла из раздела проиндексированных файлов

Как видите, команда git reset помогает соблюдать согласованность коммитов, позволяя не вносить изменения, которые не связаны со следующим коммитом.

Удаление локальных коммитов

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

Команда git reset HEAD

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

Резюме

Готовы изучить git reset?

Ознакомьтесь с этим интерактивным обучающим руководством.

Источник

Git как откатиться к коммиту

Copy raw contents

Базовые операции с Git

Тут рассмотрено несколько типичных операций, которые нужно уметь делать с Гитом. Перед прочтением лучше ознакомиться с ссылками в предыдущей статье на девмане: пройти туториал гитхабе и прочитать пару глав Git-book’a.

Подтянуть чужие изменения

Утро, ты пришёл на работу. Как к локальной версии исходного кода добавить те изменения,
которые коллеги сделали вчера?

Для работы с удалёнными репозиториями используем fetch, merge и pull:
$ git fetch server_branch # изъять данные из другой ветки
$ git merge server_branch # слить другую ветку в текущую рабочую

$ git pull server_branch master # два действия одной командой

Поделиться своими изменениями с коллегами

Ну вот, ты поработал. Теперь нужно поделиться своим кодом с другими. Как?

Используем git push:
$ git push origin master

Также важно понимать, почему нежелательно делать push с форсом!

Разобраться с конфликтами

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

В PyCharm можно выполнять данные операции удобнее и нагляднее чем в консоли. Ссылка на документацию

Тимлид дал тебе задачу. Объяснение он закончил фразой «делай в фичабранче». Когда ты спросил, что это значит, он промямлил что-то про гитфлоу. Что делать-то?

$ git branch feature_branch # создание новой ветки
$ git checkout feature_branch # переход в новую ветку

Графические иллюстрации веток для понимания происходящего можно найти всё в том же Git-book.

Слить свои изменения

Задачу ты закончил, теперь ты получил указание «замерджить свой бранч в дев». Что это за дичь? Как делать?

Всё та же третья глава и уже, должно быть, знакомые команды:
$ git checkout dev_branch # переключаемся на ветку dev
$ git merge my_work_branch # мерджим ветку my_work_branch

Добавить в одну ветку изменения из другой

Следующую задачу ты делаешь так же, в отдельной ветке от дева. Правда, долго: уже неделя прошла, а задача не готова. Лид даёт указание «подлить изменения из дева в свой бранч». Шта?

$ git merge dev # выполняем команду слияния ветки dev с my_branch, находясь в векте my_branch

Ты сделал задачу, но ошибся с веткой, в которую коммитить: вместо дева сделал коммит в мастер. Хорошо, что не запушил. Теперь надо этот коммит перенести в дев. Как это сделать?

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

Надо вернуться к состоянию репозитория на третий коммит, где нет той самой ошибки. Чтобы было проще дальше объяснять, обзовём это состояние репозитория «C» (от слова correct).

2 # все файлы изменятся на состояние репозитория «C», а индексированные файлы двух ошибочных коммитов будут удалены.

Выглядеть это будет как на картинке из одного стоящего прочтения параграфа GitBook’a, только здесь рассматривается переход на один коммит назад, а не на два:

Выглядеть это будет так:

Подытожим, фрагментом из данного параграфа. Команда reset:

Делает Рабочий Каталог таким же как и Индекс.

Второй способ, используем revert:
$ git commit revert HEAD

2 # всё тоже самое, но безопаснее: команда создаёт новый коммит c состоянием репозитория «C», не удаляя предыдущие коммиты и не трогая индексированные файлы.

Удалить коммиты, которые были запушены на удалённый сервер

Как же мне теперь удалить пять коммитов с сообщением «финальная версия 3» из ветки на github?

4 master
$ git push origin +master

Добавить изменение в сделанный коммит или переименовать его

Исправил ридми, но забыл поставить запятую.

Нашел ошибки? Хочешь пулреквестнуть?
Пиши мне в slack @beastrock или вконтакте.

Источник