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

https://stackoverflow.com/questions/4114095

29-09-2019
|

Вопрос

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

Если я это сделаю 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?

Решение

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

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

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

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

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

Undo опубликовал коммиты с новыми коммитами

С другой стороны, если вы опубликовали работу, вы, вероятно, не хотите сбросить ветку, поскольку это эффективно переписать историю. В этом случае вы действительно можете вернуть коммиты. С 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 мастерство на самом деле охватывает многое в своем описании. Еще одна полезная ссылка Этот раздел Git-Scm.com обсуждает Git-Revert.

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

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

Другие советы

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

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

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

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

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

Rogue Coder?

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

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

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

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

git reset --hard 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?.

Лучший вариант для меня и, возможно, другие - это вариант сброса GIT:

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

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

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

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

git clean -i

Перед ответом давайте добавим немного фона, объясняя, что это 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 и проверка желаемой записи Refluog установит 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.

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

git reset --soft HEAD~1

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

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

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

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

git add . && git checkout master -f

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

Это не создаст никаких коммитов как git revert делает.
Это не отсоединит вашу голову, как git checkout <commithashcode> делает.
Он переопределит все ваши локальные изменения и удаляет все добавленные файлы с момента последнего коммита в филиале.
Работает только с именами ветвей, поэтому вы можете вернуться только к последним филиалам в ветке таким образом.

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

git add . && git reset --hard HEAD

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

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

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

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

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

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

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

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

ХОРОШО, Возвращаясь к предыдущему фиксации в Git довольно легко ...

Вернуться назад без вести перемены:

git reset --hard <commit>

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

git reset --soft <commit>

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

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

--мягкий

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

--жесткий

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

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

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

# 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 в первую очередь.

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

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

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

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

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

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

Создать Башмак Shell Script для возврата каждого из них:

#!/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> вне меня.

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

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

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

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

Это очень слегка модифицированная версия решения Charles Bailey Вернуться к коммитированию хеша 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>"

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

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

Это решение происходит от решения SVICK Посмотрите старый коммит и сделайте его новым коммитом:

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

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

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

git reset HEAD~1

Так что нет необходимости в коммит -идентификаторах и так далее :)

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

git back

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

# Remove the latest three commits
git back 3

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

git push -f ...

Да и не только git push.

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

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

$ git log -n 4
Сбросьте заголовок истории вашего репозитория с помощью git reset --hard HEAD~N где N - количество коммитов, которые вы хотите вернуть в исходное положение.В следующем примере заголовок будет возвращен на единицу фиксация, к последнему фиксации в истории репозитория:
Внесите изменения в git repo, используя git push --force чтобы принудительно нажать изменение.

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

git pull --all
git reset --hard HEAD~1
git push --force

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

git reset --hard HEAD

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

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

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

git reset --hard HEAD~1

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

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

git reset <SHA>

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

git reset --hard <SHA>

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

git add -A .
git reset --hard HEAD

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

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

git stash
git stash clear

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

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

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

git reset --hard origin/master

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

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

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

Делать:

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

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

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

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

Чтобы сэкономить на большом стрессе, вам придется прочитать книгу о GIT - я бы порекомендовал «Управление версией с GIT». Отказ И если вы можете доверять мне (или, точнее, мои шрамы), когда я говорю «нужно», из этого следует, что вы можете сделать это также сделать ТЕПЕРЬ. Отказ Большая часть сложности Git исходит от разветвления, а затем поспоримым. Но с вашего вопроса есть Нет причин, по которым люди должны ослеплять вас наукой.

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

PS: одна другая мысль: это (сейчас) на самом деле довольно просто сохранить репозиторий Git («REPO») в каталоге, отличном от единицы с рабочими файлами. Это будет означать, что вам не придется скопировать весь репозиторий Git, используя вышеупомянутое и грязное решение. Смотрите ответ Fryer, используя --sparate-git-dir здесь. Имейте в виду, хотя: если у вас есть «отдельный репозиторий», который вы не копируете, и вы делаете трудный сброс, все версии после сброса будут потеряны навсегда, если вы не должны, как следует, регулярно поддерживать Вверх по своему хранилищу, предпочтительно в облаке (например, Гугл Диск) среди других мест.

На эту тему «резервного копирования в облако» следующий шаг - открыть учетную запись (свободно, конечно) с GitHub или (лучше, по моему мнению) Gitlab. Тогда вы можете регулярно делать git push Команда для резервного копирования вашего Cloud Repo «правильно». Но опять же, говорить об этом, может быть слишком много слишком рано.

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

git revert <commit1> <commit2>

Образец:

git revert 2h3h23233

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

git revert HEAD~1..HEAD

а потом сделать git push

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

git reset --hard HEAD

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

Вернуться к старшему Commit: самый быстрый способ восстановления старой версии - использовать 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

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

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

Восстановление ревизии в Новая местная филиал

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

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

git checkout -b old-project-state 0ad5a7a6

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

Теперь у вас есть новая ветвь по имени старый проект-государство Отражая старую версию вашего проекта - не касаясь и даже не удалять какие -либо другие коммиты или филиалы.

Попробуйте сбросить до нужного Commit -

git reset <COMMIT_ID>

(Чтобы проверить использование commit_id git log)

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

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

git checkout .

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

ОБНОВИТЬ

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

git update-ref -d HEAD

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

Вам сначала нужно удалить развиваться из происхождения:

git push origin :develop (note the colon)

Тогда вам нужно получить разработку до желаемого статуса, позвольте мне предположить, что хэш коммита - это efghijk:

git reset --hard EFGHIJK

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

git push origin develop

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

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

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

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

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

git push -f

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow