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

avatar
Peter Mortensen
29 мая 2009 в 18:09
9779663
100
22982

Я случайно передал неправильные файлы в Git, но еще не отправил фиксацию на сервер.

Как я могу отменить эти коммиты из локального репозитория ?

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

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

Есть способ лучше?

Источник
Luzan Baral
27 февраля 2017 в 03:53
0

См. Это руководство для Git коммитов отмены в Local, Public и Git Branch Как отменить Git Commits как pro

Yimin Rong
20 марта 2018 в 01:45
210

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

Edric
5 октября 2018 в 14:50
23

@YiminRong Это можно сделать с помощью функции Git alias: git-scm.com/book/en/v2/Git-Basics-Git-Aliases

ashad
8 апреля 2019 в 12:15
8

Для пользователей VsCode просто введите ctrl + shift + G, а затем нажмите на три точки, то есть дополнительные параметры, а затем нажмите Отменить последнюю фиксацию.

Romain Valeri
24 марта 2020 в 14:27
2

@YiminRong Undo что именно ? Есть десятки очень разных функциональных случаев, когда «отмена» означает что-то совершенно . Готов поспорить, добавление новой причудливой «волшебной палочки» только еще больше запутает ситуацию.

Romain Valeri
25 марта 2020 в 13:23
20

@YiminRong Не покупаю. Люди по-прежнему будут возиться и отменять вещи, чтобы их нельзя было отменить. Но что более важно, git reflog уже близок к тому, что вы описываете, но дает пользователю больше контроля над тем, что нужно (не) делать. Но, пожалуйста, нет, «отменить» не везде одинаково, и люди ожидали, много разных вещей, чтобы реализовать эту функцию. Отменить последнюю фиксацию? Отменить последнее действие? Если последним действием было нажатие, как именно отменить (сбросить и нажать) или (вернуться и нажать)?

Honey
28 марта 2020 в 20:10
7

См. Диаграмму из Git. Он показывает все возможные способы испортить код и способы их устранения.

Nathan
2 мая 2020 в 19:14
1

@RomainValeri Правильная критика. Но «у х есть проблемы» не является достаточным аргументом для оправдания «не делай х».

Snowcrash
19 октября 2020 в 14:27
1

Чтобы сделать что-то простое в git, выполните либо невероятно сложную задачу A, либо невероятно сложную задачу B. Затем немного испортите ее и попробуйте вернуться, выполнив невероятно сложную задачу C или невероятно сложную задачу D.

Victor Schröder
23 июля 2021 в 15:02
0

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

StingyJack
7 августа 2021 в 18:36
0

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

Ответы (100)

avatar
Mark Amery
21 декабря 2020 в 16:53
25057

Отменить фиксацию и повторить

$ git commit -m "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~                              # (1)
[ edit files as necessary ]                    # (2)
$ git add .                                    # (3)
$ git commit -c ORIG_HEAD                      # (4)
  1. Эта команда отвечает за отмену . Он отменит вашу последнюю фиксацию, в то время как оставит ваше рабочее дерево (состояние ваших файлов на диске) нетронутым. Вам нужно будет добавить их снова, прежде чем вы сможете снова зафиксировать их).

  2. Внесите исправления в файлы рабочего дерева.

  3. git add все, что вы хотите включить в новую фиксацию.

  4. Зафиксируйте изменения, повторно используя старое сообщение фиксации. reset скопировал старую голову в .git/ORIG_HEAD; commit с -c ORIG_HEAD откроет редактор, который изначально содержит сообщение журнала из старой фиксации и позволяет вам редактировать его. Если вам не нужно редактировать сообщение, вы можете использовать параметр -C.

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

Чтобы удалить (не отменить) фиксацию, отправленную на сервер , необходимо переписать историю с помощью git push origin master --force.


Дополнительная литература

Как я могу переместить HEAD обратно в предыдущее место? (Отдельная голова) & Отменить коммиты

Приведенный выше ответ покажет вам git reflog, который вы можете использовать для определения SHA-1 для фиксации, к которой вы хотите вернуться. Получив это значение, используйте последовательность команд, как описано выше.


HEAD~ совпадает с HEAD~1. Статья Что такое HEAD в git? полезен, если вы хотите отменить несколько коммитов.

Frank Shearar
5 октября 2010 в 15:44
522

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

Ryan Lundy
13 апреля 2011 в 14:15
535

Если вы работаете в DOS, вместо git reset --soft HEAD^ вам нужно использовать git reset --soft HEAD~1. ^ - это символ продолжения в DOS, поэтому он не будет работать должным образом. Кроме того, по умолчанию используется --soft, поэтому вы можете опустить его, если хотите, и просто сказать git reset HEAD~1.

tnajdek
21 февраля 2013 в 17:47
144

Пользователи zsh могут получить: zsh: no matches found: HEAD^ - вам нужно избежать ^ т.е. git reset --soft HEAD\^

dmansfield
2 июля 2014 в 21:19
17

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

ThomasW
16 сентября 2016 в 05:56
8

В более поздних версиях git HEAD~ можно заменить на @~.

jterm
14 марта 2017 в 21:30
1

Это действительно не способ отменить набор изменений? Это больше, если нужно внести изменения?

user3613932
13 апреля 2017 в 18:08
4

Если вы уже отправили свои изменения в удаленную ветку и выполняете git reset, как показано выше, вы будете за удаленной веткой. В такой ситуации предпочтительнее использовать git revert <commit hash>, который добавит еще один коммит, который отменяет предыдущие изменения. Подробнее здесь

Mr5o1
13 сентября 2017 в 23:05
1

@Green Я думаю, это произойдет, если у вас есть только 1 коммит ... нет более раннего коммита, на который нужно выполнить сброс.

daGo
6 октября 2017 в 12:36
4

Это почти исчерпывающий ответ. В случае, если ваша 'последняя фиксация' === 'ваша первая фиксация' - сброс ничего не сделает, кроме выдачи приятного фатального сообщения. В этом случае используйте git update-ref -d HEAD.

microsaurus_dex
20 марта 2018 в 03:27
1

Также, если у вас слишком большие файлы, которые вам не принадлежат, и вы не можете завершить начальные коммиты. вы можете удалить .git, удалить слишком большие файлы. git init и commit -m 'начальная фиксация', а затем нажмите -u origin master

Mr. Tao
6 мая 2018 в 10:40
2

zsh пользователям следует отключить подстановку с помощью noglob git, чтобы избавиться от этого постоянного раздражения с помощью символа каретки ^.

briefy
7 ноября 2018 в 08:51
2

- git reset --hard HEAD ~ 1, вернется к одной фиксации и удалит все файлы, о которых знает git, но не неотслеживаемые файлы, поскольку git не имеет о них представления. - git reset HEAD ~ 1, сохранит все изменения текущего коммита, но сделает их неотслеживаемыми - git reset --soft HEAD ~ 1, сохранит ваши зафиксированные файлы в постановке, а неотслеживаемые файлы останутся неотслеживаемыми

Auxiliary Joel
28 июля 2019 в 23:45
1

