it-swarm-ru.tech

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

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

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

19077
Hamza Yerlikaya

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

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)
  1. Это то, что вы хотите отменить.
  2. Это оставляет ваше рабочее дерево (состояние ваших файлов на диске) без изменений, но отменяет фиксацию и оставляет внесенные вами изменения без изменений (поэтому они будут отображаться как «Изменения не подготовлены для фиксации» в git status, поэтому вам нужно будет добавить их снова перед совершением). Если вы only хотите добавить больше изменений к предыдущей фиксации или изменить сообщение фиксации1, вместо этого вы можете использовать git reset --soft HEAD~, который похож на git reset HEAD~ (где HEAD~ такой же, как HEAD~1), но оставляет ваши существующие изменения подготовленными.
  3. Внесите исправления в рабочие файлы дерева.
  4. git add все, что вы хотите включить в свой новый коммит.
  5. Зафиксируйте изменения, повторно используя старое сообщение. reset скопировал старую голову в .git/ORIG_HEAD; commit с -c ORIG_HEAD откроет редактор, который изначально содержит сообщение журнала от старого коммита и позволяет вам редактировать его. Если вам не нужно редактировать сообщение, вы можете использовать опцию -C.

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

Если код уже передан на ваш сервер и у вас есть права на перезапись истории (перебазирование), то:

git Push Origin master --force

Вы также можете посмотреть на этот ответ: 

Как переместить ГОЛОВУ назад в предыдущее место? (Отдельная голова)

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


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

20714
Esko Luontola

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

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

   (F)
A-B-C
    ↑
  master

Вы хотите nuke commit C и никогда больше его не видеть. Ты делаешь это:

git reset --hard HEAD~1

Результат:

 (F)
A-B
  ↑
master

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

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

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

git reset --soft HEAD~1

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

Еще одна вещь: Предположим, вы уничтожили коммит, как в первом примере, но потом обнаружили, что он вам нужен в конце концов? Не повезло, правда?

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

git checkout -b someNewBranchName shaYouDestroyed

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

10143
Ryan Lundy

Мне потребовалось некоторое время, чтобы понять, так что, возможно, это поможет кому-то ...

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

Как отменить локальный коммит

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

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 - Отмена вещей

1909
Andrew

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

git rm classdir
git add sourcedir

Затем измените коммит:

git commit --amend

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

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

1669
bdonlan
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 установит вашу рабочую копию в состояние коммита до вашего неверного коммита.

933
Lennart Koopmann

Чтобы изменить последний коммит

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

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

Затем, если это частная ветка, mend коммит:

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

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

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started


712
Zaz

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

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

594
Jaco Pretorius

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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

Больше

477
Madhan Ayyasamy

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

