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

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

Если я делаю git log , я получаю следующий вывод:

 $ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <me@me.com>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <me@me.com>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <me@me.com>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <me@me.com>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.
 

Как вернуться к фиксации с 3 ноября, то есть совершить 0d1d7fc ?

вопрос задан 6.11.2010
Crazy Serb
30259 репутация

40 ответов


  • 8003 рейтинг

    Это сильно зависит от того, что вы подразумеваете под «revert».

    Временно переключитесь на другую фиксацию

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

     # This will detach your HEAD, that is, leave you with no branch checked out:
    git checkout 0d1d7fc32
     

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

     git checkout -b old-state 0d1d7fc32
     

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

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

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

     # 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's 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.
     

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

    Отменить опубликованные коммиты с новыми коммитами

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

     # This will create three separate revert commits:
    git revert a867b4af 25eee4ca 0766c053
    
    # It also takes ranges. This will revert the last two commits:
    git revert HEAD~2..HEAD
    
    #Similarly, you can revert a range of commits using commit hashes:
    git revert a867b4af..0766c053 
    
    # Reverting a merge commit
    git revert -m 1 <merge_commit_sha>
    
    # To get just one, you could use `rebase -i` to squash them afterwards
    # Or, you could do it manually (be sure to do this at top level of the repo)
    # get your index and work tree into the desired state, without changing HEAD:
    git checkout 0d1d7fc32 .
    
    # Then commit. Be sure and write a good message describing what you just did
    git commit
     

    git-revert manpage действительно покрывает много этого в описании. Еще одна полезная ссылка - это раздел git-scm.com, в котором обсуждается git-revert .

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

    Вы также можете найти этот ответ полезным в этом случае:
    Как переместить HEAD обратно в предыдущее место? (Отдельная головка)

    ответ дан Cascabel, с репутацией 317837, 6.11.2010
  • 1305 рейтинг

    Возврат рабочей копии к последней фиксации

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

     git reset --hard HEAD
     

    где HEAD является последним фиксатором в вашей текущей ветке

    Возврат рабочей копии к старой записи

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

     # Resets index to former commit; replace '56e05fced' with your commit code
    git reset 56e05fced 
    
    # Moves pointer back to previous HEAD
    git reset --soft HEAD@{1}
    
    git commit -m "Revert to 56e05fced"
    
    # Updates working copy to reflect the new commit
    git reset --hard
     

    Кредиты идут к аналогичному вопросу переполнения стека, возвращаются к фиксации SHA-хешем в Git? ,

    ответ дан boulder_ruby, с репутацией 25435, 21.08.2012
  • 1265 рейтинг

    Здесь много сложных и опасных ответов, но на самом деле это легко:

     git revert --no-commit 0766c053..HEAD
    git commit
     

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

    (Флаг --no-commit позволяет git возвращать все коммиты сразу, иначе вам будет предложено отправить сообщение для каждого фиксации в диапазоне, засоряя вашу историю ненужными новыми коммитами.)

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

    ответ дан Yarin, с репутацией 68591, 12.02.2014
  • 161 рейтинг

    Лучшим вариантом для меня и, возможно, для других является опция сброса Git:

     git reset --hard <commidId> && git clean -f
     

    Это был лучший вариант для меня! Это просто, быстро и эффективно!


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

    Кроме того, из комментариев, если вы хотите использовать менее «простой» метод, вы можете использовать

    git clean -i

    ответ дан Pogrindis, с репутацией 4937, 22.10.2013
  • 115 рейтинг

    Прежде чем ответить, добавим немного фона, объяснив, что это такое HEAD .

    First of all what is HEAD?

    HEAD - это просто ссылка на текущую фиксацию (последнюю) в текущей ветке. Там может быть только один HEAD в любой момент времени ( за исключением git worktree ).

    Содержимое HEAD хранится внутри .git/HEAD и содержит 40 байт SHA-1 текущего фиксации.


    detached HEAD

    Если вы не используете последнюю фиксацию - это означает, что HEAD указывает на предыдущую фиксацию в истории, она называется detached HEAD .

    Введите описание изображения здесь

    В командной строке это будет выглядеть так: SHA-1 вместо имени ветки, так как HEAD не указывает на конец текущей ветви:

    Введите описание изображения здесь


    Несколько вариантов восстановления после отсоединенной головки:


    git checkout

     git checkout <commit_id>
    git checkout -b <new branch> <commit_id>
    git checkout HEAD~X // x is the number of commits t go back
     

    Это проверит новую ветвь, указывающую на требуемую фиксацию. Эта команда будет проверять заданную фиксацию.

    На этом этапе вы можете создать ветку и начать работу с этого момента:

     # Checkout a given commit.
    # Doing so will result in a `detached HEAD` which mean that the `HEAD`
    # is not pointing to the latest so you will need to checkout branch
    # in order to be able to update the code.
    git checkout <commit-id>
    
    # Create a new branch forked to the given commit
    git checkout -b <branch name>
     

    git reflog

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

    Каждый раз, когда HEAD изменяется, в reflog будет введена новая запись

     git reflog
    git checkout HEAD@{...}
     

    Это вернет вас к вашей желаемой фиксации

    Введите описание изображения здесь


    git reset HEAD --hard <commit_id>

    «Переместите» свою голову назад к желаемому фиксации.

     # 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's 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.
     
    • Примечание: ( Начиная с Git 2.7 ) вы также можете использовать git rebase --no-autostash .

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

    Введите описание изображения здесь

    ответ дан CodeWizard, с репутацией 46220, 5.02.2015
  • 107 рейтинг

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

     git reset --soft HEAD~1
     
    • --soft указывает, что незафиксированные файлы должны быть сохранены как рабочие файлы, противоположные --hard которые будут отбрасывать их.
    • HEAD~1 - последняя фиксация. Если вы хотите откат 3 фиксации, вы можете использовать HEAD~3 . Если вы хотите откат к определенному номеру ревизии, вы также можете сделать это, используя свой SHA-хэш.

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

    Источник: http://nakkaya.com/2009/09/24/git-delete-last-commit/

    ответ дан Stephen Ostermiller, с репутацией 13219, 4.03.2014
  • 99 рейтинг

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

     git add . && git checkout master -f
     

    Краткое описание:

    • Он не будет создавать никаких коммитов, как это делает git revert .
    • Он НЕ будет отсоединять ваш ГОЛОВ, как git checkout <commithashcode> .
    • Он будет отменять все ваши локальные изменения и УДАЛИТЬ все добавленные файлы с момента последнего фиксации в ветке.
    • Он работает только с именами филиалов, поэтому вы можете вернуться только к последнему фиксации в ветке таким образом.

    Я нашел гораздо более удобный и простой способ добиться результатов выше:

     git add . && git reset --hard HEAD
     

    где HEAD указывает на последнюю фиксацию в вашей текущей ветке.

    Это тот же код, что и boulder_ruby, но я добавил git add . до git reset --hard HEAD чтобы стереть все новые файлы, созданные с момента последнего коммита, так как это то, что большинство людей ожидают, когда вернусь к последней фиксации.

    ответ дан Roman Minenok, с репутацией 7088, 29.07.2012
  • 82 рейтинг

    Вы можете сделать это с помощью следующих двух команд:

     git reset --hard [previous Commit SHA id here]
    git push origin [branch Name] -f
     

    Он удалит вашу предыдущую Git-фиксацию.

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

     git reset --soft [previous Commit SHA id here]
     

    Затем он сохранит ваши изменения.

    ответ дан kiran boghra, с репутацией 2072, 12.12.2014
  • 53 рейтинг

    Скажем, у вас есть следующие коммиты в текстовом файле с именем ~/commits-to-revert.txt (я использовал git log --pretty=oneline для их получения)

     fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
    0c27ecfdab3cbb08a448659aa61764ad80533a1b
    f85007f35a23a7f29fa14b3b47c8b2ef3803d542
    e9ec660ba9c06317888f901e3a5ad833d4963283
    6a80768d44ccc2107ce410c4e28c7147b382cd8f
    9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
    fff2336bf8690fbfb2b4890a96549dc58bf548a5
    1f7082f3f52880cb49bc37c40531fc478823b4f5
    e9b317d36a9d1db88bd34831a32de327244df36a
    f6ea0e7208cf22fba17952fb162a01afb26de806
    137a681351037a2204f088a8d8f0db6e1f9179ca
     

    Создайте сценарий оболочки Bash для возврата каждого из них:

     #!/bin/bash
    cd /path/to/working/copy
    for i in `cat ~/commits-to-revert.txt`
    do
        git revert $i --no-commit
    done
     

    Это возвращает все обратно в предыдущее состояние, включая создание файлов и каталогов, а также удаляет их, передает их в вашу ветку и сохраняет историю, но вы вернули ее обратно в ту же структуру. Почему у Гита нет git revert --to <hash> .

    ответ дан Lance Caraccioli, с репутацией 1105, 13.10.2011
  • 50 рейтинг

    Дополнительные альтернативы решениям Jefromi

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

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

    Альтернатива 1: жесткие и мягкие сбросы

    Это очень немного модифицированная версия решения Чарльза Бейли « Возвратить» к фиксации SHA-хэшем в Git? :

     # Reset the index to the desired commit
    git reset --hard <commit>
    
    # Move the branch pointer back to the previous HEAD
    git reset --soft HEAD@{1}
    
    # Commit the changes
    git commit -m "Revert to <commit>"
     

    Это в основном работает, используя тот факт, что мягкие сбросы оставят состояние предыдущей фиксации, поставленной в области index /staging-area, которую вы затем можете зафиксировать.

    Альтернатива 2: Удалить текущее дерево и заменить его новым

    Это решение исходит из решения svick для Checkout old commit и делает его новой фиксацией :

     git rm -r .
    git checkout <commit> .
    git commit
     

    Аналогично альтернативу №1, это воспроизводит состояние <commit> в текущей рабочей копии. Сначала нужно сделать git rm потому что git checkout не будут удалять файлы, которые были добавлены с <commit> .

    ответ дан does_not_exist, с репутацией , 29.06.2014
  • 48 рейтинг

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

     git reset HEAD~1
     

    Итак, нет необходимости в фиксации идентификаторов и т. Д. :)

    ответ дан Paul Walczewski, с репутацией 586, 29.02.2016
  • 44 рейтинг

    Хорошо, возврат к предыдущей фиксации в git довольно прост ...

    Верните назад, не сохраняя изменений:

     git reset --hard <commit>
     

    Верните назад с сохранением изменений:

     git reset --soft <commit>
     

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

    Но, как вы видите, разница заключается в использовании двух флагов --soft и --hard , по умолчанию git reset с использованием флага --soft , но это хорошая практика, всегда использующая флаг, я объясняю все флаги:


    --мягкий

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


    --жесткий

    Будьте осторожны с этим флагом, он сбрасывает рабочее дерево и все изменения в отслеживаемые файлы, и все не будет!


    Я также создал изображение ниже, которое может произойти в реальной жизни, работающей с git:

    git сбрасывается на фиксацию

    ответ дан Alireza, с репутацией 39782, 20.07.2017
  • 43 рейтинг

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

     # Revert local master branch to November 3rd commit ID
    git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    
    # Revert remote master branch to November 3rd commit ID
    git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master
     

    Я нашел ответ из сообщения в блоге. Удалите Git-ретрансляцию Git для конкретной фиксации .

    ответ дан markreyes, с репутацией 532, 10.05.2016
  • 43 рейтинг

    Ничто здесь не работало для меня, кроме этой точной комбинации:

     git reset --hard <commit_hash>
    git push origin <branch_name> --force
     

    Ключ здесь - это принудительное нажатие, никаких дополнительных сообщений о фиксации /фиксации и т. Д.

    ответ дан serdarsenay, с репутацией 983, 12.02.2018
  • 32 рейтинг

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

     git push -f ...
     

    И не только git push .

    ответ дан sivi, с репутацией 6112, 5.09.2013
  • 31 рейтинг

    Существует команда (не часть ядра Git, но она находится в пакете git-extras ) специально для возврата и постановки старых коммитов:

     git back
     

    На странице руководства он также может быть использован как таковой:

     # Remove the latest three commits
    git back 3
     
    ответ дан Shadow Man, с репутацией 1928, 8.08.2013
  • 24 рейтинг

    Выберите требуемую фиксацию и проверьте ее

     git show HEAD
    git show HEAD~1
    git show HEAD~2 
     

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

     git reset --hard HEAD~1
     

    или git reset --hard HEAD~2 или что-то еще.

    ответ дан tonythomas01, с репутацией 400, 26.02.2014
  • 22 рейтинг

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

     git reset --hard HEAD
     
    ответ дан Mohammed Irfan Tirupattur, с репутацией 889, 26.07.2016
  • 19 рейтинг

    Это еще один способ прямого возврата к недавнему фиксации

     git stash
    git stash clear
     

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

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

    ответ дан Point Networks, с репутацией 403, 5.05.2016
  • 19 рейтинг

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

     git reset <SHA>
     

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

     git reset --hard <SHA>
     
    ответ дан Vishnu Atrai, с репутацией 1784, 28.07.2015
  • 19 рейтинг

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

     git add -A .
    git reset --hard HEAD
     

    Только git reset --hard HEAD избавится от модификаций, но он не избавится от «новых» файлов. В их случае они случайно перетащили важную папку где-то случайную, и все эти файлы были обработаны Git, как новые, поэтому reset --hard не исправили ее. Запустив git add -A . заранее, он явно отслеживал их все с помощью git, которые были уничтожены сбросом.

    ответ дан Chris Moschini, с репутацией 25057, 11.10.2015
  • 18 рейтинг

    Вы можете выполнить все эти начальные шаги самостоятельно и вернуться к git-репо.

    1. Вытащите последнюю версию своего репозитория из Bitbucket с помощью команды git pull --all .

    2. Запустите команду git log с -n 4 с вашего терминала. Число после -n определяет количество коммитов в журнале, начиная с последнего фиксации в вашей локальной истории.

      $ git log -n 4

    3. Сбросьте историю истории вашего репозитория, используя git reset --hard HEAD~N где N - количество фиксаций, которые вы хотите вернуть назад. В следующем примере голова будет установлена ​​одна фиксация, последняя фиксация в истории репозитория:

    4. Нажмите на изменение в git repo, используя git push --force чтобы принудительно нажать на изменение.

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

     git pull --all
    git reset --hard HEAD~1
    git push --force
     
    ответ дан Nanhe Kumar, с репутацией 8577, 6.04.2017
  • 18 рейтинг

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

     git reset --hard origin/master
     

    https://superuser.com/questions/273172/how-to-reset-master-to-origin-master

    ответ дан nevster, с репутацией 4405, 5.02.2015
  • 15 рейтинг

    Revert - команда отката коммитов.

     git revert <commit1> <commit2> 
     

    Образец:

    git revert 2h3h23233

    Он способен принимать диапазон от HEAD, как показано ниже. Здесь 1 говорит: «Вернуть последнее совершение».

    git revert HEAD~1..HEAD

    и затем сделать git push

    ответ дан Sireesh Yarlagadda, с репутацией 6876, 20.08.2015
  • 12 рейтинг

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

    1. Скопируйте весь каталог и назовите его чем-то другим, например «мой проект - копия»

    2. Делать:

       git reset --hard [first-4-letters&numbers-of-commit's-SHA]
       

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

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

    Git - это блестящее творение, но вы не можете просто «поднять его на лету»: также люди, которые пытаются объяснить это слишком часто, предполагают предварительное знание других VCS [систем контроля версий] и слишком далеко заходят слишком далеко, и совершать другие преступления, например, использовать взаимозаменяемые термины для «проверки» - способами, которые иногда кажутся почти рассчитанными, чтобы запутать новичка.

    Чтобы сэкономить много внимания, вам нужно в значительной степени прочитать книгу о Git - я бы рекомендовал «Контроль версий с Git» . И если вы можете мне доверять (точнее, мои шрамы), когда я говорю «нужно», из этого следует, что вы могли бы также сделать это СЕЙЧАС . Большая часть сложности Git происходит от разветвления, а затем сжигает. Но из вашего вопроса нет причин, по которым люди должны ослеплять вас наукой .

    Особенно, если, например, это отчаянная ситуация, и вы новичок в Git!

    PS: Еще одна мысль: на самом деле довольно просто сохранить репозиторий Git («repo») в каталоге, отличном от того, в котором работают рабочие файлы. Это означало бы, что вам не пришлось бы копировать весь репозиторий Git, используя вышеупомянутое быстрое и грязное решение. Смотрите ответ на Фрайер с помощью --separate-ГИТ-реж здесь . Однако будьте осторожны : если у вас есть репозиторий «отдельный каталог», который вы не копируете, и вы выполняете жесткий сброс, все версии, следующие за фиксацией сброса, будут потеряны навсегда, если у вас нет, как вам абсолютно необходимо, регулярно резервирует ваш репозиторий, предпочтительно в облаке (например, на Google Диске ) среди других мест.

    ответ дан mike rodent, с репутацией 3462, 19.03.2015
  • 11 рейтинг

    Попробуйте выполнить сброс до требуемого фиксации -

    git reset <COMMIT_ID>

    (для проверки использования COMMIT_ID git log )

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

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

    git checkout .

    Проверьте git log чтобы проверить свои изменения.

    ОБНОВИТЬ

    Если у вас есть одно и только сообщение в вашем репо, попробуйте

    git update-ref -d HEAD

    ответ дан optimistanoop, с репутацией 474, 6.05.2017
  • 10 рейтинг

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

    Сначала вам нужно удалить развитие из источника:

     git push origin :develop (note the colon)
     

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

     git reset --hard EFGHIJK
     

    Наконец, толчок развивается снова:

     git push origin develop
     
    ответ дан George Ninan, с репутацией 629, 20.03.2017
  • 9 рейтинг

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

    У меня была аналогичная проблема, и я хотел вернуться к предыдущему Commit. В моем случае я не был настроен на сохранение новых коммитов, поэтому я использовал Hard .

    Вот как я это сделал:

     git reset --hard CommitId && git clean -f
     

    Это будет возвращено в локальный репозиторий, здесь после использования git push -f будет обновлен удаленный репозиторий.

     git push -f
     
    ответ дан maytham-ɯɐɥʇʎɐɯ, с репутацией 9607, 8.01.2018
  • 9 рейтинг

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

    ответ дан Upul Doluweera, с репутацией 713, 1.07.2015
  • 8 рейтинг

    На GitKraken вы можете сделать это:

    1. Щелкните правой кнопкой мыши фиксацию, которую вы хотите сбросить, выберите: Сбросить на это commit /Hard :

    введите описание изображения здесь

    1. Щелкните правой кнопкой мыши на фиксации еще раз, выберите: Current name name /Push :

    введите описание изображения здесь

    1. Нажмите на Force Push :

    введите описание изображения здесь

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

    ответ дан Angelo Polotto, с репутацией 358, 2.05.2018
  • 8 рейтинг

    Во-первых, получите строку, которая идентифицирует фиксацию в какой-то день, делая:

     git rev-list -n 1 --before="2009-07-27 13:37" origin/master
     

    он печатает идентификатор фиксации, берет строку (например, XXXX) и делает:

     git checkout XXXX
     
    ответ дан Luca C., с репутацией 2885, 5.05.2017
  • 7 рейтинг

    SourceTree можно сделать намного проще. Щелкните правой кнопкой мыши фиксацию, которую вы ищете, и выберите «Checkout» из меню.

    введите описание изображения здесь

    ответ дан Marcin Szymczak, с репутацией 6450, 26.05.2017
  • 7 рейтинг

    Для отката (или возврата):

    1. git revert --no-commit «commit-code-to-remove» HEAD (например, git revert --no-commit d57a39d HEAD)
    2. git commit
    3. git push

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

    Если вы обнаружите, что что-то не так:

    git revert --bort

    ответ дан Jagraj Singh, с репутацией 206, 1.11.2016
  • 7 рейтинг

    Еще одно простейшее решение; вы должны изменить ветвь, чтобы сделать это, но потом вы можете просто запустить:

     git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
     
    ответ дан Aif, с репутацией 8859, 4.12.2015
  • 6 рейтинг

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

    1. Выбрал ветку, которую я хотел, скопировал.
    2. Выбрано последнее отделение.
    3. Скопировав содержимое из ветки, я хотел, чтобы каталог последней ветви перезаписывал изменения и фиксировал это.
    ответ дан Demodave, с репутацией 3171, 23.02.2015
  • 6 рейтинг
     git reflog
     

    Выберите номер HEAD (ы) git reflog, где вы хотите вернуться и сделать (для этого примера я выбираю 12):

     git reset HEAD@{12} --hard
     
    ответ дан Sérgio, с репутацией 4389, 28.09.2016
  • 5 рейтинг

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

    1. выйдите из фиксации или ответвите свое желание вернуться.
    2. Измените .git /HEAD и измените ref на ветку, на которую вы вернетесь.

    Такие как:

     echo 'ref: refs/heads/example' > .git/HEAD
     

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

    Если все выглядит хорошо, вы можете совершить. Вы также можете использовать git diff revert..example, чтобы убедиться, что это то же самое.

    ответ дан jgmjgm, с репутацией 1332, 7.12.2017
  • 4 рейтинг

    Если вы хотите временно вернуть изменения, потому что

    • кто-то совершил код, который нарушает работу или нарушает функциональность, над которой вы работаете

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

     git rebase --onto <commitId>
     

    Когда удаленная ветка снова работает, вы можете

     git pull --rebase
     

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

    ответ дан joseph, с репутацией 573, 10.11.2017
  • 2 рейтинг

    Revert Most Recent Commit:

     git reset --hard HEAD
     

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

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

     # Resets index to former commit
    git reset 56e05fced 
    
    # Moves pointer back to previous HEAD
    git reset --soft HEAD@{1}
    
    # Updates working copy to reflect the new commit
    git reset --hard
     

    Это перемотает вашу ветку HEAD в указанную версию. Все фиксации, которые появились после этой версии, фактически отменены; ваш проект точно так же, как и в тот момент.

    Команда reset поставляется с несколькими опциями, одним из наиболее интересных из которых является флаг --soft . Если вы используете его вместо --hard , Git сохранит все изменения в этих «отмененных» записях как локальные модификации.

    Восстановление версии в новом локальном филиале

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

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

     git checkout -b old-project-state 0ad5a7a6
     

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

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

    ответ дан Lyes CHIOUKH, с репутацией 1557, 31.08.2018
  • -1 рейтинг

    В визуальной студии это довольно легко, проверяя исходное дерево. Просто:

    Нажмите «Командный проводник» -> «Ветви» -> разверните (выберите желаемый филиал) -> щелкните правой кнопкой мыши и выберите «Просмотр истории» -> Выберите фиксацию, которую вы хотите вернуть раньше -> щелкните правой кнопкой мыши и нажмите «Восстановить»,

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

    введите описание изображения здесь

    ответ дан nzrytmn, с репутацией 309, 3.09.2018