Я случайно зафиксировал целую папку. поэтому я затем запустил git reset HEAD core /, который дал мне этот список «Неустановленные изменения после сброса:» (показывая все мои файлы основных папок / подпапок). Затем, когда я запустил 'git status', весь мой «основной» контент оказался под заголовком списка «Изменения, не предназначенные для фиксации:», что звучит хорошо. Затем я добавил ядро ​​в свой .gitignore. и снова запустил 'git status', но файлы продолжали появляться в списке «не подготовлено для фиксации». Я бы предпочел, чтобы git их даже не видел, но я не могу понять, как это сделать?

100pic
21 августа 2019 в 04:25
3

Я погуглил и попал на эту страницу около 50 раз, и я всегда посмеивался над первой строкой кода git commit -m "Something terribly misguided"

kaleidawave
8 ноября 2019 в 14:19
4

Выполнение первой команды дает fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.

thdoan
11 декабря 2019 в 01:17
1

Случайно я сделал git commit -m '...' files, предварительно не выполнив git add files, и заметил, что эти фиксация и push работают нормально. Я думаю, что git теперь достаточно умен, чтобы автоматически добавлять, когда вы используете git commit.

avatar
25 ноября 2021 в 11:15
2

В СЛУЧАЕ, ЕСЛИ ВЫ ХОТИТЕ ВЕРНУТЬСЯ К ПОСЛЕДНЕМУ КОММИТУ И ТАКЖЕ УДАЛИТЬ ИСТОРИЮ ЖУРНАЛА

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

git push origin +71e2e57458bde883a37b332035f784c6653ec509^:master

avatar
9 ноября 2021 в 01:17
3

Если вы используете GitHub desktop, слева под синей кнопкой Commit to BRANCH_NAME

будет кнопка отмены.

enter image description here

avatar
5 октября 2021 в 13:26
14

Отмена ряда локальных коммитов

OP: Как отменить последние локальные коммиты в Git? Я случайно зафиксировал неправильные файлы [в рамках нескольких коммитов].

Начальный случай

Есть несколько способов "отменить" серию коммитов, в зависимости от желаемого результата. Учитывая начальный случай ниже, reset, rebase и filter-branch можно использовать для перезаписи вашей истории.

Star-case

Как С1 и С2 необратимо удалить файл tmp.log от каждой фиксации?

В приведенных ниже примерах используются абсолютные ссылки фиксации, но это работает так же, если вы больше используете относительные ссылки (например, HEAD~2 или HEAD@{n}).

Вариант 1: reset

$ git reset --soft t56pi

using-reset

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

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

.

Вариант 2: rebase

$ git rebase --interactive t56pi

using-rebase

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

.

Пошагово

  1. Выберите, на каком коммите должна быть основана перебазировка (например, t56pi)
  2. Выберите, какие коммиты вы хотите изменить, заменив pick на edit. Сохраните и закройте.
  3. Git теперь будет останавливаться на каждом выбранном коммите, что позволит вам сбросить HEAD, удалить ненужные файлы и создать новые коммиты.

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

Вариант 3: filter-branch

$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD

Вышеупомянутая команда отфильтрует файл ./tmp.log из всех коммитов в желаемом диапазоне t56pi..HEAD (при условии, что наш начальный начальный случай описан выше). Для ясности см. иллюстрацию ниже.

using-filter-branch

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

Примечание: Точно так же, как и rebase, filter-branch сохранит остальные метаданные фиксации, отбросив только нужный файл. Обратите внимание, как C1 и C2 были переписаны, а файл журнала удалялся из каждой фиксации.

Вывод

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

Напоследок - дружеский совет

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

Источник: Все примеры выше взяты из этого блога.<63958592030

avatar
26 сентября 2021 в 17:50
14

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

First of all what is HEAD?

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

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


detached HEAD

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

Enter image description here

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

Enter image description here

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 to 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, а проверка нужной записи журнала ссылок вернет HEAD к этой фиксации.

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

git reflog
git checkout HEAD@{...}

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

Enter image description here


git reset --hard <commit_id>

"Переместите" свой HEAD обратно к нужному коммиту.

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

enter image description here


git revert <sha-1>

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

# Add a new commit with the undo of the original one.
# The <sha-1> can be any commit(s) or commit range
git revert <sha-1>

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

.

Enter image description here

avatar
18 августа 2021 в 12:35
54

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

git reset HEAD~1 --mixed
Ringo
15 ноября 2021 в 00:31
9

Правильный ответ без учебника по git.

Brent Woodruff
20 ноября 2021 в 20:31
2

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

avatar
CyberChris
23 июля 2021 в 22:00
14

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

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

1: Получите id = SHA коммита, который вы хотите получить, конечно

$ git log

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

$ git reset --hard 'your SHA'

3: Заставить новую локальную историю на вашем исходном GitHub с параметром -f (последний трек фиксации будет удален из истории GitHub)

$ git push origin master -f

Пример

$ git log

Последняя отменяемая фиксация

commit e305d21bdcdc51d623faec631ced72645cca9131 (HEAD -> master, origin/master, origin/HEAD)
Author: Christophe <blabla@bla.com>
Date:   Thu Jul 30 03:42:26 2020 +0200

U2_30 S45; updating files package.json & yarn.lock for GitHub Web Page from docs/CV_Portfolio...

Фиксация, которую мы хотим сейчас, на HEAD

commit 36212a48b0123456789e01a6c174103be9a11e61
Author: Christophe <blabla@bla.com>
Date:   Thu Jul 30 02:38:01 2020 +0200

First commit, new title

Достигните предыдущей фиксации, удалив последнюю

$ git reset --hard 36212a4

HEAD is now at 36212a4 First commit, new title

Проверить все в порядке

$ git log

commit 36212a48b0123456789e01a6c174103be9a11e61 (HEAD -> master)
Author: Christophe <blabla@bla.com>
Date:   Thu Jul 30 02:38:01 2020 +0200

    First commit, new title

$ git status

On branch master
Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.
 (use "git pull" to update your local branch)

nothing to commit, working tree clean

Обновите свою историю в Git (Hub)

$ git push origin master -f

Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/ GitUser bla bla/React-Apps.git
 + e305d21...36212a4 master -> master (forced update)

Убедитесь, что все в порядке

$ git status

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean
avatar
Paras Korat
23 июля 2021 в 21:57
27

Выполните следующие действия.

Шаг 1

Хит git log

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

Шаг 2

git reset <hash code>
Maf
11 марта 2021 в 16:23
0

Как после этого исправить неправильную фиксацию, чтобы исключить неправильные файлы?

avatar
JeremyWeir
23 июля 2021 в 21:56
8

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

git reset --hard origin/branch-name
avatar
Theo Itzaris
23 июля 2021 в 21:56
12

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

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

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

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

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

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

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 для отправки на сервер и редактирования истории.

git push --force origin master

avatar
Alisa
23 июля 2021 в 21:15
36

Чтобы избавиться от (всех изменений в) последней фиксации, последних 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

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

Кстати, около 7 букв хэша коммита достаточно, но в более крупных проектах вам может потребоваться до 12 букв, чтобы он был уникальным. Вы также можете использовать весь SHA коммита, если хотите.

Вышеуказанные команды также работают в GitHub для Windows.

avatar
FraK
23 июля 2021 в 21:09
60

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

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

    git reset --soft HEAD~1

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

