Отмена коммита немного страшна, если вы не знаете, как он работает. Но это на самом деле удивительно легко, если вы понимаете.

Скажем, у вас это есть, где C - это ваша ГОЛОВА, а (F) - это состояние ваших файлов.

   (F)
A-B-C
    ↑
  master

Вы хотите обнулить коммит C и больше никогда его не видеть. Ты делаешь это:

git reset --hard HEAD~1

Результат:

 (F)
A-B
  ↑
master

Теперь Б - ГОЛОВА. Поскольку вы использовали --hard, ваши файлы возвращаются в свое состояние при фиксации B.

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

   (F)
A-B-C
    ↑
  master

Вы можете сделать это, оставив --hard:

git reset HEAD~1

В этом случае результат:

   (F)
A-B-C
  ↑
master

В обоих случаях HEAD - это просто указатель на последний коммит. Когда вы делаете git reset HEAD~1, вы говорите Git переместить указатель HEAD назад на один коммит. Но (если вы не используете --hard) вы оставляете свои файлы такими, какими они были. Теперь git status показывает изменения, которые вы зарегистрировали в C. Вы ничего не потеряли!

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

git reset --soft HEAD~1

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

Еще одна вещь: предположим, вы уничтожили коммит, как в первом примере, но потом обнаружили, что он вам нужен в конце концов? Не повезло, правда?

Нет, еще есть способ вернуть его. Тип git reflog, и вы увидите список (частично) совершать ШАС (то есть, хэш), что вы переместились вокруг в Найти коммит вы уничтожили, и сделать это.:

git checkout -b someNewBranchName shaYouDestroyed

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

Мне потребовалось некоторое время, чтобы понять, так что, возможно, это поможет кому-то...

Существует два способа "отменить" ваш последний коммит, в зависимости от того, сделал ли вы общедоступный отчет (нажал на удаленный репозиторий):

Как отменить локальную фиксацию

Пусть говорят, что я совершил локально, но теперь хочу удалить эту фиксацию.

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

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

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Теперь git log покажет, что наша последняя фиксация была удалена.

Как отменить публичную фиксацию

Если вы уже сделали свои коммиты общедоступными, вам нужно будет создать новый коммит, который "вернет" изменения, внесенные вами в предыдущую фиксацию (текущий HEAD).

git revert HEAD

Теперь ваши изменения будут отменены и готовы к фиксации:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Для получения дополнительной информации, ознакомьтесь с Основами Git - Отменить вещи

Добавить/удалить файлы, чтобы получить то, что вы хотите:

git rm classdir
git add sourcedir

Затем измените фиксацию:

git commit --amend

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

Обратите внимание, что вы должны сделать это только в том случае, если вы еще не нажали. Если вы нажали, вам просто придется совершить исправить нормально.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

или

git reset --hard HEAD~1

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

hard reset в HEAD-1 установит вашу рабочую копию в состояние фиксации до вашего неправильного фиксации.

Чтобы изменить последнее фиксацию

Замените файлы в индексе:

git rm --cached *.class
git add *.java

Затем, если это частный филиал, измените фиксацию:

git commit --amend

Или, если это общая ветка, выполните новую фиксацию:

git commit -m 'Replace .class files with .java files'

(чтобы изменить предыдущую фиксацию, используйте удивительную интерактивную rebase)

ProTip : добавьте *.class в gitignore, чтобы остановить это повторение.

Чтобы вернуть фиксацию

Изменение коммита - идеальное решение, если вам нужно изменить последнее коммит, но reset более общее решение.

Вы можете сбросить git на любой фиксатор с помощью:

git reset @~N

Где N - количество коммитов перед HEAD, а @~ возврат к предыдущему фиксации.

Итак, вместо внесения изменений в коммит вы можете использовать:

git reset @~
git add *.java
git commit -m "Add .java files"

Проверьте git help reset, в частности разделы --soft --mixed и --hard, чтобы лучше понять, что это делает.

Reflog

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

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Использовать git revert <commit-id>

Чтобы получить идентификатор фиксации, просто используйте git log

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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

Больше

Если у вас установлена Git Extras, вы можете запустить git undo чтобы отменить последнюю фиксацию. git undo 3 отменяет последние 3 фиксации.

