it-swarm.com.ru

Как мне вернуть Git-репозиторий к предыдущему коммиту?

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

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

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

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

6875
Crazy Serb

Это во многом зависит от того, что вы подразумеваете под "возвратом".

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

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

# 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 возврат имеет очень специфическое значение: создайте коммит с обратным патчем, чтобы отменить его. Таким образом, вы не переписываете историю.

# 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 обратно в предыдущее местоположение? (Отдельная голова)

8778
Cascabel

Мошенник кодер?

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

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

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

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

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 [email protected]{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

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

1463
boulder_ruby

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

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

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

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

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

1453
Yarin

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

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

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


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

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

git clean -i

183
Pogrindis

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

First of all what is HEAD?

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

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


detached HEAD

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

Enter image description here

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

Enter image description here


Несколько вариантов того, как восстановить систему с отключенной 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 [email protected]{...}

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

Enter image description here


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.

Enter image description here

143
CodeWizard

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

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

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

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

124
Stephen Ostermiller

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

git add . && git checkout master -f

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

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

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

git add . && git reset --hard HEAD

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

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

105
Roman Minenok

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

git reset --hard [previous Commit SHA id here]
git Push Origin [branch Name] -f

Это удалит ваш предыдущий коммит Git.

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

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

Тогда это сохранит ваши изменения.

98
kiran boghra

ОК, вернуться к предыдущему коммиту в git довольно просто ...

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

git reset --hard <commit>

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

git reset --soft <commit>

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

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


--мягкий

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


--жесткий

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


Я также создал изображение ниже, которое может случиться в реальной жизни, работая с git:

git reset to a commit

65
Alireza

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

git reset --hard <commit_hash>
git Push Origin <branch_name> --force

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

59
serdarsenay

Скажем, у вас есть следующие коммиты в текстовом файле с именем ~/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 нет git revert --to <hash> - вне меня.

57
Lance Caraccioli

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

# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Reset remote master branch to November 3rd commit ID
git Push -f Origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

Я нашел ответ от в сообщении в блоге (теперь больше не существует)

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

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

56
markreyes

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

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

Чтобы было ясно, эти альтернативы не лучший способ отменить коммиты , Джефроми решения есть , но я просто хочу отметить, что вы также можете использовать эти другие методы для достижения того же, что и 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 [email protected]{1}

# Commit the changes
git commit -m "Revert to <commit>"

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

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

Это решение взято из решения svick по Извлечь старый коммит и сделать его новым :

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

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

56
user456814

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

git reset HEAD~1

Таким образом, нет необходимости в фиксации идентификаторов и так далее :)

51
Paul Walczewski

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

git Push -f ...

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

34
sivi

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

git back

Согласно man-страница , он также может быть использован как таковой:

# Remove the latest three commits
git back 3
34
Shadow Man

Вы можете выполнить все эти начальные шаги самостоятельно и вернуться к 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
29
Nanhe Kumar

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

git reset --hard HEAD
27
Mohammed Irfan Tirupattur

Выберите необходимый коммит и проверьте его с помощью

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

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

git reset --hard HEAD~1

или git reset --hard HEAD~2 или что угодно.

26
tonythomas01

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

git stash
git stash clear

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

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

20
Point Networks

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

git reset <SHA>

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

git reset --hard <SHA>
20
Vishnu Atrai

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

git add -A .
git reset --hard HEAD

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

20
Chris Moschini

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

git reset --hard Origin/master

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

19
nevster

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

git revert <commit1> <commit2> 

Пример:

git revert 2h3h23233

Он может принимать диапазон от HEAD, как показано ниже. Здесь 1 говорит "отменить последний коммит".

git revert HEAD~1..HEAD

а затем сделать git Push

16
Sireesh Yarlagadda

Вернуть самый последний коммит:

git reset --hard HEAD

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

Возврат к более старой фиксации. Самый быстрый способ восстановить старую версию - использовать команду reset:

# Resets index to former commit
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

# Updates working copy to reflect the new commit
git reset --hard

Это перемотает вашу ветку HEAD до указанной версии. Все коммиты, которые пришли после этой версии, фактически отменены; Ваш проект точно такой, каким он был на тот момент.

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

Восстановление редакции в новой локальной ветке

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

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

git checkout -b old-project-state 0ad5a7a6

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

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

16
Lyes CHIOUKH

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

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

  2. Делать:

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

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

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

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

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

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

PS: Еще одна мысль: (сейчас) на самом деле довольно просто хранить репозиторий Git ("repo") в каталоге, отличном от каталога с рабочими файлами. Это означает, что вам не нужно будет копировать весь репозиторий Git, используя вышеуказанное быстрое и грязное решение. Посмотрите ответ Фрайера, используя --separate-git-dir здесь . Будьте предупреждены , хотя: если у вас есть репозиторий "отдельный каталог", который вы не копируете, и вы делаете полный сброс, все последующие версии фиксация сброса будет потеряна навсегда, если только вы, как и всегда должны делать, регулярно выполняете резервное копирование своего хранилища, предпочтительно в облако (например, Google Drive ) среди других мест.