git reset FILE

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

avatar
Carl
23 июля 2021 в 20:52
80

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

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

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

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

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

  1. Перейдите в свой репозиторий в командной строке и запустите графический интерфейс с git gui
  2. Выберите «Изменить последнюю фиксацию». Вы увидите свое последнее сообщение о фиксации, файлы, которые вы разместили, и файлы, которые не были.
  3. Теперь измените все так, как вы хотите, и нажмите "Подтвердить".
avatar
16 июля 2021 в 05:16
4
#1) $ git commit -m "Something terribly misguided" 
#2) $ git reset HEAD~                              

[редактировать файлы при необходимости]

 #3) $ git add .
#4) $ git commit -c ORIG_HEAD  
avatar
MontresorXPL
23 июня 2021 в 22:33
21

Чтобы удалить некоторые файлы из фиксации Git, используйте команду «git reset» с параметром «–soft» и укажите фиксацию перед HEAD.

$ git reset --soft HEAD~1

При выполнении этой команды вам будут представлены файлы из самой последней фиксации (HEAD), и вы сможете их зафиксировать.

Теперь, когда ваши файлы находятся в промежуточной области, вы можете удалить их (или деактивировать их), снова используя команду «git reset».

$ git reset HEAD <file>

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

Если вас просто больше не интересует этот файл, вы можете использовать команду «git rm», чтобы удалить файл из индекса (также называемого промежуточной областью).

$ git rm --cached <file>

Когда вы закончите с модификациями, вы можете просто снова зафиксировать их с помощью опции «–amend».

$ git commit --amend

Чтобы убедиться, что файлы были правильно удалены из репозитория, вы можете запустить команду «git ls-files» и убедиться, что файл не отображается в файле (если он, конечно, новый)

$ git ls-files

 <file1>
 <file2>

Удалить файл из фиксации с помощью Git Restore

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

$ git --version

Git версии 2.24.1

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

Чтобы установить новые версии Git, вы можете проверить это руководство. Чтобы удалить файлы из коммитов, используйте команду «git restore», укажите источник с помощью опции «–source» и файл, который нужно удалить из репозитория.

Например, чтобы удалить файл с именем «myfile» из HEAD, вы должны написать следующую команду

$ git restore --source=HEAD^ --staged  -- <file>

В качестве примера представим, что вы редактировали файл в своей последней фиксации в своей «главной» ветке.

Файл зафиксирован правильно, но вы хотите удалить его из репозитория Git.

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

$ git restore --source=HEAD^ --staged  -- newfile

$ git status

В ветке "master"

Ваша ветка опережает origin / master на 1 фиксацию. (используйте "git push" для публикации ваших локальных коммитов)

Изменения, которые необходимо зафиксировать:

 (use "git restore --staged <file>..." to unstage)
    modified:   newfile

Изменения, не поставленные для фиксации:

 (use "git add <file>..." to update what will be committed)
 (use "git restore <file>..." to discard changes in working directory)
      modified:   newfile

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

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

Удалить файл из репозитория Git

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

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

Чтобы отключить файл, используйте команду «git reset» и укажите HEAD в качестве источника.

$ git reset HEAD newfile

Если ваш файл правильно не настроен, используйте команду «git rm» с параметром «–cached», чтобы удалить этот файл из индекса Git (это не приведет к удалению файла на диске)

$ git rm --cached newfile

rm 'новый файл'

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

$ git status

В ветке 'master'

Ваша ветка опережает origin / master на 1 фиксацию. (используйте "git push" для публикации ваших локальных коммитов)

Изменения, которые необходимо зафиксировать:

 (use "git restore --staged <file>..." to unstage)
    deleted:    newfile

Теперь, когда ваш файл подготовлен, просто используйте «git commit» с опцией «–amend», чтобы изменить самую последнюю фиксацию из вашего репозитория.

`$ git commit --amend

 [master 90f8bb1] Commit from HEAD
  Date: Fri Dec 20 03:29:50 2019 -0500
  1 file changed, 2 deletions(-)
  delete mode 100644 newfile

`Как видите, это не создаст новую фиксацию, но существенно изменит самую последнюю фиксацию, чтобы включить ваши изменения.

Удалить определенный файл из фиксации Git

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

Чтобы удалить определенный файл из фиксации Git, используйте команду «git reset» с параметром «–soft», укажите фиксацию перед HEAD и файл, который вы хотите удалить.

$ git reset HEAD^ -- <file>

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

Во-первых, вы можете удалить файл из промежуточной области с помощью команды «git reset» и указать, что вы хотите выполнить сброс из HEAD.

$ git reset HEAD <file>

Примечание: это не означает, что вы потеряете изменения в этом файле, просто файл будет удален из промежуточной области.

Если вы хотите полностью удалить файл из индекса, вам нужно будет использовать команду «git rm» с параметром «–cached».

$ git reset HEAD <file>

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

$ git ls-files

Когда вы полностью закончите свои модификации, вы можете исправить коммит, из которого вы удалили файлы, используя команду «git commit» с параметром «–amend».

$ git commit --amend
Maf
11 марта 2021 в 16:37
0

В чем разница между использованием git rm file` and файла проверки git`?

avatar
Numan Gillani
23 июня 2021 в 22:30
2

Сначала запустите эту команду, чтобы сбросить фиксацию :

git reset --hard HEAD~1

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

git push upstream head -f
avatar
Chamod Dissanayake
23 июня 2021 в 22:27
1

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

Как я могу отменить коммиты в Git локально и удаленно?

avatar
arslan
23 июня 2021 в 22:14
17
git reset --soft HEAD~1

git status

Вывод

На главном сервере
Ваша ветка опережает origin / master на 1 коммит.
(используйте "git push" для публикации ваших локальных коммитов)

Изменения, которые необходимо зафиксировать:
(используйте "git restore --staged ..." для отключения) новый файл: file1

git log --oneline --graph

Выход

  • 90f8bb1 (HEAD -> master) Вторая фиксация \
  • 7083e29 Начальная фиксация репозитория \
avatar
11 июня 2021 в 21:58
2

Visual Studio Code делает это очень просто.

VS Code

Peter Mortensen
23 июня 2021 в 22:21
0

И это не было охвачено одним из предыдущих 151 ответов (не риторический вопрос)? (Включая удаленные ответы). В любом случае вы можете составить (аннотированный) список ссылок на похожие ответы (например, 152 ответа (включая удаленный ответ), так как 6 длинных длинных страниц затрудняют навигацию), чтобы упростить навигацию - скажем, те, которые содержат решения, использующие Код Visual Studio. (30 синонимов Visual Studio Code пока что наблюдались в дикой природе.)

Kyle Delaney
24 июня 2021 в 20:49
0

Нет, это не был.

avatar
AO_
27 мая 2021 в 23:13
12

Я писал об этом много лет назад после того, как сам столкнулся с такими же проблемами:

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

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

git log, получите первые семь символов хэша SHA, а затем выполните git revert <sha>, за которым следует git push --force.

Вы также можете отменить это, используя команду Git revert следующим образом: git revert <sha> -m -1, а затем git push.

avatar
Thiago
21 мая 2021 в 10:52
6