Я хотел отменить последние 5 коммитов в нашем общем хранилище. Я просмотрел идентификатор ревизии, к которому я хотел откат. Затем я набрал следующее.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

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

Выберите количество коммитов, которые вы хотите перечислить, затем вызовите это (чтобы забрать последние три)

git rebase -i HEAD~3

Примерный список

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Затем Git удалит фиксации для любой удаляемой строки.

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

Используйте git-gui (или аналогичный) для выполнения git commit --amend. Из графического интерфейса вы можете добавлять или удалять отдельные файлы из коммита. Вы также можете изменить сообщение коммита.

Как отменить предыдущий локальный коммит

Просто верните свою ветку в предыдущее местоположение (например, используя gitk или git rebase). Затем повторно примените изменения из сохраненной копии. После сборки мусора в вашем локальном хранилище будет похоже на то, что нежелательный коммит никогда не происходил. Чтобы сделать все это в одной команде, используйте git reset HEAD~1.

Слово предупреждения: неосторожное использование git reset - хороший способ привести вашу рабочую копию в запутанное состояние. Я рекомендую новичкам Git избегать этого, если они могут.

Как отменить публичный коммит

Выполните обратный выбор вишни (git-revert), чтобы отменить изменения.

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

git revert --no-edit HEAD

Затем отправьте обновленную ветку в общий репозиторий.

История коммитов покажет оба коммита отдельно.

Дополнительно: исправление частной ветки в публичном хранилище

Это может быть опасно - убедитесь, что у вас есть локальная копия ответвления.

Также обратите внимание: вы не хотите делать это, если кто-то еще работает над веткой.

git push --delete (branch_name) ## remove public version of branch

Очистите свою ветку локально, затем оттолкнитесь...

git push origin (branch_name)

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

Если вы совершили ошибку, но не нажали,

git reset --soft HEAD~1

HEAD ~ 1 является сокращением для фиксации перед головой. В качестве альтернативы вы можете обратиться к SHA-1 хэша, если вы хотите сбросить его. --soft удалит коммит, но он оставит все ваши измененные файлы "Изменения будут совершены", как сказал бы статус git.

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

ИЛИ

Если вы уже нажали, и кто-то потянул, что обычно является моим делом, вы не можете использовать сброс git. Однако вы можете сделать git revert,

git revert HEAD

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

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

Идентификатор фиксации можно увидеть

git log 

Тогда вы можете сделать -

git reset --hard <commit_id>

git push origin <branch_name> -f

В SourceTree (GUI для GitHub) вы можете щелкнуть правой кнопкой мыши фиксацию и выполнить "Обратный фиксат". Это должно отменить ваши изменения.

На терминале:

Вы также можете использовать:

git revert

Или:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Единая команда:

git reset --soft 'HEAD^' 

Он отлично работает, чтобы отменить последнюю локальную фиксацию!

Просто сбросьте его, выполнив команду ниже, используя git:

git reset --soft HEAD~1

Объясните: что делает git reset, он в основном reset на любой фиксатор, на который вы хотите вернуться, тогда, если вы объедините его с --soft, он вернется, но сохранит изменения в ваших файлах, поэтому вы вернетесь на сцену, в которую был добавлен файл, HEAD - глава ветки, и если вы объединитесь с ~1 (в этом случае вы также используете HEAD^), он вернется только к одной команде, которую вы хотите...

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

Как отменить последний Git?

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

1. Если вы не хотите сохранять свои изменения, которые вы сделали:

   git reset --hard HEAD^
   

2. Если вы хотите сохранить свои изменения:

   git reset --soft HEAD^
   

Теперь проверьте свой журнал git. Он покажет, что наша последняя фиксация была удалена.

Используйте reflog, чтобы найти правильное состояние

git reflog

REFLOG ПЕРЕД СБРОСОМ

Выберите правильный рефлог (f3cb6e2 в моем случае) и введите

git reset --hard f3cb6e2

После этого HEAD возвращается в HEADid LOG AFTER RESET

Наконец, reflog выглядит как картинка ниже

REFLOG FINAL

"Сбросить рабочее дерево до последнего фиксации"

git reset --hard HEAD^ 

"Очистить неизвестные файлы от рабочего дерева"

git clean    

см. - Краткая ссылка Git

ПРИМЕЧАНИЕ. Эта команда удалит предыдущую фиксацию, поэтому используйте ее с осторожностью! git reset --hard безопаснее -

