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

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

git push origin +71e2e57458bde883a37b332035f784c6653ec509^:master

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

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

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

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

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

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

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

Вариант 1: reset

$ git reset --soft t56pi

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

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

Вариант 2: rebase

$ git rebase --interactive t56pi

Используя интерактивный 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 (при условии, что наш начальный начальный случай описан выше). Для ясности см. иллюстрацию ниже.

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

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

Вывод

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

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

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

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

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

First of all what is HEAD?

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

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

detached HEAD

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

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
git checkout 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.

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

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

git reset HEAD~1 --mixed

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

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

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

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

Шаг 1

Хит git log

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

Шаг 2

git reset <hash code>

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

git reset --hard origin/branch-name

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

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

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

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

• git add <file names> & git commit -m "message" -m "details"

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

• git checkout <filename>

5. , если я уже отправил его на удаленный источник, ранее:

• git push origin <branch name> -f // используйте -f для принудительного нажатия.

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

git reset --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

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

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

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

    git reset --soft HEAD~1

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

git reset FILE

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

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

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

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

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

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

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

#1) $ git commit -m "Something terribly misguided" 
#2) $ git reset HEAD~                              

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

 #3) $ git add .
#4) $ git commit -c ORIG_HEAD  

Чтобы удалить некоторые файлы из фиксации 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

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

git reset --hard HEAD~1

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

git push upstream head -f

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

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

git reset --soft HEAD~1

git status

Вывод

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

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

git log --oneline --graph

Выход

• 90f8bb1 (HEAD -> master) Вторая фиксация \
• 7083e29 Начальная фиксация репозитория \

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

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

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

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

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

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

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

$ git reset --soft HEAD~1

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

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

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

git log 

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

git reset --hard <commit_id>

git push origin <branch_name> -f

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

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

git reset --hard HEAD~1

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

git push --force

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

$ git commit -m 'Initial commit'
$ git add forgotten_file
$ git commit --amend

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

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

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

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

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

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

git log

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

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

git reset --hard {insert long_hash without braces}

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

1. Git клонирует репозиторий в другое место.
2. Скопируйте модификации (файлы / каталоги) из исходного репозитория в этот новый. Затем зафиксируйте и нажмите с изменениями из нового.
3. Замените старый репозиторий новым.

Типичный цикл 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.

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

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

git reset --soft HEAD~1

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

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

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

git reset --hard HEAD~1

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

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

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

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

git push --force-with-lease

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

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

git reset --hard HEAD^ 

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

git clean    

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

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

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

[alias]
  undo = reset --soft HEAD^

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

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

First of all what is HEAD?

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

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

detached HEAD

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

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

Несколько вариантов восстановления после отключенной 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@{...}

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

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.

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

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

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

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

   git reset --soft HEAD^

   

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

   git reset --hard HEAD^

   

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

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

   

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

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

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

git fetch --all

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

git reset --hard origin/master

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

git reset --soft HEAD~1

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

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

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

 git reset --hard HEAD~1

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

git reset --hard 0ad5a7a6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

git commit --amend -m "message"

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

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

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

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

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

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

Разница между 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

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

git reset HEAD^

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

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

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

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

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

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

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

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

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

git revert --no-edit HEAD

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

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

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

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

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

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

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

git push origin (branch_name)

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

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

git log

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

git revert <commit_id>

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

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

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

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

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

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

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

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

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

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

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

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

git log

Тогда

git reset <the previous co>

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

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

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

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

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

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

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

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

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

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

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

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

Вот дерьмо, я случайно передал мастеру кое-что, что должно было быть в новой ветке!

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

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

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

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

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

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

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

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

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

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

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

$ git reset 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 .

git revert commit

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

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

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

Команда 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

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

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

git rebase --onto HEAD~1 HEAD

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

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

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

git rebase --onto b c

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

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

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

git reset --hard <commit_hash>

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

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

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

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

$ git reset --soft HEAD~1

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

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

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

$ git reset --hard HEAD~1

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

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

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

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

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

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

git commit --amend -m "message"

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

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

git reset --soft HEAD~1

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

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

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

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

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

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

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

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

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

git checkout -b old-state number_commit

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

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

ЧТО ИСПОЛЬЗОВАТЬ, 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.

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

git reset HEAD@{1}

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

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

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

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

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

git reset --hard HEAD~1

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

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

git checkout commitID .

Пример:

git checkout 7991072 .

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

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

    git commit --amend

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

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

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

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

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

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

   git reset --hard HEAD^
   

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

   git reset --soft HEAD^
   

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

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

git reset --hard HEAD~1

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

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

git reset --soft HEAD~ 

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

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

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

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

git checkout -b old-state 0d1d7fc32

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

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

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

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

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

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

git reset <the previous co>

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

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

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

git revert

Или:

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

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

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

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

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

git reflog

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

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

git reset --hard ActionIdFromRefLog

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

git reset --soft HEAD~

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

git reset --soft HEAD~2

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

git reset --soft <commitID>

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

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

git clean

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

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

git reset --soft HEAD~1

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

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

ИЛИ

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

git revert HEAD

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

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

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

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

git reset --soft 'HEAD^' 

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

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

git reflog

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

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

git reset --hard f3cb6e2

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

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

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

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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

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

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

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

git rebase -i HEAD~3

Пример списка

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

Затем Git удалит коммиты для любой строки, которую вы удаляете.

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

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

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

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>

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

Отменить фиксацию немного страшно, если вы не знаете, как это работает. Но на самом деле это удивительно просто, если вы понимаете. Я покажу вам 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 дней, поэтому вы обычно можете вернуться и спасти того, от которого не собирались избавляться.

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

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

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

git log
    commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
    commit 100: good commit   # Second to last commit. This is the one we want.

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

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

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

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

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

git revert HEAD

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

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

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

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

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

git rm --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

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

git rm classdir
git add sourcedir

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

git commit --amend

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

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

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

или

git reset --hard HEAD~1

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

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