Самый простой способ:

$ git reset --soft HEAD~1

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

alakin_11
20 мая 2021 в 20:26
0

Я запускаю команду git reset, а затем просто принудительно нажимаю на свою ветку следующим образом: git push upstream head -f После этого фиксация исчезла.

avatar
poorva
10 апреля 2021 в 09:04
381

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

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

git log 

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

git reset --hard <commit_id>

git push origin <branch_name> -f
Jaime Montoya
27 сентября 2017 в 23:30
0

Что делать, если вы не используете «<commit_id>», а просто используете «git reset --hard»? Обычно я просто хочу избавиться от своих последних обновлений, которые я еще не зафиксировал, и вернулся к последней сделанной мной фиксации, и я всегда использую «git reset --hard».

poorva
28 сентября 2017 в 13:10
6

@JaimeMontoya Чтобы отменить последние изменения, вы можете использовать git reset --hard, но если вам нужно жестко удалить последние "n" коммитов, вы указываете SHA

avatar
Stipe
18 января 2021 в 20:44
48

Все так запутанно комментируют.

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

git reset --hard HEAD~1

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

git push --force

Вот и все. Это удалит вашу последнюю фиксацию.

CloudJR
14 марта 2020 в 11:58
5

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

Maf
11 марта 2021 в 16:29
0

Да, в случае, если нам нужно просто исправить фиксацию, мы не должны использовать --hard`, but leave it with the default --soft`, чтобы мы могли удалить и добавить что-то перед `git push -f`

avatar
18 января 2021 в 20:38
6
$ git commit -m 'Initial commit'
$ git add forgotten_file
$ git commit --amend

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

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

2.4 Основы Git - отмена действий

Maf
11 марта 2021 в 16:31
0

Что, если бы мы хотели вернуть один файл?

avatar
Peter Mortensen
18 января 2021 в 20:33
4

git reset HEAD@{n} сбросит ваши последние n действия.

Для сброса, для последнего действия используйте git reset HEAD@{1}.

avatar
lbragile
18 января 2021 в 20:28
5

Обычно я сначала нахожу хэш моей недавней фиксации:

git log

Это выглядит так: commit {long_hash}

Скопируйте этот long_hash и сбросьте его (вернитесь к тем же файлам / укажите, что он был в этой фиксации):

git reset --hard {insert long_hash without braces}
Maf
11 марта 2021 в 16:38
0

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

avatar
Peter Mortensen
18 января 2021 в 20:26
4

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

  1. Git клонирует репозиторий в другое место.
  2. Скопируйте модификации (файлы / каталоги) из исходного репозитория в этот новый. Затем зафиксируйте и нажмите с изменениями из нового.
  3. Замените старый репозиторий новым.
avatar
Sazzad Hissain Khan
20 июня 2020 в 09:12
50

Типичный цикл 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 (предположим, что файл2 добавлен как шаг 3, чего я не хотел)

    git reset $file2

  5. Фиксация файла file1, находящегося в $ 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.

Chaitanya Bapat
30 октября 2018 в 19:18
0

Что, если я работаю над вилкой, поэтому в основном у меня есть 2 пульта дистанционного управления, например incubator-mxnet и мое разветвленное репо ChaiBapchya / incubator-mxnet Итак, в таком случае, как я могу разрешить конфликты слияния из локальной ветки в мою разветвленную ветку репо

avatar
20 июня 2020 в 09:12
14

enter image description here

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

avatar
Ankit Tiwari
17 июня 2020 в 09:54
47

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

git reset --soft HEAD~1

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

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

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

git reset --hard HEAD~1
avatar
KawaiKx
13 декабря 2019 в 16:40
58

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

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

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

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

git push --force-with-lease

Версия форсированной версии 'with-lease' предотвращает случайное удаление новых коммитов, о которых вы не знаете (т. Е. Исходящих из другого источника с момента вашего последнего извлечения).

AeroHil
6 мая 2019 в 20:36
1

это сработало для меня лучше всего, так как я уже перенес плохую фиксацию на github

avatar
Ravi_Parmar
13 декабря 2019 в 16:39
215

«Сбросить рабочее дерево до последней фиксации»

git reset --hard HEAD^ 

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

git clean    

см. - Краткий справочник Git

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

avatar
23 октября 2019 в 09:19
16

Чтобы отменить последнюю локальную фиксацию, не отбрасывая ее изменения, у меня есть удобный псевдоним в ~/.gitconfig

[alias]
  undo = reset --soft HEAD^

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

avatar
CodeWizard
14 октября 2019 в 14:42
68

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

First of all what is HEAD?

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

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


detached HEAD

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

enter image description here

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

enter image description here

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, и проверка нужной записи в журнале ссылок вернет HEAD обратно в эту фиксацию.

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

git reflog
git checkout HEAD@{...}

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

enter image description here


git reset --hard <commit_id>

«Переместите» вашу HEAD обратно в желаемую фиксацию.

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

git revert <sha-1>

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

# add new commit with the undo of the original one.
# the <sha-1> can be any commit(s) or commit range
git revert <sha-1>

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

enter image description here

avatar
Ali Motameni
5 августа 2019 в 19:24
97

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

enter image description here

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

enter image description here

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

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

    git reset --soft HEAD^

    enter image description here

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

    git reset --hard HEAD^

    enter image description here

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

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

    enter image description here

avatar
shiraz
10 июля 2019 в 20:27
13

Замените локальную версию, включая изменения, версией сервера. Эти две строки кода заставят Git извлечь и перезаписать локальную.

Откройте командную строку и перейдите в корень проекта Git. Если вы используете Visual Studio, нажмите Team , Sync и нажмите «Открыть командную строку» (см. Изображение) ниже.

Visual Studio

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

git fetch --all

Затем вы делаете

git reset --hard origin/master

Это заменит существующую локальную версию версией на сервере Git.

avatar
Abu Bakr
10 июля 2019 в 20:25
29
git reset --soft HEAD~1

Reset вернет текущую ветку HEAD к указанной версии.

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

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

 git reset --hard HEAD~1

Отмена нескольких коммитов

git reset --hard 0ad5a7a6

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

Enter image description here

avatar
Videsh
10 июля 2019 в 20:24
8

Вы можете использовать git revert <commit-id>.

А для получения идентификатора фиксации просто используйте git log.

avatar
V V
13 марта 2019 в 05:22
45

Удалить неправильную фиксацию, которая уже отправлена ​​в Github

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

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

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

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

avatar
Ankit Patidar
13 марта 2019 в 05:18
63

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

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

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

Здесь --soft означает сброс в промежуточное состояние.

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

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

git commit --amend -m "message"

Он заменит последнюю фиксацию новой фиксацией.

avatar
Dominic Cerisano
18 января 2019 в 20:09
22

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

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

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

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

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

avatar
21 декабря 2018 в 02:02
26

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

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

Возьмем пример:

- A - B - C (master)

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

- soft

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

- смешанный

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

- жесткий

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

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

avatar
10 декабря 2018 в 07:05
24

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

git reset HEAD^

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

avatar
nobar
7 декабря 2018 в 05:57
465

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

Используйте 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)

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

Brent Bradburn
18 октября 2014 в 23:38
11