456
nickf

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

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 [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>
424
neoneye

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

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

git rebase -i HEAD~3

Образец списка

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

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

401
Steven Penny

Как исправить предыдущий локальный коммит

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

Как отменить предыдущий локальный коммит

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

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

Как отменить публичный коммит

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

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

git revert --no-edit HEAD

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

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


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

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

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

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

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

git Push Origin (branch_name)

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

386
nobar

Если вы совершили мусор, но не столкнулись,

git reset --soft HEAD~1

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

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

OR

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

git revert HEAD

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

310
santos_mgr

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

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

git log 

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

git reset --hard <commit_id>

git Push Origin <branch_name> -f
306
poorva

На SourceTree (GUI для GitHub), вы можете щелкнуть правой кнопкой мыши на коммите и сделать 'Reverse Commit'. Это должно отменить ваши изменения.

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

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

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.
258
Varun Parakh

Единственная команда:

git reset --soft 'HEAD^' 

Это прекрасно работает, чтобы отменить последний локальный коммит!

242
Manish Shrivastava

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

git reset --soft HEAD~1

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

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

 How to undo the last commits in Git?

229
Alireza

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

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

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

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

    git reset --soft HEAD^
    

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

216
Ranjithkumar Ravi

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

git reflog

reflog before REFLOG ПЕРЕД СБРОСОМ

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

git reset --hard f3cb6e2

После этого заголовок репо будет сброшен на этот заголовок reset effect LOG ПОСЛЕ СБРОСА

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

reflog after ФИНАЛ РЕФЛОГА

174
Shubham Chaudhary

«Сбросить рабочее дерево до последнего коммита»

git reset --hard HEAD^ 

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

git clean    

см. - Git Quick Reference

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

169
Ravi_Parmar

Первый забег: 

git reflog

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

Затем сделайте:

git reset --hard ActionIdFromRefLog
152
U. Ali

Отменить последний коммит:

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

Это отменит последний коммит.

Здесь --soft означает сброс в стадию.

HEAD~ или HEAD^ означает переход на коммит до HEAD.


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

git commit --amend -m "message"

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

143
akshay_rahar

По-другому:

Извлеките ветку, которую вы хотите отозвать, затем сбросьте локальную рабочую копию обратно в коммит, который вы хотите, чтобы он был последним на удаленном сервере (все после того, как оно пройдет до свидания). Для этого в SourceTree я щелкнул правой кнопкой мыши и выбрал «Сбросить BRANCHNAME для этого коммита».

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

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

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

138
CommaToast

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

git reset <the previous co>
129
user853293

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

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

125
egridasov

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

114
iOS Coder

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

git reset --soft HEAD~ 
114
kyo

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

git reset --hard HEAD~1
113
thestar

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

Вы еще не выдвинули коммит

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

Вы уже нажали коммит

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

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

113
dseminara

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

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

Для локального коммита

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

112
geoom

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

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

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

Зачем ?

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

91
amd

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

git reset [email protected]{1}

Эта команда удалит ваш неверный коммит без журнала Git.

62
Jade Han

Представьте, что у нас есть 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. Если мы хотим отменить фиксацию и ее изменения (ЭТО IS ОПАСНО, потому что ваше изменение будет потеряно), мы можем использовать

    git reset --hard HEAD^

     enter image description here

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

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

     enter image description here

60
Ali Motameni

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

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

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

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

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

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

Просто отмените последний коммит: 

git reset --soft HEAD~

Или отмените время до последнего коммита: 

git reset --soft HEAD~2

Или отмените любой предыдущий коммит: 

git reset --soft <commitID>

(вы можете получить commitID используя git reflog)

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

git clean

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

53
steven

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

Щелкните правой кнопкой мыши по коммиту, затем выберите "Сброс (текущая ветвь)/мастер этого коммита" и последний выберите _ ​​"мягкий" сброс ,.

 Enter image description here

53
Alexandr

Отменить последний коммит

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

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

$ git reset --soft HEAD~1

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

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

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

$ git reset --hard HEAD~1

 Enter image description here

51
Mohit

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

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

47
mfathy00

Типичный цикл Git

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

  1. Первое клонирование с удаленного сервера

    git clone $project

  2. Извлечение из удаленного узла (когда у меня нет ожидающего локального коммита в Push)

    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. Разрешение при возникновении конфликта предварительное условие настройки 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.

41
Sazzad Hissain Khan

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

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

git reset --soft HEAD~1

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

git reset FILE

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

39
FraK

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

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

Согласно ответу с тоннами голосов:

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

git reset --hard HEAD~1

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

38
Tom Stickel

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

git checkout commitID .

Пример:

git checkout 7991072 .

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

35
ioopl

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

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

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

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

git Push --force-with-lease

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

34
KawaiKx

Отменить последний коммит:

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

Это отменит последний коммит.

Здесь --soft означает сброс в стадию.

HEAD~ or HEAD^ означает переход на коммит до HEAD.

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

git commit --amend -m "message"

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

32
Ankit Patidar

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

    git commit --amend

если это частная ветка или

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

если это общая или публичная ветка.

32
Yahs Hef

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

Прежде всего вам нужно выяснить, какие «неправильные» коммиты вы хотите отменить. Мы будем использовать git reflog, чтобы найти его.


git reflog

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

Каждый раз, когда HEAD изменяется, в reflog появляется новая запись.
reflog похож на команду истории unix и хранится локально на вашем компьютере.

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

Используя checkout, вы можете вернуться к любому желаемому коммиту и создать ветку или любые другие опции, которые вам позволит сделать git checkout.

 enter image description here


git reset HEAD --hard <commit_id>

"Переместите" вашу голову назад к желаемому коммиту.
Git reset будет извлекать желаемый контент коммитов в вашу промежуточную область и/или в ваш рабочий каталог на основе значения --hard/--soft/--mixed, которое вы выберете. --hard обновит область рабочей области и рабочий каталог с заданным содержимым и "отсоединит" любые другие коммиты за пределами этой точки в вашей локальной ветке. 

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

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

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

 enter image description here

28
CodeWizard

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

git checkout -b old-state number_commit
27
Fadid

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

git checkout -b old-state 0d1d7fc32
27
Jishnu Sukumaran

Удалить неправильный коммит, который уже передан в Github

git Push Origin +(previous good commit id):(branch name)

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

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

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

25
V V

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

PS:
1- Будьте осторожны, из-за «жесткого» параметра, он удаляет локальные изменения в вашем репо и возвращается к предыдущему коммиту. Вы должен выполнить это, если вы уверены, что запутались в своем последнем коммите (-ах) и хотел бы вернуться во времени. 

2- Обычно достаточно 7 букв "commit sha", но больше проекты, вам может понадобиться до 12 писем, чтобы гарантировать уникальность. Вы Также можно упомянуть целых 40 букв ша.

3. Вышеприведенные команды работают и в Github для Windows.

24
Alisa

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

24
shreshta bm

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

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

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

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

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

20
Shwetank

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

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

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

 Git Extensions screen shot

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

 Revert commit popup

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

18
Ranadheer Reddy

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

16
hubot

Я нашел этот сайт, который описывает, как отменить вещи, которые вы совершили в хранилище.

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

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

Вот сайт: 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 :)
15
Eugen Konkov

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