Первый забег:

git reflog

Он покажет вам все возможные действия, которые вы выполнили в своем репозитории, например, commit, merge, pull и т.д.

Затем выполните:

git reset --hard ActionIdFromRefLog

Отменить последнее коммит:

git reset --soft HEAD^ или git reset --soft HEAD~

Это приведет к отмене последнего фиксации.

Здесь --soft означает сброс настроек.

HEAD~ или HEAD^ означает переход к фиксации перед HEAD.

Заменить последнюю фиксацию на новую фиксацию:

git commit --amend -m "message"

Он заменит последнее коммит новым фиксатором.

Другой путь:

Оформите заявку на филиал, который хотите вернуть, затем верните локальную рабочую копию обратно на коммит, который вы хотите быть последним на удаленном сервере (все после того, как оно пройдет до свидания). Для этого в SourceTree я щелкнул правой кнопкой мыши и выбрал "Сбросить BRANCHNAME на это коммит".

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

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

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

Введите git log и найдите последний код хеширования и введите:

git reset <the previous co>

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

В моем случае я случайно совершил некоторые файлы, которые я не хотел. Поэтому я сделал следующее, и это сработало:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Проверьте результаты с помощью gitk или git log --stat

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

git reset --hard HEAD~1

Есть много способов сделать это:

Команда Git для отмены последнего фиксации/предыдущих коммитов:

Предупреждение: Не используйте --hard, если вы не знаете, что делаете. --hard слишком опасен, и он может удалить ваши файлы.

Основная команда для отмены фиксации в Git:

$ git reset --hard <COMMIT -ID>

или

$ git reset --hard HEAD~<n>

COMMIT-ID: идентификатор для фиксации

n: число последних коммитов, которые вы хотите вернуть

Вы можете получить идентификатор фиксации, как показано ниже:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

где d81d3f1 и be20eb8 - идентификатор commit.

Теперь рассмотрим некоторые случаи:

Предположим, вы хотите вернуть последнее коммит 'd81d3f1'. Вот два варианта:

$ git reset --hard d81d3f1

или

$ git reset --hard HEAD~1

Предположим, вы хотите вернуть commit 'be20eb8':

$ git reset --hard be20eb8

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

$ git reset --help

Существует два основных сценария

Вы еще не нажали фиксацию

Если проблема связана с дополнительными файлами, которые вы совершили (и вы не хотите их использовать в репозитории), вы можете удалить их с помощью git rm а затем --amend с --amend

git rm <pathToFile>

Вы также можете удалить целые каталоги с помощью -r или даже объединить с другими командами Bash

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

После удаления файлов вы можете зафиксировать с помощью опции --amend

git commit --amend -C HEAD # the -C option is to use the same commit message

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

Вы уже нажали на фиксацию

Вы можете применить одно и то же решение другого сценария, а затем выполнить git push с -f опции -f, но это не рекомендуется, так как он перезаписывает удаленную историю с расходящимся изменением (это может испортить ваш репозиторий).