gitk --all $(git reflog | cut -c1-7)& может быть полезным для поиска предыдущей ревизии, если вы хотите отменить фиксацию '--amend'.

Jherico
4 сентября 2015 в 04:52
6

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

Brent Bradburn
28 марта 2018 в 14:59
0

Я думаю, что «частный» / «общедоступный» правильнее было бы быть «локальным» / «удаленным».

Brent Bradburn
7 сентября 2018 в 12:09
0

Исправить частную ветку в удаленном репозитории также можно с помощью простого git push origin (branch_name) --force

avatar
Nalan Madheswaran
6 декабря 2018 в 22:00
10

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

git log

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

git revert <commit_id>
Rémi P
21 ноября 2018 в 13:05
0

В чем разница с ответом @JacoPretorius?

avatar
shreshta bm
10 ноября 2018 в 09:27
30

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

avatar
mfathy00
10 ноября 2018 в 09:26
57

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

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

Eugen Konkov
15 декабря 2016 в 16:25
0

Будьте особенно осторожно при отмене коммитов слияния. Вы можете потерять свои коммиты. Прочтите, что об этом говорит Линус: kernel.org/pub/software/scm/git/docs/howto/…

avatar
Eugen Konkov
10 ноября 2018 в 09:16
25

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

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

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit
avatar
Tom Hale
20 октября 2018 в 12:30
8

Как отредактировать более раннюю фиксацию

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

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

Вот рабочий процесс:

  1. git commit-edit <commit-hash>
    

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

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

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

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

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

    git commit --amend
    
  4. Завершить перебазирование:

    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://coderhelper.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
avatar
Praveen Singh
19 октября 2018 в 18:15
15

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

git log

Тогда

git reset <the previous co>
avatar
Peter Mortensen
19 октября 2018 в 18:15
18

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

avatar
Mohideen ibn Mohammed
19 октября 2018 в 18:13
21

HEAD :

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

Git commit:

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

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

Метод 1: (если вы не знаете номер фиксации, но хотите перейти к самому первому)

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

Метод 2: (если вы знаете фиксацию, вы просто сбрасываете ее на известную фиксацию)

git reset 0xab3 # Номер фиксации

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

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

Enter image description here

avatar
Shwetank
19 октября 2018 в 18:10
28

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

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

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

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

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

avatar
Eugen Konkov
19 октября 2018 в 18:08
23

Вот сайт: 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 :)
avatar
Raj S. Rusia
19 октября 2018 в 18:07
25

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

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

Enter image description here

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

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

Enter image description here

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

Enter image description here

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

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

Enter image description here

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

Enter image description here

avatar
Nicholas
3 октября 2018 в 03:07
11

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

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

$ 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 .
avatar
Gjorgi Gjorgiev
26 сентября 2018 в 10:33
7
git revert commit

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

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

avatar
user3799762
19 августа 2018 в 14:00
134

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

Команда 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 - идентификатор фиксации.

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

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

$ git reset --hard d81d3f1

или

$ git reset --hard HEAD~1

Предположим, вы хотите отменить фиксацию be20eb8:

$ git reset --hard be20eb8

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

$ git reset --help
Arnis Juraga
21 марта 2017 в 12:09
8

git reset --hard HEAD~1 - это слишком опасно ! Это не просто «отменит последнюю фиксацию», но полностью вернет репо к предыдущей фиксации. Таким образом, вы ПОТЕРЯЕТЕ все изменения, сделанные в последней фиксации!

Benny
24 апреля 2017 в 13:07
0

Вы правы, чтобы отменить это, вы можете использовать git push -f <remote> HEAD@{1}:<branch>

anonymous
19 августа 2018 в 13:53
0

К сожалению, я использую --hard, и мои файлы удаляются! Я сначала не проверял комментарий, потому что он свернут. Не используйте --hard, если не знаете, что делаете!

avatar
Khem
2 июля 2018 в 18:21
18

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

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

git rebase --onto HEAD~1 HEAD

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

a -> b -> c -> d -> главный

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

git rebase --onto b c

Это сделает 'b' новым основанием 'd', исключив 'c'

avatar
18 мая 2018 в 07:00
4
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
avatar
17 апреля 2018 в 15:41
12

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

git reset --hard <commit_hash>

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

avatar
Mohit
28 января 2018 в 21:34
75

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

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

В этих случаях вам лучше всего подойдет команда «reset»:

$ git reset --soft HEAD~1

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

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

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

$ git reset --hard HEAD~1

Enter image description here

Peter Mortensen
28 января 2018 в 21:36
0

"Рабочая копия"? Это концепция Git? Разве это не концепция SVN?

Mohit
4 мая 2018 в 19:46
0

@PeterMortensen да рабочая копия, хотя это концепция git

avatar
akshay_rahar
13 декабря 2017 в 22:05
171

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

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

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

Здесь --soft означает сброс в промежуточное состояние.

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


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

git commit --amend -m "message"

Последняя фиксация будет заменена новой.

avatar
Alireza
27 октября 2017 в 12:46
280

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

git reset --soft HEAD~1

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

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

How to undo the last commits in Git?

avatar
Peter Mortensen
12 июня 2017 в 13:21
127

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

avatar
Ranadheer Reddy
12 апреля 2017 в 10:31
21

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

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

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

Git Extensions screen shot

Откроется всплывающее окно (см. Снимок экрана ниже)

Revert commit popup

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

avatar
Fadid
25 марта 2017 в 09:24
31

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

git checkout -b old-state number_commit
avatar
Alexandr
25 марта 2017 в 09:22
61

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

Щелкните правой кнопкой мыши на фиксации, затем выберите « Сбросить (текущая ветвь) / ведущее устройство для этой фиксации » и выберите <1961920622190> в последнюю очередь <19619619> > «Мягкий» сброс .

Enter image description here

avatar
amd
25 марта 2017 в 08:24
132

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

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

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

Почему?

Если вы по ошибке выберете --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.

Eugen Konkov
15 декабря 2016 в 16:29
9

Очень полезное описание различий --soft VS --hard atlassian.com/git/tutorials/…

Todd
11 сентября 2017 в 14:10
2

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

avatar
Min Han
25 марта 2017 в 08:23
78

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

git reset HEAD@{1}

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

Zaz
4 августа 2016 в 08:36
10

Или git reset @~

avatar
Tom Stickel
25 марта 2017 в 08:22
51

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

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

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

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

git reset --hard HEAD~1

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

avatar
ioopl
25 марта 2017 в 08:21
40

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

git checkout commitID .

Пример:

git checkout 7991072 .

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

cSharma
22 мая 2019 в 14:02
0

Примечание: проверка 5456cea9. Вы находитесь в состоянии «отключенная ГОЛОВА». Вы можете осмотреться, внести экспериментальные изменения и зафиксировать их, а также отменить любые фиксации, сделанные в этом состоянии, не влияя на какие-либо ветки, выполнив еще одну проверку. Если вы хотите создать новую ветку для сохранения созданных вами коммитов, вы можете сделать это (сейчас или позже), снова используя -b с командой checkout. Пример: git checkout -b <new-branch-name> HEAD теперь находится на 5456cea ... Необходимо удалить Exclusions.xslt из папки документации. - Удалить Что делать после этого