13
mike rodent

Попробуйте сбросить до желаемого коммита -

git reset <COMMIT_ID>

(для проверки COMMIT_ID используйте git log)

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

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

git checkout .

Проверьте git log, чтобы подтвердить ваши изменения.

UPDATE

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

git update-ref -d HEAD

13
optimistanoop

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

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

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

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

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

git Push -f
11
maytham-ɯɐɥʇʎɐɯ

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

Сначала вам нужно удалить Develop из Origin:

git Push Origin :develop (note the colon)

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

git reset --hard EFGHIJK

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

git Push Origin develop
11
George Ninan

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

  1. Щелкните правой кнопкой мыши на коммите, который вы хотите сбросить, выберите: Reset to this commit/Hard :

enter image description here

  1. Снова щелкните правой кнопкой мыши на коммите, выберите: Текущее имя ветви/Push :

enter image description here

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

enter image description here

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

10
Ângelo Polotto

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

10
Upul Doluweera

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

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

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

git checkout XXXX
9
Luca C.

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

  1. git revert --no-commit "commit-code-to-remove" HEAD (например, git revert --no-commit d57a39d HEAD)
  2. мерзавец совершить
  3. мерзавец толчок

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

Если вы нашли что-то не так, сделайте:

git revert --abort

9
Jagraj Singh

Это можно сделать намного проще с SourceTree . Просто щелкните правой кнопкой мыши коммит, который вы ищете, и выберите "Оформить заказ" из меню.

enter image description here

8
Marcin Szymczak

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

git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
8
Aif

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

  1. Проверил ветку, которую хотел получить, скопировал.
  2. Проверил последнюю ветку.
  3. Скопировал содержимое из ветки, которую я хотел, в каталог последней ветки, переписав изменения и подтвердив это.
7
Demodave
git reflog

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

git reset [email protected]{12} --hard
7
Sérgio

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

  1. оформите коммит или ветку, от которой вы хотите отказаться.
  2. Отредактируйте .git/HEAD и измените ссылку на ветку, к которой вы хотите вернуться.

Такие как:

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

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

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

6
jgmjgm

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

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

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

git rebase --onto <commitId>

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

git pull --rebase

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

5
joseph

Сброс поэтапных изменений и фиксаций

Команда git reset позволяет вам изменить HEAD - последний коммит, на который указывает ваше рабочее дерево вашего репозитория. Он изменяет либо область подготовки, либо область подготовки и рабочее дерево. Способность Git создавать коммиты в точности так, как вы хотите, означает, что вам иногда нужно отменить изменения, внесенные вами с помощью git add. Вы можете сделать это, вызвав git reset HEAD <file to change>. У вас есть два варианта, чтобы полностью избавиться от изменений. git checkout HEAD <file(s) or path(s)> - это быстрый способ отменить изменения в области подготовки и рабочем дереве. Будьте осторожны с этой командой, потому что она удаляет все изменения в вашем рабочем дереве. Git не знает об этих изменениях, так как они никогда не совершались. Невозможно вернуть эти изменения после запуска этой команды. Другая команда в вашем распоряжении - git reset --hard. Это в равной степени разрушительно для вашего рабочего дерева - любые незафиксированные изменения или поэтапные изменения теряются после его запуска. Запуск git reset -hard HEAD делает то же самое, что и git checkout HEAD. он просто не требует файла или пути для работы. Вы можете использовать --soft с git reset. Он сбрасывает репозиторий в указанный вами коммит и выполняет все эти изменения. На любые изменения, которые вы уже подготовили, это не повлияет, равно как и изменения в вашем рабочем дереве. Наконец, вы можете использовать --mixed для сброса рабочего дерева без внесения каких-либо изменений. Это также не вносит изменений в любые промежуточные изменения.

Возврат Коммитов

Иногда мы делаем ошибки. Коммит, который не должен был использоваться совместно, помещается в общедоступный репозиторий, в коммите есть ошибка, которую невозможно исправить, и которую необходимо отменить, или, может быть, вам больше не нужен этот код. вызов git revert. Команда git revert делает то, что вы могли ожидать. Он отменяет один коммит, применяя обратный коммит к истории. Иногда вам нужно отменить несколько коммитов, чтобы полностью отменить изменение. Вы можете использовать -no-commit, или вы можете использовать -n, чтобы сообщить Git, что нужно выполнить возврат, но не останавливайтесь перед принятием изменения. Это позволяет объединить все возвратные коммиты в один коммит, что полезно, если вам нужно отменить функцию, охватывающую несколько коммитов. Убедитесь, что вы отменили коммиты в обратном порядке - сначала самый новый коммит. В противном случае вы можете запутать Git, пытаясь вернуть код, который еще не существует.

2
SAIguru011