Вместо этого вам необходимо выполнить фиксацию без --amend (помните об этом -amend ": этот вариант перезаписывает историю последнего коммита).

Для локальной фиксации

git reset --soft HEAD~1

или если вы точно не помните, в какой фиксации это возможно, вы можете использовать

git rm --cached <file>

Для нажатой фиксации

Правильный способ удаления файлов из истории репозитория - использование git filter-branch. То есть,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Но я рекомендую вам использовать эту команду с осторожностью. Подробнее читайте в разделе git-filter-branch (1) Manual.

ЧТО ИСПОЛЬЗОВАТЬ, reset --soft или reset --hard?

Я просто добавляю два цента за @Kyralessa ответ:

Если вы не знаете, что использовать, перейдите для --soft (я использовал это соглашение, чтобы запомнить его - s for for safe).

Зачем?

Если вы выберете --hard по ошибке, вы потеряете свои изменения, как это было раньше. Если вы выберете --soft по ошибке, вы можете добиться тех же результатов --hard, применив дополнительные команды

git reset HEAD file.html
git checkout -- file.html

Полный пример

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Кредиты идут на @Kyralessa.

В этой статье есть отличное объяснение того, как идти о различных сценариях (где совершена фиксация, а также нажать "ИЛИ" только коммит до нажатия):

http://christoph.ruegg.name/blog/git-howto-revert-a-commit-already-pushed-to-a-remote-reposit.html

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

git revert dd61ab32

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

git reset --hard HEAD~1

И если нужны файлы в последнем коммите, вы можете использовать это:

git reset --soft HEAD~1

Вы можете использовать:

git reset HEAD@{1}

Эта команда удалит неправильную фиксацию без журнала Git.

Подумайте, у нас есть файл code.txt. Мы вносим в него некоторые изменения и совершаем. Мы можем отменить эту фиксацию тремя способами, но сначала вы должны знать, что такое поэтапный файл... Поэтапный файл - это файл, готовый к фиксации, и если вы запустите git status этот файл будет отображаться зеленым цветом, и если это не поставленный для фиксации, будет показан красным цветом:

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

Отменить последнее коммит:

1. Теперь, если мы хотим просто отменить фиксацию без каких-либо изменений, мы можем использовать

   git reset --soft HEAD^

   

2. Если мы хотим отменить фиксацию и ее изменения (ЭТО ОПАСНО, потому что ваши изменения будут потеряны), мы можем использовать

   git reset --hard HEAD^

   

3. И если мы хотим отменить фиксацию и удалить изменения со стадии, мы можем использовать

   git reset --mixed HEAD^ или в краткой форме git reset HEAD^

   

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

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

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

ПРИМЕЧАНИЕ. Я предполагаю, что вы поняли, что совершение было неправильным, прежде чем вы его подтолкнули. Если вы не знаете, что такое толкание, вы, вероятно, не нажали, так что продолжайте с инструкциями. Если вы допустили ошибочную фиксацию, наименее рискованным способом является просто отслеживание ошибочного фиксации с помощью новой фиксации, которая исправляет ситуацию, как вы это делаете в системе контроля версий, которая не позволяет вам переписывать историю.

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

1. Перейдите в свой репозиторий в командной строке и запустите gui с помощью git gui
2. Выберите "Изменить последнее завершение". Вы увидите последнее сообщение о фиксации, файлы, которые вы поставили, и файлы, которые у вас не были.
3. Теперь измените ситуацию так, как вы хотите, чтобы они выглядели, и нажмите "Зафиксировать".

Если вы работаете с SourceTree, это поможет вам.

Щелкните правой кнопкой мыши фиксацию, затем выберите "Сброс (текущая ветка)/мастер для этой фиксации" и последний выбор "Мягкий" сброс.

Отменить последнее обязательство

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

В этих случаях команда "reset" - ваш лучший друг:

$ git reset --soft HEAD~1

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

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

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

$ git reset --hard HEAD~1

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

git reset --soft HEAD~

Или отмените время до последнего времени:

git reset --soft HEAD~2

Или отменить любую предыдущую фиксацию:

git reset --soft <commitID>

(вы можете получить commitID с помощью git reflog)

Когда вы отмените предыдущую фиксацию, не забудьте очистить рабочее место с помощью

git clean

Более подробную информацию можно найти в документах: git-reset

Чтобы отменить ваш локальный коммит вы используете git reset <commit>. Также этот урок очень полезен, чтобы показать вам, как он работает.

В качестве альтернативы вы можете использовать git revert <commit>: возврат следует использовать, когда вы хотите добавить еще один коммит, который откатывает изменения (но сохраняет их в истории проекта).

Типичный цикл Git

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

1. Клонирование в первый раз с удаленного сервера

   git clone $project

2. Вытягивание с удаленного (когда у меня нет ожидающего локального коммита для нажатия)

   git pull

3. Добавление нового локального файла1 в $ to_be_committed_list (просто представьте, что $ to_be_committed_list означает staged область)

   git add $file1

4. Удаление ошибочно добавленного файла2 из $ to_be_committed_list (предположим, что file2 добавлен как шаг 3, чего я не хотел)

   git reset $file2

5. Зафиксировать файл1, который находится в $ to_be_committed_list

   git commit -m "commit message description"

6. Синхронизация локального коммита с удаленным репозиторием перед нажатием

   git pull --rebase

7. При разрешении конфликтов возникает предварительная настройка configure mergetool

   git mergetool #resolve merging here, also can manually merge

8. Добавление файлов разрешенных конфликтов, скажем, file1:

   git add $file1

9. Продолжение моей предыдущей команды rebase

   git rebase --continue

10. Нажатие готовой и уже синхронизированной последней локальной фиксации

    git push origin head:refs/for/$branch # branch = master, dev, etc.

ПОЛЬЗОВАТЕЛИ ВИЗУАЛЬНОЙ СТУДИИ (2015 г. и т.д.)

Если вы не можете синхронизировать в Visual Studio, так как вам не разрешено нажимать на ветвь, как "разработка", то насколько я пробовал, в Visual Studio НИКОГДА не работал REVERT NOR RESET (жесткий или мягкий).

За ответ с ТОННЫМИ ГОЛОСОВ:

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

git reset --hard HEAD~1

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

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

В той же ветке, которую вы совершили и нажали, если вы наберете "git status", вы не увидите ничего нового, потому что вы совершили и нажали, теперь введите:

git reset --soft HEAD~1

Это вернет все ваши изменения (файлы) обратно в область сцены, теперь, чтобы вернуть их в рабочий каталог (нестатический), который вы просто набираете:

git reset FILE

Где "Файл" - это файл, который вы хотите снова зафиксировать. Теперь этот ФАЙЛ должен находиться в рабочем каталоге (нестационарный) со всеми изменениями, которые вы сделали. Теперь вы можете перейти к любой ветки, которую хотите, и зафиксировать изменения в этой ветке. Надеюсь, это поможет другим людям совершить ту же ошибку, что и я. Конечно, начальная ветвь, которую вы совершили, все еще существует со всеми изменениями, но в моем случае это было нормально, если она не для вас, вы можете искать способы вернуть это сообщение в этой ветке.

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

Во-первых, нам нужно исправить наш локальный репозиторий, вернувшись к комманде, которое мы хотим:

git reset --hard <previous good commit id where you want the local repository  to go>

Теперь мы принудительно нажимаем эту хорошую фиксацию на удаленный репозиторий, используя эту команду:

git push --force-with-lease

Вариант силового варианта "с лизингом" предотвратит случайное удаление новых коммитов, о которых вы не знаете (т.е. Из другого источника с момента последнего вытягивания).

Я получил идентификатор фиксации из bitbucket а затем сделал:

git checkout commitID .

Пример:

git checkout 7991072 .

И он вернул его обратно к этой рабочей копии этого сообщения.

Вам нужно сделать легкий и быстрый

    git commit --amend

если это частный филиал или

    git commit -m 'Replace .class files with .java files'

если это общий или публичный филиал.

Отменить последнее коммит:

git reset --soft HEAD^ or git reset --soft HEAD~

Это приведет к отмене последнего фиксации.

Здесь --soft означает сброс настроек.

HEAD~ or HEAD^ означает переход к фиксации перед HEAD.

Заменить последнюю фиксацию на новую фиксацию:

git commit --amend -m "message"

Он заменит последнее коммит новым фиксатором.

Используйте эту команду

git checkout -b old-state 0d1d7fc32

У вас есть несколько вариантов отмены последнего фиксации. Вот некоторые из ваших вариантов суммировать в один ответ с фрагментами кода

Прежде всего вам нужно определить, какие "неправильные" фиксации вы хотите отбросить. Мы будем использовать git reflog чтобы найти его.

git reflog

Вы всегда можете использовать reflog.
git reflog отобразит любое изменение, которое обновило HEAD и проверив нужную запись reflog, вернет HEAD к этой фиксации.

Каждый раз, когда HEAD изменен, в reflog будет введена новая запись.
Функция reflog похожа на команду истории unix и хранится локально на вашем компьютере.

git reflog
git checkout HEAD@{...}
# or
git checkout <sha-1>

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

git reset HEAD --hard <commit_id>

"Переместите" свою голову назад к желаемому фиксации.
Сброс Git проверяет требуемый контент фиксации на вашу промежуточную область и/или на ваш рабочий каталог на основе значения --hard / --soft / --mixed вы выбираете. --hard обновит как сцену, так и рабочий каталог с данным контентом и "отделит" любые другие коммиты за пределами этой точки вашего локального ветки.

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

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

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

Используйте эту команду:

git checkout -b old-state number_commit

Чтобы избавиться от (всех изменений) последнего коммита, последние 2 фиксации и последние n совершают:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

И, чтобы избавиться от чего-либо после конкретной фиксации:

git reset --hard <commit sha>

например,

git reset --hard 0d12345

PS:
1- Будьте осторожны, из-за "жесткого" варианта он также удаляет локальные изменения в вашем репо и возвращается к предыдущей фиксации. Вы должны запустить это, если вы уверены, что перепутались в своих последних фиксациях и хотите вернуться во времени.

2- Обычно достаточно 7 букв "commit sha", но в больших проектах вам может потребоваться до 12 букв, чтобы гарантировать уникальность. Вы также можете упомянуть все 40 букв ша.

3- Вышеупомянутые команды работают в Github для Windows.

Вы всегда можете выполнить git checkout <SHA code> предыдущей версии и затем снова зафиксировать новый код.

Удалите ошибку, которая уже перенесена в Github

git push origin +(previous good commit id):(branch name)

Укажите последний идентификатор хорошей фиксации, который вы хотели бы вернуть в Github.

Например. Если последний идентификатор фиксации неверен, укажите предыдущий идентификатор commit в приведенной выше команде git с именем ветки.

Вы можете получить предыдущий идентификатор фиксации, используя git log

Вам просто нужно использовать одну команду:

git reset --soft 'HEAD^' 

Он работает, чтобы отменить последнюю локальную фиксацию в вашем репозитории Git.

Использование:

git reset HEAD~1 --soft

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

Вы можете отменить свои Git-коммиты двумя способами: во-первых, вы можете использовать git revert, если хотите сохранить историю фиксации:

git revert HEAD~3
git revert <hashcode of commit>

Во-вторых, вы можете использовать git reset, который удалит всю вашу историю фиксации и приведет вашу голову к фиксации там, где вы хотите.

git reset <hashcode of commit>
git reset HEAD~3

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

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

Перейдите к терминалу и введите следующие команды:

git reset --hard hash-to-reverted

git push origin HEAD --force

Для этого вам нужен хэш.

Ссылка: Как отменить последнее совершение в Git?

Если у вас установлены Git Extensions, вы можете легко отменить/отменить фиксацию (вы можете скачать GIT-расширения здесь).

Откройте Git Extensions, щелкните правой кнопкой мыши на фиксации, которую вы хотите вернуть, затем выберите "Revert commit".

Всплывающее окно будет открыто (см. Снимок экрана ниже)

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

Я нашел этот сайт, который описывает, как отменить все, что вы сделали в репозитории.

Некоторые команды:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Просто используйте git reset --hard <last good SHA> чтобы сбросить изменения и дать новый коммит. Вы также можете использовать git checkout -- <bad filename>.

Вот сайт: Oh shit, git! ,

Вот много рецептов, как отменить вещи в Git. Некоторые из них:

О, дерьмо, мне нужно изменить сообщение на мой последний бой!

git commit --amend
# follow prompts to change the commit message

О, дерьмо, я случайно совершил что-то, чтобы справиться с этим, должно быть, было в совершенно новой отрасли!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

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

В приведенном ниже изображении я проверяю ветку "test" (с помощью теста Git git checkout -b test) в качестве локального состояния и проверки (с использованием Git-команды git status) локальной ветки, которой нечего зафиксировать.

На следующем изображении изображения, которое вы видите здесь, я сделал несколько изменений в файле Filter1.txt и добавил этот файл в промежуточную область, а затем передал свои изменения с некоторым сообщением (используя команду Git git commit -m "Doing commit to test revert back").

"-m для сообщения фиксации"

На следующем изображении вы можете видеть, что ваш журнал совершает все, что вы совершили, (используя Git-команду git log).

Таким образом, в приведенном выше изображении вы можете увидеть идентификатор фиксации с каждой фиксацией и с вашим сообщением о фиксации сейчас, независимо от того, что вы хотите вернуть назад или отменить копию, которая зафиксирует идентификатор и нажать ниже команду Git, git revert {"paste your commit id"}, Пример:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

Я вернул обратно свой последний коммит. Теперь, если вы проверяете свой статус Git, вы можете увидеть измененный файл, который является Filter1.txt, и все же выполнить фиксацию.

$ git reset --soft HEAD~1  

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

$ git reset --hard HEAD~1  

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

В IntelliJ IDEA вы можете просто открыть журнал репозитория Git, нажав Alt + 9, щелкнув правой кнопкой мыши по какому-либо тегу из списка коммитов и выберите: "Сбросить текущую ветвь до...".

ГОЛОВА:

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

Git совершает:

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

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

Способ 1: (если вы не знаете номер фиксации, но хотите перенести на первое)

git reset HEAD~1  # It will move your head to last commit

Способ 2: (если вы знаете коммит, который вы просто перезагрузите на свой известный коммит)

git reset 0xab3 # Номер git reset 0xab3

Примечание: если вы хотите узнать недавний коммит, попробуйте git log -p -1

Вот графическое представление:

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

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

git rebase --onto HEAD~1 HEAD

Но если вы хотите сбросить 1 из многих коммитов, вы сказали

a → b → c → d → master

и вы хотите отказаться от commit 'c'

git rebase --onto b c

Это создаст 'b', поскольку новая база 'd' устраняет 'c'

Найдите последний хеш-код фиксации, просмотрев журнал:

git log

затем

git reset <the previous co>

Для полноты картины я приведу один явно очевидный метод, который был упущен из предыдущих ответов.

Так как фиксация не была отправлена, пульт не изменился, поэтому:

1. Удалить локальный репозиторий.
2. Клонировать удаленный репозиторий.

Это иногда необходимо, если ваш модный клиент Git прощается. (например, ошибки non-fast-forward)

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

Предполагая, что вы работаете в Visual Studio, если вы входите в историю веток и просматриваете все свои коммиты, просто выберите событие до фиксации, которую вы хотите отменить, щелкните его правой кнопкой мыши и выберите " Revert. Легко.

Разница между git reset --mixed, --soft и --hard

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

Давайте возьмем пример:

- A - B - C (master)

HEAD указывает на C а индекс соответствует C

--soft

• Когда мы выполняем git reset --soft B с целью удаления коммита C и указания главного /HEAD на B.
• Master/HEAD теперь будет указывать на B, но индекс все еще изменился с C.
• При выполнении git status вы могли видеть файлы, проиндексированные в коммите C, как поэтапные.
• Выполнение git commit в этот момент создаст новый коммит с теми же изменениями, что и в C

--mixed

• Выполнить git reset --mixed B
• При выполнении master/HEAD будет указывать на B, и индекс также изменяется, чтобы соответствовать B из-за используемого смешанного флага.
• Если в этот момент мы запустим git commit, ничего не произойдет, так как индекс соответствует HEAD.
• У нас все еще есть изменения в рабочем каталоге, но, поскольку они отсутствуют в индексе, состояние git показывает их как неперехваченные.
• Чтобы зафиксировать их, вы должны git add а затем зафиксировать как обычно.

--hard

• Выполнить git reset --hard B
• При выполнении master/HEAD будет указывать на B и изменяет ваш рабочий каталог
• Изменения, добавленные в C, и все незафиксированные изменения будут удалены.
• Файлы в рабочей копии будут соответствовать коммиту B, это приведет к потере всех изменений, которые были внесены в коммит C, а также к незафиксированным изменениям.

Надеюсь, что сравнение флагов, доступных для использования с командой git reset, поможет кому-то использовать их с умом. Обратитесь к ним для получения дополнительной информации link1 & link2

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

git reset HEAD^

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

Шаг 1: Получить Git commit-id: - git log

Шаг 2: Используйте Git reset: git reset --hard commit-id

Шаг 3: Если вы уже нажали свои изменения на пульте дистанционного управления, вы можете использовать git push для возврата изменения на пульт: git push origin branch-name -f

Если вы хотите устранить неправильные файлы, вы должны сделать

git reset --soft <your_last_good_commit_hash_here> Здесь, если вы выполняете git status, вы увидите файлы в промежуточной области. Вы можете выбрать неправильные файлы и снять их с промежуточной области.

Как и следующее.

git reset wrongFile1 wrongFile2 wrongFile3

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

git add goodFile1 goodFile2

совершать их

git commit -v или git commit -am "Message"

и толчок

git push origin master

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

от

git reset --hard <your_last_good_commit_hash_here>

git push origin master

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

git push --force origin master

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

git reset --hard <commit_hash>

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

То, что я делаю каждый раз, когда мне нужно отменить фиксацию/фиксации, является:

1. git reset HEAD~<n>//число последних коммитов, которые мне нужно отменить

2. git status//необязательно. Все файлы теперь красны (нестационарны).

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

   • git add <file names> & git commit -m "message" -m "details"
4. Необязательно: я могу отменить изменения остальных файлов, если нужно, в их предыдущем состоянии, с проверкой:
   • git checkout <filename>
5. если я уже подтолкнул его к удаленному происхождению, ранее:
   • git push origin <branch name> -f//использование -f для принудительного нажатия.

Если вы хотите отменить самую первую фиксацию в своем репо

Вы столкнетесь с этой проблемой:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

Ошибка возникает из-за того, что если последняя фиксация является первоначальной фиксацией (или отсутствием родителей) в репозитории, нет HEAD ~.

Решение

Если вы хотите сбросить только фиксацию на "ведущей" ветке

$ git update-ref -d HEAD
$ git rm --cached -r .

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

$ git log

Обратите внимание на предыдущий идентификатор фиксации вашего фиксации и выполните мягкий сброс.

Предположим, что ваш идентификатор фиксации - "C2", а предыдущий идентификатор фиксации - "C1", а затем сброс $ git C1

Ни HEAD не указывает на C1. C2 теперь нестационарен.

Если вы хотите удалить свои изменения из ветки вместе с нестационарностью, выполните сброс $ git --hard C1

Получите последний идентификатор фиксации с помощью этой команды (в журнале один вверху он является последним):

git log

Получите идентификатор фиксации (GUID) и запустите эту команду:

git revert <commit_id>

Повторно опубликованный из моего ответа на другой экземпляр этого вопроса: Как раскрыть мой последний коммит в Git

Чтобы сохранить изменения от фиксации, которую вы хотите отменить

git reset --soft HEAD^

Чтобы уничтожить изменения от фиксации, которую вы хотите отменить

git reset --hard HEAD^

Вы также можете сказать

git reset --soft HEAD~2

для возврата двух коммитов.

Как упоминалось в charsi, если вы находитесь в Windows, вам нужно будет поставить HEAD или зафиксировать хеш в кавычках.

git reset --soft "HEAD^"
git reset --soft "asdf"

Как отредактировать предыдущую фиксацию

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

Я обнаружил, что фиксирую прошлую фиксацию достаточно часто, чтобы написать для нее сценарий.

Здесь рабочий процесс:

1. git commit-edit <commit-hash>
   

   Это выведет вас на фиксацию, которую вы хотите отредактировать.

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

2. Исправьте и выполните фиксацию, как вы хотели, в первую очередь.

   (Вы можете использовать git stash save --keep-index чтобы бежать от любых файлов, которые вы не совершаете)

3. Повторите фиксацию с помощью --amend, например:

   git commit --amend
   

4. Заполните rebase:

   git rebase --continue
   

Вызовите это следующее git-commit-edit и поместите его в свой $PATH:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "$@"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with 'git commit --amend'
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

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

git reset --hard origin/branch-name

git revert commit

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

https://git-scm.com/docs/git-revert

git reset --soft HEAD~1  // For soft delete
git reset --hard HEAD~1  // Complete removal

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

Чтобы разблокировать изменения последнего фиксации:

git reset --soft

Все изменения последнего фиксации будут нефиксированы.

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

git clean -f //use -d with -f if you want to process directories too

Теперь вы можете делать свои изменения и совершать снова с помощью:

git commit -m "removed unwanted files from last commit"

Git Revert to Old Commit

git reset --hard hash-to-reverted

git push origin HEAD --force

git push --delete (branch_name) //this will be removing the public version of your branch

git push origin (branch_name) //This will add the previous version back

Если вы хотите отменить последнюю фиксацию, выполните следующий шаг:

1. git log: - для того, чтобы узнать commit-id, который вы хотите отменить

2. git revert commit-id: - используя эту команду, вы можете отменить фиксацию

или

1. git reset --hard HEAD ~ 1: - используйте это для сброса фиксации, вы также можете использовать commit-id вместо HEAD ~ 1

На моей стороне я использую GitKraken и просто нужно нажать на кнопку отмены/повтора...

Я использую VS Code, и есть удобная интеграция git, которая позволяет мне отменить последнюю фиксацию одним щелчком мыши.

Для тех, кто предпочитает графический интерфейс, ungit - это полнофункциональный графический интерфейс для git, включающий кнопку "отменить последний коммит".

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