avatar
Yahs Hef
25 марта 2017 в 08:14
38

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

    git commit --amend

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

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

, если это общая или общедоступная ветвь.

avatar
Ranjithkumar Ravi
25 марта 2017 в 08:14
257

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

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

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

    git reset --hard HEAD^
    
  2. Если вы хотите сохранить изменения:

    git reset --soft HEAD^
    

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

avatar
thestar
16 сентября 2016 в 07:25
135

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

git reset --hard HEAD~1
cr7pt0gr4ph7
24 ноября 2014 в 22:35
23

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

cr7pt0gr4ph7
24 ноября 2014 в 22:40
6

Однако, если вы сделаете это случайно, не все потеряно. См. coderhelper.com/questions/10099258/…, coderhelper.com/questions/15479501/… и coderhelper.com/questions/reset-o7. жесткий / 7376959.

Yunus Nedim Mehel
9 марта 2015 в 09:11
13

Используйте --soft, чтобы сохранить ваши изменения как uncommitted changes, --hard, чтобы полностью уничтожить фиксацию и вернуться на единицу. Не забывайте делать такие операции только с изменениями, которые еще не внесены.

cr7pt0gr4ph7
13 сентября 2016 в 21:17
0

@Zaz: Вы правы; возможно, мне следовало это прояснить. Возможно восстановление только файлов / изменений, которые были либо добавлены в индекс (/ staged), либо зафиксированы. Незавершенные, неустановленные изменения , как вы сказали, полностью отбрасываются git reset --hard.

cr7pt0gr4ph7
13 сентября 2016 в 21:22
1

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

avatar
29 мая 2016 в 14:21
21

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

avatar
ihue
18 января 2016 в 21:58
148

Просто, запустите это в командной строке:

git reset --soft HEAD~ 
avatar
dseminara
11 января 2016 в 23:50
137

Есть два основных сценария

Вы еще не отправили фиксацию

Если проблема заключалась в добавленных вами дополнительных файлах (и они не нужны вам в репозитории), вы можете удалить их с помощью git rm, а затем выполнить фиксацию с помощью --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, а также будут удалены GC из вашего локального репозитория .git.

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

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

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

avatar
6 июля 2015 в 08:30
32

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

git checkout -b old-state 0d1d7fc32
avatar
CommaToast
24 июня 2015 в 09:34
168

Другой способ:

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

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

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

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

avatar
Peter Mortensen
24 июня 2015 в 09:34
158

Введите git log и найдите последний хэш-код фиксации, а затем введите:

git reset <the previous co>
avatar
Varun Parakh
24 июня 2015 в 09:34
318

На SourceTree (графический интерфейс для 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.
avatar
egridasov
24 июня 2015 в 09:34
152

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

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

avatar
U. Ali
24 июня 2015 в 09:33
180

Первый запуск:

git reflog

Он покажет вам все возможные действия, которые вы выполнили в своем репозитории, например, фиксацию, слияние, извлечение и т. Д.

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

git reset --hard ActionIdFromRefLog
avatar
steven
18 мая 2015 в 16:55
66

Просто отмените последнюю фиксацию:

git reset --soft HEAD~

Или отменить время перед последней фиксацией:

git reset --soft HEAD~2

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

git reset --soft <commitID>

(вы можете получить идентификатор фиксации, используя git reflog)

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

git clean

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

avatar
santos_mgr
25 сентября 2014 в 07:58
376

Если вы передали мусор, но не отправили его,

git reset --soft HEAD~1

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

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

ИЛИ

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

git revert HEAD

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

metaforge
12 ноября 2014 в 19:36
0

У меня второй случай, но когда я делаю «git revert HEAD», он говорит: «Ошибка: фиксация [ID] - это слияние, но не задана опция -m. Fatal: revert failed». Какие-либо предложения?

ccpizza
7 декабря 2014 в 00:38
5

Вероятно, стоит упомянуть, что вместо HEAD~1 вы можете использовать фактический хэш, отображаемый git log --stat или git reflog - полезно, когда вам нужно «отменить» более одной фиксации.

avatar
geoom
21 июля 2014 в 20:15
136

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

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) Страница руководства .

avatar
Manish Shrivastava
21 июля 2014 в 20:13
297

Одна команда:

git reset --soft 'HEAD^' 

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

Ena
23 апреля 2014 в 09:13
15

Мне нужно было написать git reset --soft «HEAD ^» в двойных кавычках, потому что я пишу это из командной строки Windows.

avatar
6 января 2014 в 22:34
205

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

git reflog

reflog before ОБНОВЛЕНИЕ ПЕРЕД СБРОСОМ

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

git reset --hard f3cb6e2

После этого HEAD репо будет сброшен на этот HEADid reset effect ЖУРНАЛ ПОСЛЕ СБРОСА

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

reflog after РЕФЛОГ ОКОНЧАТЕЛЬНЫЙ

avatar
Madhan Ayyasamy
31 января 2013 в 07:06
601

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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

Еще (ссылка не работает) (Архивная версия)

Madhan Ayyasamy
14 декабря 2015 в 15:34
17

@SMR, в вашем примере все указывают только на текущую HEAD. ГОЛОВА ^ = ГОЛОВА ^ 1. А также HEAD ^ 1 = HEAD ~ 1. Когда вы используете HEAD ~ 2, есть разница между символами ~ и ^. Если вы используете ~ 2, это означает «первый родитель первого родителя» или «дедушка или бабушка».

Rob Mosher
20 декабря 2020 в 10:55
0

git reset --hard HEAD ^ 1 дает мне эту ошибку «фатальный: неоднозначный аргумент 'HEAD1': неизвестная ревизия или путь не в рабочем дереве».

Maf
11 марта 2021 в 16:41
0

Как насчет удаления некоторых файлов из фиксации и сохранения других?

avatar
Steven Penny
25 октября 2012 в 03:41
490

Я предпочитаю использовать 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 удалит коммиты для любой строки, которую вы удаляете.

FredL
24 июля 2020 в 13:23
0

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

avatar
Jaco Pretorius
25 мая 2012 в 16:04
748

Используйте git revert <commit-id>.

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

astronomerdave
13 января 2015 в 22:05
19

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

Casey Robinson
25 января 2016 в 21:07
0

Я просто использовал git revert commit-id работал как шарм. Конечно, тогда вам нужно будет продвигать свои изменения.

Tom Howard
20 октября 2016 в 18:19
9

Думаю, это будет git cherry-pick <<erroneous-commit-sha>> @astronomerdave. От, г. Почти-2-летнего-опоздания-к-вечеринке.

Eugen Konkov
10 ноября 2018 в 09:38
0

@Kris: Вместо вишневого выбора используйте rebase. Потому что это продвинутый сбор вишни

Hola Soy Edu Feliz Navidad
6 февраля 2020 в 12:40
0

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

avatar
neoneye
6 апреля 2012 в 13:58
516

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

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 git@bitbucket.org:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>
Brad Koch
7 декабря 2012 в 16:02
31

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

neoneye
8 декабря 2012 в 14:14
0

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

Mikko Rantalainen
7 августа 2013 в 10:10
7