На изображении ниже я проверяю ветку '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

14
Raj S. Rusia

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

git reset HEAD^

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

14
Arun Karnawat

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

13
Krzysztof Walczewski

ГОЛОВА:

Перед сбросом коммитов мы должны знать о 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

13
Mohideen ibn Mohammed

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

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

Давайте возьмем пример: 

- A - B - C (master)

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

--мягкий

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

--mixed

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

--жесткий

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

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

12
Keshan Nageswaran

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

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

git rebase --onto HEAD~1 HEAD

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

a -> b -> c -> d -> мастер

и вы хотите отбросить коммит 'c'

git rebase --onto b c

Это сделает «b» новой базой «d», исключив «c»

12
Khem

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

git log

Затем

git reset <the previous co>
12
Praveen Singh

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

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

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

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

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

11
Dominic Cerisano

 enter image description here

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

11
Uchiha Itachi

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

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

8
nPcomp

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

git reset --hard <commit_hash>

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

7
serdarsenay
git reset --soft HEAD~1

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

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

 git reset --hard HEAD~1

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

git reset --hard 0ad5a7a6

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

6
Abu Bakr

То, что я делаю каждый раз, когда мне нужно отменить коммит/коммит, это:

  1. git reset HEAD~<n> // количество последних коммитов, которые мне нужно отменить
  2. git status // необязательно. Все файлы теперь в красном (не в формате).

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

    • git add <file names> & git commit -m "message" -m "details"
  4. Необязательно: Я могу откатить изменения остальных файлов, если мне нужно, до их прежнего состояния с помощью checkout:
    • git checkout <filename>
  5. если я уже передал его на удаленный источник, ранее:
    • git Push Origin <branch name> -f // используем -f для принудительной отправки.
6
Theo Itzaris

Если вы хотите отменить самый первый коммит в вашем репо

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

$ 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 .
5
Nicholas

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

git log

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

git revert <commit_id>
3
Nalan Madheswaran

Как редактировать более ранний коммит

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

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

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

  1. git commit-edit <commit-hash>
    

    Это приведет вас к коммиту, который вы хотите отредактировать.

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

  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://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; 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
2
Tom Hale

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

git reset --hard Origin/branch-name

1
JeremyWeir
git revert commit

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

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

1
Gjorgi Gjorgiev

замените вашу локальную версию, включая ваши изменения, версией сервера, эти две строки кода заставят git вытянуть и перезаписать локальную. Откройте командную строку и перейдите к корню проекта git. Если вы используете VS, нажмите Team, Synch и нажмите «Открыть командную строку» (см. Изображение) ниже. 

 Visual Studio

Попав в Cmd Prompt, выполните следующие две инструкции. 

git fetch --all

тогда вы делаете

git reset --hard Origin/master

это заменит существующую локальную версию той, что на git server

0
shiraz
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
0
Omkaar.K