«Как и в реальном мире, если вы хотите переписать историю, вам нужен заговор: все должны участвовать в заговоре (по крайней мере, все, кто знает историю, то есть все, кто когда-либо выходил из ветки) . " Источник: coderhelper.com/a/2046748/334451

avatar
nickf
13 декабря 2011 в 10:18
554

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

avatar
Ryan Lundy
28 июля 2011 в 22:22
11411

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

вариант 1: git reset --hard

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

   (F)
A-B-C
    ↑
  master

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

git reset --hard HEAD~1

Результат:

 (F)
A-B
  ↑
master

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

вариант 2: git reset

А, но предположим, что фиксация 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. Вы ничего не потеряли!

вариант 3: git reset --soft

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

git reset --soft HEAD~1

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

вариант 4: вы сделали git reset --hard и вам нужно вернуть этот код

И еще кое-что: Предположим, вы уничтожили фиксацию , как в первом примере, , но потом обнаружили, что она вам все-таки нужна ? Не повезло, правда?

Нет, есть еще способ вернуть его. Введите git reflog, и вы увидите список (частичных) фиксаций shas (то есть хэшей), в которые вы переместились. Найдите уничтоженную фиксацию и сделайте следующее:

git checkout -b someNewBranchName shaYouDestroyed

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

dma_k
25 февраля 2012 в 13:31
2

@Kyralessa: Если я сделаю git reset --hard HEAD^ дважды, изменится ли состояние на (A)?

Adam
22 июня 2012 в 10:53
0

Не работает с OS x. - Я получаю «неоднозначный аргумент 'HEAD ^' ... Неизвестная ревизия или путь не в рабочем дереве». Использование версии с тильдой не имеет значения. Но git log и git status, похоже, показывают, что на месте есть действительная фиксация.

Adam
22 июня 2012 в 12:35
1

@Kyralessa - да, я думаю, это может быть проблемой. В этом случае я совершил что-то, что, как мне казалось, было небольшим, и когда я попытался нажать, я обнаружил, что это 400 МБ данных (!) (Глубоко вложенная папка ресурсов, содержащая видео и музыкальные файлы). Итак, мне нужно отменить фиксацию, но сохранить исходные файлы, и я зафиксирую их позже, когда у меня будет лучшее сетевое соединение - или в другое репо.

TwainJ
30 октября 2012 в 06:09
1

Спасибо также за объяснение. Вопрос по поводу этого утверждения (re --hard): «ваши файлы сбрасываются до своего состояния при фиксации B». Скажем, я зафиксировал только некоторые из моих модификаций, другие файлы предназначены для будущих коммитов. На сколько я сбрасываю? Только зафиксированные файлы? Или мне сбросить весь рабочий набор?

Danny
1 февраля 2013 в 19:39
3

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

Chris Kerekes
20 февраля 2013 в 18:46
44

ОСТЕРЕГАТЬСЯ! Это могло бы не сработать, если бы ваша ошибочная фиксация была слиянием (перемоткой вперед)! Если ваша голова находится на фиксации слияния (например, функция объединенной ветки в главную), git reset --hard~1 будет указывать в главной ветке на последнюю фиксацию внутри ветки функции. В этом случае вместо относительной команды следует использовать конкретный идентификатор фиксации.

Chris Kerekes
21 февраля 2013 в 14:05
1

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

Šime Vidas
13 августа 2013 в 14:37
10

Обратите внимание на то, что число в HEAD~1 можно заменить на любое положительное целое число, например HEAD~3. Это может показаться очевидным, но новички (такие как я) очень осторожны при запуске команд git, поэтому они могут не захотеть рискнуть что-то испортить, тестируя эти вещи самостоятельно.

GreenAsJade
5 сентября 2013 в 03:10
2

Может ли кто-нибудь прокомментировать «что, если вы уже нажали фиксацию?». Этот ответ по-прежнему актуален или от этого все усложняется?

Phlucious
24 октября 2013 в 21:54
1

Отличный совет. Просто использовал его, хотя я думаю, уместно отметить, что любые теги, связанные с удаленной фиксацией, будут продолжать существовать, даже если они не появятся в gitk. Удалите его с помощью «git tag -d XXXXX», где XXXXX - имя тега.

FractalSpace
8 ноября 2013 в 23:43
137

Отсутствует важный момент: если упомянутая фиксация была ранее «отправлена» на удаленный компьютер, любая операция «отмены», какой бы простой она ни была, вызовет огромную боль и страдания для остальных пользователей, у которых есть эта фиксация в их локальной копии, когда они сделают «git pull» в будущем. Итак, если фиксация уже была отправлена, сделайте это вместо этого: git revert <bad-commit-sha1-id> git push origin:

Ryan Lundy
9 ноября 2013 в 00:00
24

@FractalSpace, это не вызовет «огромной боли и страданий». Я сделал несколько принудительных толчков при использовании Git в команде. Все, что нужно, - это общение.

FractalSpace
9 ноября 2013 в 03:02
24

@Kyralessa На моем рабочем месте испортила рабочий процесс всей команды, а затем рассказала им, как исправить дерьмо, не называется «общением». git history re-write - это деструктивная операция, которая приводит к удалению частей репо. Настаивать на его использовании при наличии ясных и безопасных альтернатив просто безответственно.

Ellen Spertus
20 февраля 2014 в 10:48
1

@ Киралесса, у меня вопрос по поводу твоего ответа. Вы говорите, что "git reset --soft" "не только оставляет ваши файлы в покое, он даже оставляет в покое ваш индекс. Когда вы сделаете git status, вы увидите, что те же файлы находятся в индексе, что и раньше. Фактически, верно после этой команды вы можете выполнить git commit и повторить только что сделанную фиксацию ". Но если «git reset --soft» не изменяет индекс, «git commit» ничего не сделает. Вы имеете в виду «git commit -a» (при условии, что заранее не было изменений в рабочем каталоге) или я что-то упустил (что более вероятно)?

Ryan Lundy
20 февраля 2014 в 14:28
3

@espertus, возможно, один из способов взглянуть на это заключается в том, что здесь работают три вещи: ваши файлы, ваш индекс и ваша история (то есть указатель вашей ветки). Допустим, вы находитесь на фиксации C (как указано выше). Ваши файлы, индекс и указатель ветки совпадают. Если вы используете git reset --soft HEAD ~ 1, указатель вашей ветки переместится обратно в B, но ваши файлы и индекс останутся в своих версиях в C. Если вы используете git reset --mixed HEAD ~ 1, ваш указатель ветки и индекс переместятся обратно в B, но ваши файлы остаются в своем состоянии в C. Затем ваши файлы показывают изменения, а ваш индекс - нет. git reset --hard HEAD ~ 1 перемещает все три назад.

Ellen Spertus
20 февраля 2014 в 16:08
1

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

fspinnenhirn
19 августа 2014 в 03:13
3

Сброс демистифицированного Скотта Чакона (GitHub CIO, Pro Git автор) объясняет и иллюстрирует команду git reset и то, как переместить HEAD (--soft), обновить индекс (--mixed, по умолчанию ) и обновите рабочий каталог (--hard) снизу вверх. Я всегда использовал ответ Киралессы в качестве шпаргалки, но сообщение в блоге Скотта наконец заставило его щелкнуть и прижиться!

Nick Volynkin
6 июля 2015 в 11:09
1

Приняты ваши иллюстрации с некоторыми улучшениями. ru.coderhelper.com/a/431521/181472

matanster
15 октября 2015 в 17:10
1

ссылка на index, добавленная в контексте, плюс комментарий о резервном копировании всего вашего проекта в качестве меры предосторожности @Kidburla.

joelostblom
7 января 2017 в 03:12
1

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

Alfe
13 сентября 2017 в 12:09
1

@ Киралесса, ясно. Но что лучше говорить о «шасах», чем о «хешах»? На странице руководства git упоминаются только хеши и «хеши SHA-1». Вопрос скорее в следующем: что лучше всего улучшает ответ?

Jaime Montoya
27 сентября 2017 в 23:35
2

В чем разница между git reset --hard HEAD~1 и git reset --hard, если вам нужно просто избавиться от всех изменений, внесенных вами после последнего коммита? Я всегда использую git reset --hard, и это возвращает меня к моей последней фиксации. По аналогии, я чувствую, что это своего рода закрытие приложения без сохранения изменений, так что все, что было в памяти RAM, теряется, но то, что у вас было в памяти ROM, сохраняется, используя ваш последний коммит в качестве памяти ROM в этой аналогии, и ваши изменения, которые не были зафиксированы как материал в оперативной памяти, который еще не был сохранен.

Jaime Montoya
28 сентября 2017 в 15:00
1

Ссылаясь на @poorva из комментариев в других сообщениях ниже: «Чтобы отменить последние изменения, вы можете использовать git reset --hard, но если вам нужно жестко удалить последние« n »коммитов, вы указываете SHA».

ruckc
24 октября 2017 в 20:32
1

Можете ли вы изменить порядок публикации, чтобы --soft было первым показанным предложением? Один из наших инженеров не прочитал всю статью и использовал --hard для общего рабочего каталога, что, к счастью, стоило нам всего одного дня работы. - Спасибо. P.S. Да, мы знаем, что использование общих рабочих каталогов - плохая практика, но это не хранение кода, а конфигурация марионетки.

gangelo
19 декабря 2017 в 20:53
1

Я пытаюсь выполнить git reset --soft HEAD ~ 1 и получаю следующее: почему ?: fatal: неоднозначный аргумент «HEAD ~ 1»: неизвестная версия или путь не в рабочем дереве. Используйте '-', чтобы отделить пути от ревизий, например: 'git <command> [<revision> ...] - [<file> ...]'

Ryan Lundy
19 декабря 2017 в 21:05
0

@gangelo, сколько коммитов у вас в репозитории? Больше одного? Трудно выполнить сброс до любой фиксации, поэтому я обычно запускаю репо с «фиктивной» фиксацией (например, с пустым файлом .gitignore), чтобы обойти этот тип проблемы.

gangelo
19 декабря 2017 в 21:28
0

@Kyralessa У меня есть только 1 коммит, но он не выдвинут, потому что, как ни странно, мне нужно вытащить мой файл .gitignore из моего репозитория. Думаю, я могу зафиксировать и применить .gitignore постфактум, но я не помню, как это сделать, и помню, что это было проблемой. Я хочу только отменить фиксацию, которая у меня есть, до такой степени, что, если я сделаю «git status», я увижу, что все мои файлы отслеживаются и готовы к фиксации, как будто этого никогда не было.

Ryan Lundy
20 декабря 2017 в 07:59
0

@gangelo, посмотрите здесь несколько идей о том, как отменить эту первую фиксацию: coderhelper.com/questions/6632191/…

briefy
7 ноября 2018 в 04:27
0

- git reset --hard HEAD ~ 1, вернется к одной фиксации и удалит все файлы, о которых знает git, но не неотслеживаемые файлы, поскольку git не имеет о них представления. - git reset HEAD ~ 1, сохранит все изменения текущего коммита, но сделает их неотслеживаемыми - git reset --soft HEAD ~ 1, сохранит ваши зафиксированные файлы в постановке, а неотслеживаемые файлы останутся неотслеживаемыми

Pztar
9 января 2019 в 20:20
0

Это здорово. Супер полезно, если ваша последняя фиксация была «стиранием», но вы хотите реорганизовать ее в более значимые коммиты, и в этом случае используйте. git reset --soft HEAD~1

Murilo
13 мая 2019 в 17:09
1

Как упоминал @Kidburla, при использовании git reset --hard HEAD~1 удаляются текущие изменения, которые не были зафиксированы. Это немного сбивает с толку, потому что кажется, что (F) представляет эти изменения, а вы оставляете (F) после reset --hard. Должно быть предупреждение или что-то еще, чтобы люди не могли удалить свои изменения. Или вы также можете представить «незафиксированные изменения» в примерах.

rinogo
13 августа 2020 в 19:16
2

Учитывая, сколько раз я гуглил, думаю, мне нужно татуировать git reset --soft HEAD~1 на тыльной стороне руки.

Farid
17 марта 2021 в 05:29
0

@ChrisKerekes Это на самом деле нужно отредактировать и включить в ответ.

avatar
Andrew
16 июня 2011 в 17:27
2356

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

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

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

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 - Отмена действий .

nacho4d
14 июля 2011 в 08:32
118

Я нашел этот ответ наиболее ясным. git revert HEAD^ не является предыдущим, является предыдущим из предыдущего. Я сделал: git revert HEAD, а затем снова нажал, и это сработало :)

tar
5 марта 2020 в 15:50
5

Если Git спросит вас "Еще?" когда вы попробуете эти команды, используйте альтернативный синтаксис в этом ответе: coderhelper.com/a/14204318/823470

carloswm85
31 июля 2021 в 22:25
0

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

avatar
Zaz
31 июля 2010 в 09:39
845

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

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

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

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

git commit --amend

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

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

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


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

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

$ 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

BKSpurgeon
8 августа 2018 в 07:11
4

Для тех, кто читает в будущем - обратите внимание, что git revert - это отдельная команда, которая в основном «сбрасывает» один коммит.

avatar
bdonlan
29 мая 2009 в 18:16
1824

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

git rm classdir
git add sourcedir

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

git commit --amend

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

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

egorlitvinenko
15 мая 2020 в 10:03
8

К вашему сведению: это удалит все мои файлы, и я потерял изменения.

egorlitvinenko
15 мая 2020 в 11:25
0

UPD: Однако я восстановил его с помощью reflog. Но квитанция не сработала для первоначального коммита.

xuiqzy
19 мая 2020 в 10:00
4

Используйте git rm --cached, чтобы хранить файлы в файловой системе и удалять их только из индекса git!

avatar
Lennart Koopmann
29 мая 2009 в 18:13
1109
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 переведет вашу рабочую копию в состояние фиксации перед ошибочной фиксацией.

trejder
21 июня 2014 в 16:31
25

git commit -a -m "" или git commit -am "" естественно! :]

seanriordan08
8 декабря 2015 в 22:30
0

Еще одно «сокращенное» использование тайника; если вы хотите отключить все (отменить git add), просто git stash, затем git stash pop