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

<p>я случайно отправил неправильные файлы в <a href="https://en.wikipedia.org/wiki/git\_software">git</a> , но еще не отправил коммит на сервер.</p><p><strong>как я могу отменить эти коммиты из локального репозитория?</strong> </p>

<h3>отменить фиксацию и повторить</h3><pre class="lang-sh prettyprint-override"><code>$ 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) </code></pre><ol> <li>это то, что вы хотите отменить.</li> <li>это оставляет ваше рабочее дерево (состояние ваших файлов на диске) без изменений, но отменяет фиксацию и оставляет внесенные вами изменения без изменений (поэтому они будут отображаться как «изменения не подготовлены для фиксации» в <code>git status</code>, поэтому вам нужно будет добавить их снова перед совершением). если вы <em>only</em> хотите <em>добавить</em> больше изменений к предыдущей фиксации или изменить сообщение фиксации<sup>1</sup>, вместо этого вы можете использовать <code>git reset --soft head~</code>, который похож на <code>git reset head~</code> (где <code>head~</code> такой же, как <code>head~1</code>), но оставляет ваши существующие изменения подготовленными.</li> <li>внесите исправления в рабочие файлы дерева.</li> <li><code>git add</code> все, что вы хотите включить в свой новый коммит.</li> <li>зафиксируйте изменения, повторно используя старое сообщение. <code>reset</code> скопировал старую голову в <code>.git/orig\_head</code>; <code>commit</code> с <code>-c orig\_head</code> откроет редактор, который изначально содержит сообщение журнала от старого коммита и позволяет вам редактировать его. если вам не нужно редактировать сообщение, вы можете использовать опцию <code>-c</code>.</li> </ol><p>однако помните, что если вы добавили какие-либо новые изменения в индекс, использование <code>commit --amend</code> добавит их в ваш предыдущий коммит.</p><p>если код уже передан на ваш сервер и у вас есть права на перезапись истории (перебазирование), то:</p><pre><code>git push origin master --force </code></pre><p>вы также можете посмотреть на этот ответ: </p><p> <a href="https://stackoverflow.com/questions/34519665/how-to-move-head-back-to-a-previous-location-detached-head/34519716#34519716">как переместить голову назад в предыдущее место? (отдельная голова)</a> </p><p>приведенный выше ответ покажет вам <code>git reflog</code>, который используется, чтобы узнать, что такое sha-1, к которому вы хотите вернуться. как только вы нашли точку, к которой вы хотите отменить, используйте последовательность команд, как описано выше.</p><hr><p><sup>1</sup> однако обратите внимание, что вам не нужно возвращаться к более ранней фиксации, если вы только что допустили ошибку в своем сообщении <em>commit</em>. более простой вариант - <code>git reset</code> (чтобы отменить все изменения, которые вы сделали с тех пор), а затем <a href="https://stackoverflow.com/q/179123/1146608"><code>git commit --amend</code></a> , который откроет ваш редактор сообщений по умолчанию, предварительно заполненный последним сообщением коммита. </p>

<p>отмена коммита немного страшна, если вы не знаете, как он работает. но на самом деле это удивительно легко, если вы понимаете.</p><p>скажем, у вас это есть, где c - это ваша голова, а (f) - это состояние ваших файлов.</p><pre><code> (f) a-b-c ↑ master </code></pre><p>вы хотите <strong>nuke commit c и никогда больше его не видеть</strong>. ты делаешь это:</p><pre><code>git reset --hard head~1 </code></pre><p>результат:</p><pre><code> (f) a-b ↑ master </code></pre><p>теперь б - голова. поскольку вы использовали <code>--hard</code>, ваши файлы возвращаются в свое состояние при фиксации b.</p><p>ах, но предположим, что commit c - это не катастрофа, а совсем немного. вы хотите <strong>отменить фиксацию, но сохраните свои изменения</strong> для небольшого редактирования, прежде чем сделать лучший коммит. начиная снова здесь, с c в качестве вашей головы:</p><pre><code> (f) a-b-c ↑ master </code></pre><p>вы можете сделать это, не используя <code>--hard</code>:</p><pre><code>git reset head~1 </code></pre><p>в этом случае результат:</p><pre><code> (f) a-b-c ↑ master </code></pre><p>в обоих случаях head - это просто указатель на последний коммит. когда вы делаете <code>git reset head~1</code>, вы говорите git переместить указатель head на один коммит. но (если вы не используете <code>--hard</code>) вы оставляете свои файлы такими, какими они были. итак, теперь <code>git status</code> показывает изменения, которые вы зарегистрировали в c. вы ничего не потеряли!</p><p>для самого легкого прикосновения вы можете даже <strong>отменить свой коммит, но оставить свои файлы и свой <a href="https://git.wiki.kernel.org/index.php/whatistheindex">index</a> </strong>:</p><pre><code>git reset --soft head~1 </code></pre><p>это не только оставляет ваши файлы в покое, оно даже оставляет ваш <em>index</em> в покое. когда вы выполните <code>git status</code>, вы увидите, что в индексе есть те же файлы, что и раньше. фактически, сразу после этой команды вы можете выполнить <code>git commit</code> и повторить тот же коммит, который вы только что сделали.</p><p>еще одна вещь: <strong>предположим, вы уничтожили коммит</strong>, как в первом примере, <strong>но потом обнаружили, что он вам нужен в конце концов</strong>? не повезло, правда?</p><p>нет, есть <em>все еще</em> способ вернуть его. введите <code>git reflog</code>, и вы увидите список (частичного) коммита <a href="https://en.wikipedia.org/wiki/sha-1#data\_integrity">shas</a> (то есть хэшей), в который вы переместились. найдите коммит, который вы уничтожили, и сделайте следующее:</p><pre><code>git checkout -b somenewbranchname shayoudestroyed </code></pre><p>вы сейчас воскресили этот коммит. комитеты на самом деле не уничтожаются в git в течение примерно 90 дней, поэтому обычно вы можете вернуться и спасти того, от которого не хотели избавиться.</p>

<p>мне потребовалось некоторое время, чтобы понять, так что, возможно, это поможет кому-то ...</p><p>существует два способа «отменить» ваш последний коммит, в зависимости от того, сделали ли вы коммит открытым или нет (передан в удаленный репозиторий):</p><h2>как отменить локальный коммит</h2><p>допустим, я зафиксировал локально, но теперь хочу удалить этот коммит.</p><pre><code>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 </code></pre><p>чтобы восстановить все обратно, как это было до последнего коммита, нам нужно <code>reset</code> до коммита перед <code>head</code>:</p><pre><code>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 </code></pre><p>теперь <code>git log</code> покажет, что наш последний коммит был удален.</p><h2>как отменить публичный коммит</h2><p>если вы уже сделали свои коммиты общедоступными, вы захотите создать новый коммит, который "отменит" изменения, сделанные вами в предыдущем коммите (текущем head).</p><pre><code>git revert head </code></pre><p>теперь ваши изменения будут отменены и готовы к принятию:</p><pre><code>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 </code></pre><p>для получения дополнительной информации, проверьте <a href="https://git-scm.com/book/en/v2/git-basics-undoing-things">основы git - отмена вещей</a> </p>

<p>добавить/удалить файлы, чтобы получить вещи, как вы хотите:</p><pre><code>git rm classdir git add sourcedir </code></pre><p>затем измените коммит:</p><pre><code>git commit --amend </code></pre><p>предыдущая, ошибочная фиксация будет отредактирована, чтобы отразить новое состояние индекса - другими словами, это будет так, как если бы вы никогда не допустили ошибку с самого начала.</p><p>обратите внимание, что вы должны делать это, только если вы еще не нажали. если вы нажали, то вам просто нужно зафиксировать исправление в обычном режиме.</p>

<pre class="lang-bash prettyprint-override"><code>git rm yourfiles/*.class git commit -a -m "deleted all class files in folder 'yourfiles'" </code></pre><p>или же</p><pre><code>git reset --hard head~1 </code></pre><p><strong> предупреждение. приведенная выше команда навсегда удалит изменения в файлах <code>.java</code> (и любых других файлах), которые вы хотели зафиксировать. </strong></p><p>от <code>hard reset</code> до <code>head-1</code> установит вашу рабочую копию в состояние коммита до вашего неверного коммита.</p>

<h2>чтобы изменить последний коммит</h2><p>заменить файлы в индексе:</p><pre><code>git rm --cached *.class git add *.java </code></pre><p>затем, если это частная ветка, <strong>mend</strong> коммит:</p><pre><code>git commit --amend </code></pre><p>или, если это общая ветка, сделайте новый коммит:</p><pre><code>git commit -m 'replace .class files with .java files' </code></pre><p><br> <em>(<strong>, чтобы изменить предыдущий коммит</strong>, используйте удивительную <a href="https://stackoverflow.com/a/28421811/405550">интерактивную перебазировку</a> )</em></p><hr><p>protip ™: добавьте <code>*.class</code> к <a href="https://help.github.com/articles/ignoring-files">gitignore</a> , чтобы остановить это снова.</p><hr><h2>чтобы отменить коммит</h2><p>внесение изменений в коммит является идеальным решением, если вам нужно изменить последний коммит, но более общее решение - <code>reset</code>.</p><p>вы можете сбросить git на любой коммит с помощью:</p><pre><code>git reset @~n </code></pre><p>где <code>n</code> - количество коммитов до <code>head</code>, а <code>@~</code> сбрасывает до предыдущего коммита.</p><p>таким образом, вместо внесения изменений в коммит, вы можете использовать:</p><pre><code>git reset @~ git add *.java git commit -m "add .java files" </code></pre><p>проверьте <code>git help reset</code>, в частности, разделы <code>--soft</code> <code>--mixed</code> и <code>--hard</code>, чтобы лучше понять, что это делает.</p><h2>reflog</h2><p>если вы запутались, вы всегда можете использовать reflog, чтобы найти упавшие коммиты:</p><pre><code>$ 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 revert <commit-id>чтобы получить идентификатор фиксации, просто используйте git log

если вы планируете полностью отменить локальный коммит, то, что вы изменили, вы сделали в коммите, и если вы не беспокоитесь об этом, просто выполните следующую команду.git reset --hard head^1 (эта команда будет игнорировать весь ваш коммит, и ваши изменения будут полностью потеряны из вашего локального рабочего дерева). если вы хотите отменить фиксацию, но хотите внести изменения в промежуточную область (до фиксации, как после git add), выполните следующую команду.git reset --soft head^1 теперь ваши зафиксированные файлы попадают в промежуточную область. предположим, что если вы хотите удалить файлы из-за кулис, потому что вам нужно отредактировать неправильный контент, выполните следующую командуgit reset head теперь переданные файлы поступают из промежуточной области в неподготовленную область. теперь файлы готовы к редактированию, поэтому, что бы вы ни изменили, вы захотите перейти к редактированию, добавить его и сделать новый/новый коммит. <a href="http://madhan-tech-updates.blogspot.in/2013/01/how-to-undo-your-local-git-commit.html">больше 

если у вас установлена  <a href="https://github.com/visionmedia/git-extras">git extras , вы можете запустить git undo, чтобы отменить последний коммит. git undo 3 отменит последние 3 коммита.

я хотел отменить последние 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 git@bitbucket.org:thecompany/prometheus.git + 09a6480...5a74047 master -> master (forced update) prompt> 

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

как исправить предыдущий локальный коммитиспользуйте git-gui (или аналогичный) для выполнения git commit --amend. из графического интерфейса вы можете добавлять или удалять отдельные файлы из коммита. вы также можете изменить сообщение коммита. как отменить предыдущий локальный коммитпросто верните свою ветку в предыдущее местоположение (например, используя gitk или git rebase). затем повторно примените изменения из сохраненной копии. после сборки мусора в вашем локальном хранилище будет похоже на то, что нежелательный коммит никогда не происходил. чтобы сделать все это в одной команде, используйте git reset head~1.<strong>слово предупреждения</strong>: неосторожное использование git reset - хороший способ привести вашу рабочую копию в запутанное состояние. я рекомендую новичкам git избегать этого, если они могут.как отменить публичный коммитвыполните <a href="https://stackoverflow.com/a/1624724/86967">обратный выбор вишни ( <a href="http://git-scm.com/docs/git-revert.html">git-revert ), чтобы отменить изменения.если вы еще не внесли другие изменения в свою ветку, вы можете просто сделать ...git revert --no-edit head затем отправьте обновленную ветку в общий репозиторий.история коммитов покажет оба коммита, отдельно.дополнительно: исправление ветки private в публичном репозиторииэто может быть опасно - убедитесь, что у вас есть локальная копия ветки для повторной отправки.также обратите внимание: вы не хотите делать это, если кто-то еще может работать над веткой.git push --delete (branch_name) ## remove public version of branch очисти свою ветку локально, затем оттолкни.git push origin (branch_name) в обычном случае вам, вероятно, не нужно беспокоиться о том, что ваша история коммитов в частной ветке будет нетронутой. просто нажмите последующую фиксацию (см. «как отменить публичную фиксацию» выше), а затем выполните <a href="https://stackoverflow.com/a/22417539/86967">squash -merge , чтобы скрыть историю.

если вы совершили мусор, но не столкнулись,git reset --soft head~1 <blockquote> <strong> head ~ 1 </strong>это сокращение для коммита перед головой. в качестве альтернативы вы можете обратиться к<strong> sha-1 </strong>хэша, если вы хотите сбросить в. параметр --soft удалит коммит, но оставит все ваши измененные файлы «изменениями, которые будут зафиксированы», как будет указано в git status. если вы хотите избавиться от каких-либо изменений отслеживаемых файлов в рабочем дереве, начиная с коммита до заголовка, используйте вместо этого "<strong> --hard </strong>". </blockquote>or<blockquote> если вы уже нажали, а кто-то нажал, что обычно является моим случаем, вы не можете использовать git reset. однако вы можете сделать git revert, </blockquote>git revert head <blockquote> это создаст новый коммит, который перевернет все, что было введено случайным коммитом. </blockquote>

если вы хотите навсегда отменить это, и вы клонировали некоторый репозиторий идентификатор коммита можно увидеть git log тогда вы можете сделать -git reset --hard <commit_id> git push origin <branch_name> -f 

на <a href="https://www.atlassian.com/software/sourcetree/overview">sourcetree (gui для github), вы можете щелкнуть правой кнопкой мыши на коммите и сделать 'reverse commit'. это должно отменить ваши изменения.на терминале:в качестве альтернативы вы можете использовать:git revert или же:<pre class="lang-bash prettyprint-override">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. 

единственная команда:<pre class="lang-bash prettyprint-override">git reset --soft 'head^' это прекрасно работает, чтобы отменить последний локальный коммит!

просто сбросьте его, выполнив команду ниже, используя git:git reset --soft head~1 <strong>объясните:</strong> что делает git reset, это в основном reset для любого коммита, к которому вы хотите вернуться, затем, если вы объедините его с ключом --soft, он вернется, но сохранит изменения в ваших файлах, так что вы вернетесь к этапу, на котором файл был только что добавлен, head является заголовком ветви, и если вы объедините с ~1 (в этом случае вы также используете head^), он вернется только к одному коммиту, который вы хотите .. ,.я создаю шаги, изображенные на рисунке ниже, более подробно для вас, включая все шаги, которые могут произойти в реальных ситуациях, и фиксацию кода: <a href="https://i.stack.imgur.com/7zrzb.jpg"> <img src="https://i.stack.imgur.com/7zrzb.jpg" alt="how to undo the last commits in git?">  

<strong> как отменить последний коммит git? </strong>чтобы восстановить все, как было до последнего коммита, нам нужно сбросить коммит до head. если вы не хотите сохранять сделанные вами изменения: git reset --hard head^  если вы хотите сохранить свои изменения: git reset --soft head^  теперь проверьте ваш журнал git. это покажет, что наш последний коммит был удален.

используйте reflog, чтобы найти правильное состояниеgit reflog <img src="https://i.stack.imgur.com/c7e7d.png" alt="reflog before">  reflog перед сбросом выберите правильный reflog (f3cb6e2 в моем случае) и введите git reset --hard f3cb6e2 после этого заголовок репо будет сброшен на этот заголовок <img src="https://i.stack.imgur.com/gdndt.png" alt="reset effect">  log после сброса наконец, рефлог выглядит как на картинке ниже<img src="https://i.stack.imgur.com/fhhub.png" alt="reflog after">  финал рефлога 

«сбросить рабочее дерево до последнего коммита»git reset --hard head^ «удалить неизвестные файлы из рабочего дерева»git clean см. - <a href="http://jonas.nitro.dk/git/quick-reference.html">git quick reference <strong>примечание:</strong> эта команда удалит ваш предыдущий коммит, поэтому используйте его с осторожностью! git reset --hard безопаснее -

первый забег: git reflog он покажет вам все возможные действия, которые вы выполнили в вашем хранилище, например, фиксация, слияние, извлечение и т.д.затем сделайте:git reset --hard actionidfromreflog 

отменить последний коммит:git reset --soft head^ или git reset --soft head~это отменит последний коммит.здесь --soft означает сброс в стадию.head~ или head^ означает переход на коммит до head.заменить последний коммит на новый коммит:git commit --amend -m "message" он заменит последний коммит новым коммитом.

по-другому:извлеките ветку, которую вы хотите отозвать, затем сбросьте локальную рабочую копию обратно в коммит, который вы хотите, чтобы он был последним на удаленном сервере (все после того, как оно пройдет до свидания). для этого в sourcetree я щелкнул правой кнопкой мыши и выбрал «сбросить branchname для этого коммита».затем перейдите в локальный каталог вашего репозитория и выполните следующую команду:git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags repository_name branchname:branchname это удалит все коммиты после текущего в вашем локальном репозитории, но только для этой ветки.

введите git log и найдите хэш-код последнего коммита, а затем введите:git reset <the previous co> 

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

используйте <a href="https://www.atlassian.com/software/sourcetree/overview">sourcetree (графический инструмент для git), чтобы увидеть ваши коммиты и дерево. вы можете вручную сбросить его, нажав правой кнопкой мыши.

просто запустите это в командной строке:git reset --soft head~ 

чтобы восстановить предыдущую ревизию, окончательно удалив все незафиксированные изменения: git reset --hard head~1 

есть два основных сценария<strong>вы еще не выдвинули коммит</strong>если проблема была в добавленных вами дополнительных файлах (и вы не хотите, чтобы они были в хранилище), вы можете удалить их с помощью git rm, а затем зафиксировать с помощью --amendgit rm <pathtofile> вы также можете удалить целые каталоги с помощью -r или даже объединить с другими командами <a href="http://en.wikipedia.org/wiki/bash_%28unix_shell%29">bash git rm -r <pathtodirectory> git rm $(find -name '*.class') </code></pre><p>после удаления файлов вы можете сделать коммит с параметром <strong>--amend</strong></p><pre><code>git commit --amend -c head # the -c option is to use the same commit message </code></pre><p>это перезапишет ваш недавний локальный коммит, удалив лишние файлы, поэтому эти файлы никогда не будут отправлены в push, а также будут удалены из вашего локального .git-репозитория gc.</p><p><strong>вы уже нажали коммит</strong></p><p>вы можете применить то же решение другого сценария, а затем выполнить <code>git push</code> с параметром <code>-f</code>, но это <strong>не рекомендуется</strong>, поскольку оно перезаписывает удаленную историю с расходящимися изменениями (это может испортить ваш репозиторий).</p><p>вместо этого вы должны выполнить коммит без <code>--amend</code> (помните об этом -amend`: эта опция переписывает историю последнего коммита).</p>

<p>есть много способов сделать это:</p><p>команда git для отмены последнего коммита/предыдущих коммитов:</p><p><strong> предупреждение: </strong>не используйте --hard, если вы не знаете, что делаете . -- hard - это слишком<strong> опасно </strong>, и это может<strong> удалить ваши файлы. </strong></p><p><strong> основная команда для возврата коммита в git: </strong></p><pre><code>$ git reset --hard <commit -id> или же$ git reset --hard head~<n> </code></pre><p><strong> commit-id </strong>: идентификатор для фиксации</p><p><strong> n: </strong>- количество последних коммитов, которые вы хотите отменить</p><p>вы можете получить идентификатор фиксации, как показано ниже:</p><pre><code>$ git log --oneline d81d3f1 function to subtract two numbers be20eb8 function to add two numbers bedgfgg function to mulitply two numbers где<strong> d81d3f1 </strong>и<strong> be20eb8 </strong>- это идентификатор коммита.<strong> теперь давайте посмотрим на некоторые случаи: </strong>предположим, вы хотите отменить последний коммит 'd81d3f1'. вот два варианта:$ git reset --hard d81d3f1 </code></pre><p>или же</p><pre><code>$ git reset --hard head~1 предположим, вы хотите отменить коммит 'be20eb8':$ git reset --hard be20eb8 </code></pre><p>для получения более подробной информации вы можете обратиться и попробовать некоторые другие команды для возврата головки в указанное состояние:</p><pre><code>$ git reset --help 

для локального коммитаgit reset --soft head~1 или если вы точно не помните, в каком именно коммите это происходит, вы можете использоватьgit rm --cached  для толкаемого коммитаправильный способ удаления файлов из истории хранилища - использование git filter-branch. то есть,<pre class="lang-bash prettyprint-override">git filter-branch --index-filter 'git rm --cached ' head но я рекомендую вам использовать эту команду с осторожностью. подробнее читайте на  <a href="https://www.kernel.org/pub/software/scm/git/docs/git-filter-branch.html">git-filter-branch (1) страница руководства .

что использовать, reset --soft или reset --hard?я просто добавляю два цента за ответ @ kyralessa:если вы не уверены, что использовать, используйте --soft (я запомнил это соглашение --<strong>s</strong> oft).зачем ?если вы выберете --hard по ошибке, вы будете <strong>потерять</strong> ваши изменения, как это было раньше . если вы выберете --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.

представьте, что у нас есть <strong>code.txt</strong> файл . мы вносим в него некоторые изменения и фиксируем . <strong>мы можем отменить этот фиксацию тремя способами</strong>, но сначала вам следует знать, что такое промежуточный файл ... промежуточный файл - это файл, который готов к фиксации, и если вы запустите git status, этот файл будет показан зеленым цветом, а если он не подготовлен для фиксации, будет показан красным цветом: <a href="https://i.stack.imgur.com/ymnkl.png"> <img src="https://i.stack.imgur.com/ymnkl.png" alt="enter image description here">  это означает, что если вы фиксируете свое изменение, ваши изменения в этом файле не сохраняются . вы можете добавить этот файл на своем этапе с помощью git add code.txt, а затем зафиксировать свое изменение: <a href="https://i.stack.imgur.com/36yag.png"> <img src="https://i.stack.imgur.com/36yag.png" alt="enter image description here">  <strong>отменить последний коммит:</strong> теперь, если мы хотим просто отменить коммит без каких-либо других изменений, мы можем использовать git reset --soft head^   <a href="https://i.stack.imgur.com/tx6x1.png"> <img src="https://i.stack.imgur.com/tx6x1.png" alt="enter image description here">   если мы хотим отменить фиксацию и ее изменения (<strong>это is опасно, потому что ваше изменение будет потеряно</strong>), мы можем использовать git reset --hard head^  <a href="https://i.stack.imgur.com/8ndbs.png"> <img src="https://i.stack.imgur.com/8ndbs.png" alt="enter image description here">   и если мы хотим отменить фиксацию и удалить изменения со сцены, мы можем использовать git reset --mixed head^ или в краткой форме git reset head^  <a href="https://i.stack.imgur.com/jg8g0.png"> <img src="https://i.stack.imgur.com/jg8g0.png" alt="enter image description here">   

обычно вы хотите<strong> отменить </strong>коммит, потому что вы сделали ошибку и хотите ее исправить - по сути, то, что сделал оп, когда задал вопрос. так что на самом деле, вы действительно хотите<strong> повторить </strong>коммит.большинство ответов здесь сосредоточены на командной строке. хотя командная строка - это лучший способ использовать git, когда вам удобно, она, вероятно, немного чужда тем, кто прибывает из других систем контроля версий в git. вот как это сделать с помощью графического интерфейса. если у вас установлен git, у вас уже есть все необходимое для выполнения этих инструкций.<strong> примечание: </strong>я предполагаю, что вы поняли, что фиксация была неправильной, прежде чем вы ее нажали. если вы не знаете, что такое толкание, вы, вероятно, не толкнули, так что продолжайте с инструкциями. если вы выдвинули ошибочный коммит, наименее рискованный способ - просто следовать за ошибочным коммитом новым коммитом, который исправляет вещи, так же, как вы это делали бы в системе контроля версий, которая не позволяет переписывать историю. тем не менее, вот как исправить ваш последний сбой фиксации с помощью графического интерфейса: перейдите в свой репозиторий в командной строке и запустите графический интерфейс с помощью git gui выберите «изменить последний коммит». вы увидите последнее сообщение о коммите, файлы, которые вы поставили, и файлы, которые вы не сделали. теперь измените все так, как вы хотите, чтобы они выглядели, и нажмите «применить».  

просто отмените последний коммит: git reset --soft head~ или отмените время до последнего коммита: git reset --soft head~2 или отмените любой предыдущий коммит: git reset --soft <commitid> (вы можете получить commitid используя git reflog)когда вы отменяете предыдущий коммит, не забудьте почистить рабочее местоgit clean более подробную информацию можно найти в документации: <a href="http://git-scm.com/docs/git-reset">git-reset 

если вы работаете с <strong> <a href="https://www.sourcetreeapp.com/">sourcetree </strong>, это поможет вам.<strong>щелкните правой кнопкой мыши</strong> по коммиту, затем <strong>выберите</strong> "сброс (текущая ветвь)/мастер этого коммита" и последний <strong>выберите</strong> _ "мягкий" сброс ,. <a href="https://i.stack.imgur.com/bsmo2.png"> <img src="https://i.stack.imgur.com/bsmo2.png" alt="enter image description here">  

<strong>отменить последний коммит</strong>существует множество ситуаций, когда вы действительно хотите отменить этот последний коммит в своем коде. например. потому что вы хотели бы реструктурировать его - или вообще отказаться от него!в этих случаях команда «reset» - ваш лучший друг:$ git reset --soft head~1 </code></pre><p>приведенная выше команда (сброс) перемотает текущую ветку head до указанной ревизии. в нашем примере выше мы хотели бы вернуться к тому, что был до текущей ревизии, - эффективно отменить наш последний коммит.</p><p>обратите внимание на флаг <code>--soft</code>: это гарантирует, что изменения в отмененных ревизиях сохраняются. после запуска команды вы найдете эти изменения в качестве незафиксированных локальных изменений в вашей рабочей копии.</p><p>если вы не хотите сохранять эти изменения, просто используйте флаг <code>--hard</code>. делайте это только тогда, когда вы уверены, что эти изменения вам больше не нужны.</p><pre><code>$ git reset --hard head~1  <a href="https://i.stack.imgur.com/hqetq.png"> <img src="https://i.stack.imgur.com/hqetq.png" alt="enter image description here">  

чтобы отменить локальный коммит, вы используете git reset <commit>. также <a href="https://www.atlassian.com/git/tutorials/undoing-changes/git-reset">этот урок очень полезен, чтобы показать вам, как он работает.кроме того, вы можете использовать git revert <commit>: <a href="https://www.atlassian.com/git/tutorials/undoing-changes/git-revert/">возвращать следует использовать, когда вы хотите добавить еще один коммит, который откатывает изменения (но сохраняет их в истории проекта).

типичный цикл gitговоря о командах, связанных с git, в предыдущих ответах, я хотел бы поделиться своими типичными циклами git со всеми читателями, которые могут оказаться полезными. вот как я работаю с git, первое клонирование с удаленного сервера git clone $project</code></p></li> <li><p>извлечение из удаленного узла (когда у меня нет ожидающего локального коммита в push)</p> <p><code>git pull</code></p></li> <li><p>добавление нового локального файла1 в $ to_be_committed_list (просто представьте, что $ to\_be\_committed\_list означает область <code>staged</code>)</p> <p><code>git add $file1 удаление ошибочно добавленного файла 2 из $ to\_be\_committed\_list (предположим, что файл 2 добавлен как шаг 3, который я не хотел)</p> <p><code>git reset $file2 передача file1, который находится в $ to\_be\_committed\_list</p> <p><code>git commit -m "commit message description"</code></p></li> <li><p>синхронизация локального коммита с удаленным репозиторием перед нажатием</p> <p><code>git pull --rebase</code></p></li> <li><p>разрешение при возникновении конфликта <a href="https://git-scm.com/book/en/v2/customizing-git-git-configuration">предварительное условие настройки mergetool</a> </p> <p><code>git mergetool #resolve merging here, also can manually merge</code></p></li> <li><p>добавление разрешенных конфликтом файлов, скажем, <code>file1</code>:</p> <p><code>git add $file1 продолжая мою предыдущую команду rebase git rebase --continue нажав готовый и уже синхронизированный последний локальный коммит git push origin head:refs/for/$branch # branch = master, dev, etc.</code></p></li> </ol>

<p>в моем случае я зафиксировал и выдвинул неверную ветку, поэтому я хотел вернуть все свои изменения, чтобы я мог зафиксировать их в новой правильной ветви, поэтому я сделал это:</p><p>в той же ветке, которую вы зафиксировали и отправили, если вы введете «git status», вы не увидите ничего нового, потому что вы зафиксировали и отправили, теперь введите:</p><p><code>git reset --soft head~1</code></p><p>это вернет все ваши изменения (файлы) в область рабочей области, а теперь, чтобы вернуть их в рабочий каталог (без этапа), просто наберите:</p><pre><code>git reset file </code></pre><p>где «файл» - это файл, который вы хотите зафиксировать снова. теперь этот файл должен находиться в рабочем каталоге (без тегов) со всеми изменениями, которые вы сделали. теперь вы можете перейти к любой ветке, которую хотите, и зафиксировать изменения в этой ветке. надеюсь, это поможет другим людям, которые совершили ту же ошибку, что и я. конечно, исходная ветвь, которую вы зафиксировали, все еще там со всеми изменениями, но в моем случае это было нормально, если это не для вас, вы можете искать способы отменить эту фиксацию в этой ветке.</p>

<p><strong> визуальные студия пользователей (2015 и т.д.) </strong></p><p>если вы не можете выполнить синхронизацию в visual studio, поскольку вам не разрешено нажимать на ветку, например, «развитие», то, как я и пытался, в visual studio никогда не будет<strong>revert</strong>nor сброс<strong></strong>(жесткий или мягкий) будет работать.</p><p>согласно ответу с тоннами голосов:</p><p>используйте это в командной строке корневого каталога вашего проекта, чтобы уничтожить все, что будет пытаться толкнуть:</p><pre><code>git reset --hard head~1 </code></pre><p>резервное копирование или архивирование ваших файлов на случай, если вы не хотите потерять работу и т.д.</p>

<p>я получил идентификатор фиксации от <code>bitbucket</code> и затем сделал:</p><pre><code>git checkout commitid . </code></pre><p>пример:</p><pre><code>git checkout 7991072 . </code></pre><p>и он вернул его обратно к этой рабочей копии этого коммита.</p>

<p>предположим, вы сделали неправильный коммит локально и отправили его в удаленный репозиторий. вы можете отменить беспорядок с этими двумя командами:</p><p>во-первых, нам нужно исправить наш локальный репозиторий, вернувшись к коммиту, который мы хотим:</p><pre><code>git reset --hard <previous good commit id where you want the local repository to go> </code></pre><p>теперь мы принудительно отправим этот хороший коммит в удаленный репозиторий с помощью этой команды:</p><pre><code>git push --force-with-lease </code></pre><p>версия опции «с арендой», которая предотвращает случайное удаление новых коммитов, о которых вы не знаете (т. е. пришедших из другого источника с момента вашего последнего извлечения).</p>

<p><strong> отменить последний коммит: </strong></p><pre><code>git reset --soft head^ or git reset --soft head~ </code></pre><p><strong> это отменит последний коммит. </strong></p><p>здесь <code>--soft</code> означает сброс в стадию.</p><p><code>head~ or head^</code> означает переход на коммит до head.</p><p>заменить последний коммит на новый коммит:</p><pre><code>git commit --amend -m "message" </code></pre><p>он заменит последний коммит новым коммитом.</p>

<p>вам нужно сделать легко и быстро</p><pre><code> git commit --amend </code></pre><p>если это частная ветка или</p><pre><code> git commit -m 'replace .class files with .java files' </code></pre><p>если это общая или публичная ветка.</p>

<p>у вас есть несколько вариантов, чтобы отменить ваш последний коммит. вот некоторые из ваших вариантов, обобщенных в один ответ с фрагментами кода</p><p><strong>прежде всего вам нужно выяснить, какие «неправильные» коммиты вы хотите отменить.</strong> мы будем использовать <code>git reflog</code>, чтобы найти его.</p><hr><h3> <a href="https://git-scm.com/docs/git-reflog"><code>git reflog</code></a> </h3><p>вы также всегда можете использовать <code>reflog</code>.<br> <code>git reflog</code> отобразит любое изменение, которое обновило <code>head</code>, а проверка нужной записи reflog вернет <code>head</code> к этому коммиту. </p><p><strong>каждый раз, когда head изменяется, в <code>reflog</code></strong> появляется новая запись.<br> <code>reflog</code> похож на команду истории unix и хранится локально на вашем компьютере.</p><pre><code>git reflog git checkout head@{...} # or git checkout <sha-1> </code></pre><p>используя checkout, вы можете вернуться к любому желаемому коммиту и создать ветку или любые другие опции, которые вам позволит сделать git checkout.</p><p> <a href="https://i.stack.imgur.com/atw9w.png"> <img src="https://i.stack.imgur.com/atw9w.png" alt="enter image description here"> </a> </p><hr><h3><strong><em> <a href="https://git-scm.com/docs/git-reset"><code>git reset head --hard <commit\_id></code></a> </em></strong></h3><p><strong>"переместите"</strong> вашу голову назад к желаемому коммиту.<br> git reset будет извлекать желаемый контент коммитов в вашу промежуточную область и/или в ваш рабочий каталог на основе значения <code>--hard/--soft/--mixed</code>, которое вы выберете. <code>--hard</code> обновит область рабочей области и рабочий каталог с заданным содержимым и "отсоединит" любые другие коммиты за пределами этой точки в вашей локальной ветке. </p><p>если эти коммиты не являются частью какой-либо другой ветки, они станут "болтаться".<br> «болтающийся» контент означает, что в вашем локальном репозитории есть недоступный контент, который не является частью какой-либо другой ветки и может быть удален или будет удален <code>gc</code>.</p><pre><code># 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. </code></pre><hr><p>эта схема иллюстрирует, какая команда что делает.<br> как вы можете видеть, <code>reset && checkout</code> изменяет <code>head</code>.</p><p> <a href="https://i.stack.imgur.com/nuthl.png"> <img src="https://i.stack.imgur.com/nuthl.png" alt="enter image description here"> </a> </p>

<p>используйте эту команду:</p><pre><code>git checkout -b old-state number\_commit </code></pre>

<p>используйте эту команду</p><pre><code>git checkout -b old-state 0d1d7fc32 </code></pre>

<p><strong> удалить неправильный коммит, который уже передан в github </strong></p><pre><code>git push origin +(previous good commit id):(branch name) </code></pre><p>пожалуйста, укажите последний хороший идентификатор фиксации, который вы хотели бы сбросить обратно в github.</p><p>например. если последний идентификатор фиксации неверен, укажите предыдущий идентификатор фиксации в приведенной выше команде git с именем ветви. </p><p>вы можете получить идентификатор предыдущего коммита, используя <code>git log</code></p>

<p>чтобы избавиться от (всех изменений) последнего коммита, последние 2 коммитов и последний n коммитов:</p><pre><code>git reset --hard head~1 git reset --hard head~2 ... git reset --hard head~n </code></pre><p>и, чтобы избавиться от чего-либо после определенного коммита:</p><pre><code>git reset --hard <commit sha> </code></pre><p>например., </p><pre><code>git reset --hard 0d12345 </code></pre><blockquote> <p>ps:<br> 1- будьте осторожны, из-за «жесткого» параметра, он удаляет локальные изменения в вашем репо и возвращается к предыдущему коммиту. вы должен выполнить это, если вы уверены, что запутались в своем последнем коммите (-ах) и хотел бы вернуться во времени. </p> <p>2- обычно достаточно 7 букв "commit sha", но больше проекты, вам может понадобиться до 12 писем, чтобы гарантировать уникальность. вы также можно упомянуть целых 40 букв ша.</p> <p>3. вышеприведенные команды работают и в github для windows.</p> </blockquote>

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

<p>вы можете отменить свои коммиты git двумя способами: во-первых, вы можете использовать <code>git revert</code>, если вы хотите сохранить историю коммитов:</p><pre><code>git revert head~3 git revert <hashcode of commit> </code></pre><p>во-вторых, вы можете использовать <code>git reset</code>, который удалит всю вашу историю коммитов и приведет вашу голову к коммиту, где вы хотите.</p><pre><code>git reset <hashcode of commit> git reset head~3 </code></pre><p>вы также можете использовать ключевое слово <code>--hard</code>, если любое из них начинает вести себя иначе. но я бы порекомендовал это только до крайней необходимости.</p>

<p>ссылка: <a href="http://www.coding-issues.com/2017/03/how-to-undo-or-revert-last-commits-in-git.html">как отменить последний коммит в git?</a> </p><p>если у вас установлены git extensions, вы можете легко отменить/отменить любой коммит (вы можете скачать расширения git из <a href="https://gitextensions.github.io/">здесь</a> ).</p><p>откройте git extensions, щелкните правой кнопкой мыши на коммите, который вы хотите отменить, и выберите «отменить коммит». </p><p> <a href="https://i.stack.imgur.com/j2fk1.png"> <img src="https://i.stack.imgur.com/j2fk1.png" alt="git extensions screen shot"> </a> </p><p>откроется всплывающее окно (см. скриншот ниже)</p><p> <a href="https://i.stack.imgur.com/skufo.jpg"> <img src="https://i.stack.imgur.com/skufo.jpg" alt="revert commit popup"> </a> </p><p>выберите «автоматически создавать фиксацию», если вы хотите напрямую зафиксировать отмененные изменения или если вы хотите вручную зафиксировать отмененные изменения, оставьте флажок снятым и нажмите кнопку «восстановить этот фикс».</p>

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

<p>я нашел <a href="http://ohshitgit.com/">этот</a> сайт, который описывает, как отменить вещи, которые вы совершили в хранилище.</p><p>некоторые команды:</p><pre><code>git commit --amend # change last commit git reset head~1 --soft # undo last commit </code></pre>

<p>вот сайт: <a href="http://ohshitgit.com/"><code>oh shit, git!</code></a> .</p><p>вот много рецептов, как отменить вещи в git. некоторые из них:</p><blockquote> <p>о, , мне нужно изменить сообщение о моем последнем коммите!</p> </blockquote><pre><code>git commit --amend # follow prompts to change the commit message </code></pre><blockquote> <p>о, , я случайно совершил что-то, что нужно освоить, что должно было быть в совершенно новой отрасли!</p> </blockquote><pre><code># 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 :) </code></pre>

<p>вы можете отменить свои коммиты из локального хранилища. пожалуйста, следуйте приведенному ниже сценарию.</p><p>на изображении ниже я проверяю ветку 'test' (используя команду git <code>git checkout -b test</code>) как локальную и проверяю состояние (используя команду git <code>git status</code>) локальной ветки, что нечего коммитить.</p><p> <a href="https://i.stack.imgur.com/kq0ds.png"> <img src="https://i.stack.imgur.com/kq0ds.png" alt="enter image description here"> </a> </p><p>на следующем изображении, которое вы видите здесь, я сделал несколько изменений в <strong>filter1.txt</strong> и добавил этот файл в область подготовки, а затем зафиксировал свои изменения с помощью некоторого сообщения (используя команду git <code>git commit -m "doing commit to test revert back"</code>).</p><p><strong>"-m для сообщения о коммите"</strong></p><p> <a href="https://i.stack.imgur.com/opwzo.png"> <img src="https://i.stack.imgur.com/opwzo.png" alt="enter image description here"> </a> </p><p>на следующем изображении вы можете увидеть в журнале ваших коммитов все, что вы сделали (используя команду git <code>git log</code>).</p><p> <a href="https://i.stack.imgur.com/2keah.png"> <img src="https://i.stack.imgur.com/2keah.png" alt="enter image description here"> </a> </p><p>таким образом, на изображении выше вы можете видеть идентификатор коммита с каждым коммитом и с вашим сообщением коммита теперь, независимо от того, какой коммит вы хотите вернуть назад или отменить копирование этого коммит-идентификатора и нажмите следующую команду git, <code>git revert {"paste your commit id"}</code>. пример:</p><pre><code>git revert 9ca304ed12b991f8251496b4ea452857b34353e7 </code></pre><p> <a href="https://i.stack.imgur.com/mi04t.png"> <img src="https://i.stack.imgur.com/mi04t.png" alt="enter image description here"> </a> </p><p>я вернул свой последний коммит. теперь, если вы проверите свой статус git, вы увидите измененный файл <strong>filter1.txt</strong>, который еще предстоит зафиксировать.</p><p> <a href="https://i.stack.imgur.com/dfdmu.png"> <img src="https://i.stack.imgur.com/dfdmu.png" alt="enter image description here"> </a> </p>

<p>самый простой способ отменить последний коммит</p><pre><code>git reset head^ </code></pre><p>это принесет состояние проекта до того, как вы сделали коммит.</p>

<p>в intellij idea вы можете просто открыть журнал репозитория git, нажав <kbd>alt</kbd>+<kbd>9</kbd>, щелкните правой кнопкой мыши на каком-либо теге из списка фиксаций и выберите: <em>"сбросить текущую ветвь до здесь ..."</em>.</p>

<p><strong>голова:</strong></p><p>перед сбросом коммитов мы должны знать о head ... head - это не что иное, как ваше текущее состояние в вашем рабочем каталоге. он представлен номером коммита.</p><p><strong>git commit:</strong></p><p>каждое изменение присваивается в коммите, который представлен уникальным тегом. коммиты не могут быть удалены. так что, если вы хотите получить свой последний коммит, вы можете просто погрузиться в него, используя <code>git reset</code>.</p><p>вы можете погрузиться в последний коммит, используя два метода:</p><p><strong>метод 1:</strong> (если вы не знаете номер коммита, но хотите перейти к самому первому)</p><pre><code>git reset head~1 # it will move your head to last commit </code></pre><p><strong>метод 2:</strong> (если вы знаете коммит, вы просто сбрасываете его на ваш известный коммит)</p><p><code>git reset 0xab3</code> # номер коммита</p><p><strong>примечание:</strong> если вы хотите узнать недавний коммит, попробуйте <code>git log -p -1</code></p><p>вот графическое представление:</p><p> <a href="https://i.stack.imgur.com/boiko.png"> <img src="https://i.stack.imgur.com/boiko.png" alt="enter image description here"> </a> </p>

<h1>разница между git reset --mixed, --soft и --hard</h1><blockquote> <p>предварительное условие: при внесении изменений в существующий файл в вашем репозиторий сделан, это изменение изначально считается неустановленным . для того, чтобы зафиксировать изменения, он должен быть организован, что означает добавив его в индекс с помощью <code>git add</code>. во время операции фиксации промежуточные файлы добавляются в индекс.</p> </blockquote><p>давайте возьмем пример: </p><pre><code>- a - b - c (master) </code></pre><p><code>head</code> указывает на <code>c</code>, а индекс соответствует <code>c</code>.</p><h2>--мягкий</h2><ul> <li>когда мы выполняем <code>git reset --soft b</code> с намерением <strong>удалить коммит c</strong> и <strong>указать ведущему/head на b</strong>. </li> <li>master/head теперь будет указывать на b, но индекс <strong>все еще изменился с c</strong>. </li> <li>при выполнении <code>git status</code> вы могли видеть файлы, проиндексированные в <strong>commit c</strong>, как <strong>staged</strong>. </li> <li>выполнение <code>git commit</code> в этот момент создаст новый коммит с <strong>такими же изменениями, как c</strong></li> </ul><h2>--mixed</h2><ul> <li>выполнить <code>git reset --mixed b</code>. </li> <li>при выполнении master/head будет указывать на b, а индекс <strong>также изменяется в соответствии с b</strong> из-за используемого смешанного флага. </li> <li>если в этот момент мы запустим git commit, ничего не произойдет, поскольку <strong>index соответствует head</strong>.</li> <li>у нас все еще есть изменения в рабочем каталоге, но, поскольку они отсутствуют в индексе, в состоянии <strong>git они отображаются как unstaged</strong>. </li> <li>чтобы зафиксировать их, вы должны <code>git add</code>, а затем зафиксировать как обычно.</li> </ul><h2>--жесткий</h2><ul> <li>выполнить <code>git reset --hard b</code></li> <li>при выполнении master/head будет указывать на b <strong>и изменяет ваш рабочий каталог</strong></li> <li><strong>изменения, добавленные в c</strong> и <strong>все незафиксированные изменения</strong>, будут <strong>удалены</strong>.</li> <li>файлы в рабочей копии будут соответствовать коммиту b, это приведет к окончательной потере всех изменений, которые были сделаны в коммите c плюс незафиксированные изменения</li> </ul><p>надеюсь, что сравнение флагов, доступных для использования с командой <code>git reset</code>, поможет кому-то использовать их с умом. обратитесь к ним для получения дополнительной информации <a href="https://gist.github.com/tnguyen14/0827ae6eefdff39e452b">link1</a> & <a href="https://stackoverflow.com/questions/3528245/whats-the-difference-between-git-reset-mixed-soft-and-hard">link2</a> </p>

<p>перебазирование и удаление коммитов являются лучшими, когда вы хотите сохранить историю в чистоте полезно при предложении исправлений для публичной ветки и т.д.</p><p>если вам нужно отбросить самый верхний коммит, то поможет следующий однострочный</p><pre><code>git rebase --onto head~1 head </code></pre><p>но если вы хотите отбросить 1 из многих коммитов, вы сказали</p><p>a -> b -> c -> d -> мастер</p><p>и вы хотите отбросить коммит 'c'</p><pre><code>git rebase --onto b c </code></pre><p>это сделает «b» новой базой «d», исключив «c»</p>

<p>найдите хэш-код последнего коммита, просмотрев журнал по:</p><pre><code>git log </code></pre><p>затем</p><pre><code>git reset <the previous co> </code></pre>

<p>для полноты картины я приведу один явно очевидный метод, который был упущен из предыдущих ответов.</p><p>так как фиксация не была передана, пульт не изменился, поэтому:</p><ol> <li>удалить локальный репозиторий.</li> <li>клонировать удаленный репозиторий.</li> </ol><p>это иногда необходимо, если ваш модный клиент git прощается. (например, ошибки <code>non-fast-forward</code>)</p><p>не забудьте повторно зафиксировать ваши<em> сохраненные </em>изменения с момента последнего push.</p>

<p> <a href="https://i.stack.imgur.com/uefvy.png"> <img src="https://i.stack.imgur.com/uefvy.png" alt="enter image description here"> </a> </p><p>предполагая, что вы работаете в visual studio, если вы заходите в историю веток и просматриваете все свои коммиты, просто выберите событие до коммита, который вы хотите отменить, щелкните его правой кнопкой мыши и выберите <code>revert</code>. легко как то.</p>

<p>если вы хотите устранить неправильные файлы, вы должны сделать </p><p><code>git reset --soft <your\_last\_good\_commit\_hash\_here></code> вот, если вы сделаете <code>git status</code>, вы увидите файлы в промежуточной области. вы можете выбрать неправильные файлы и убрать их из области подготовки.</p><p>вроде следующего.</p><p><code>git reset wrongfile1 wrongfile2 wrongfile3</code></p><p>теперь вы можете просто добавить файлы, которые вам нужно нажать,</p><p><code>git add goodfile1 goodfile2</code></p><p>совершить их </p><p><code>git commit -v</code> или <code>git commit -am "message"</code></p><p>и нажмите</p><p><code>git push origin master</code></p><p>однако, если вы не заботитесь об измененных файлах, вы можете выполнить полный возврат к предыдущей удачной фиксации и перенести все на сервер.</p><p>от </p><pre><code>git reset --hard <your\_last\_good\_commit\_hash\_here> </code></pre><p><code>git push origin master</code></p><p>если вы уже опубликовали свои неправильные файлы на сервере, вы можете использовать флаг <code>--force</code> для отправки на сервер и редактирования истории.</p><p><code>git push --force origin master</code></p>

<p>попробуйте сделать это, сделав полный сброс до предыдущего коммита, где эти файлы не были добавлены, затем:</p><pre><code>git reset --hard <commit\_hash> </code></pre><p>убедитесь, что у вас есть резервная копия ваших изменений на всякий случай, так как это жесткий сброс, а это значит, что они будут потеряны (если вы не спрятали ранее)</p>

<pre><code>git reset --soft head~1 </code></pre><p>сброс перемотает вашу текущую ветку head до указанной ревизии.<strong> примечание </strong>флаг --soft: это гарантирует сохранение изменений в отмененных ревизиях. после запуска команды вы найдете эти изменения в качестве незафиксированных локальных изменений в вашей рабочей копии.</p><p>если вы не хотите сохранять эти изменения, просто используйте флаг --hard. делайте это только тогда, когда вы уверены, что эти изменения вам больше не нужны.</p><pre><code> git reset --hard head~1 </code></pre><blockquote> <p>отмена нескольких коммитов</p> </blockquote><pre><code>git reset --hard 0ad5a7a6 </code></pre><p>имейте в виду, однако, что использование команды сброса отменяет все коммиты, которые пришли после того, к которому вы вернулись: <a href="https://i.stack.imgur.com/slheg.png"> <img src="https://i.stack.imgur.com/slheg.png" alt="enter image description here"> </a> </p>

<p>то, что я делаю каждый раз, когда мне нужно отменить коммит/коммит, это:</p><ol> <li><code>git reset head~<n></code> // количество последних коммитов, которые мне нужно отменить</li> <li><p><code>git status</code> // необязательно. все файлы теперь в красном (не в формате).</p></li> <li><p>теперь я могу добавить и зафиксировать только те файлы, которые мне нужны:</p> <ul> <li><code>git add <file names> & git commit -m "message" -m "details"</code></li> </ul></li> <li>необязательно: я могу откатить изменения остальных файлов, если мне нужно, до их прежнего состояния с помощью checkout: <ul> <li><code>git checkout <filename></code></li> </ul></li> <li>если я уже передал его на удаленный источник, ранее: <ul> <li><code>git push origin <branch name> -f</code> // используем -f для принудительной отправки.</li> </ul></li> </ol>

<h2>если вы хотите отменить самый первый коммит в вашем репо</h2><p>вы столкнетесь с этой проблемой:</p><pre><code>$ 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>...] -- [...]' ошибка возникает из-за того, что если последним коммитом является начальный коммит (или его нет) в репозитории, head ~ нет.решение<strong> если вы хотите сбросить единственный коммит на "главной" ветке </strong>$ git update-ref -d head $ git rm --cached -r . 

получите последний идентификатор фиксации, используя эту команду (в журнале один сверху самый последний):git log получите идентификатор фиксации (guid) и выполните эту команду:git revert <commit_id> 

как редактировать более ранний коммиткак правило, я не хочу отменять кучу коммитов, а скорее отредактировать предыдущий коммит так, как мне хотелось бы, чтобы он был зафиксирован в первую очередь.я обнаружил, что исправляю прошлый коммит достаточно часто, поэтому я написал для него скрипт.вот рабочий процесс: git commit-edit <commit-hash>  это приведет вас к коммиту, который вы хотите отредактировать. изменения коммита будут<strong> un </strong>поэтапными, готовыми к постановке так, как вы хотите, чтобы это было в первый раз. фиксируйте и ставьте коммит так, как вам хотелось бы. (вы можете использовать git stash save --keep-index, чтобы спрятать любые файлы, которые вы не делаете) повторите коммит с помощью --amend, например: git commit --amend  завершите перебазирование: git rebase --continue  назовите это следующим git-commit-edit и вставьте его в свой $path</code>:</p><pre class="lang-bash prettyprint-override"><code>#!/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: %sn' "$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 </code></pre>

<p>если вы просто хотите удалить все ваши локальные изменения/коммиты и сделать вашу локальную ветку похожей на ветку origin, с которой вы начали ...</p><p><code>git reset --hard origin/branch-name</code></p>

<pre><code>git revert commit </code></pre><p>это сгенерирует противоположные изменения от коммита, который вы хотите вернуть обратно, а затем просто зафиксируйте эти изменения. я думаю, что это самый простой способ.</p><p> <a href="https://git-scm.com/docs/git-revert">https://git-scm.com/docs/git-revert</a> </p>

<p>замените вашу локальную версию, включая ваши изменения, версией сервера, эти две строки кода заставят git вытянуть и перезаписать локальную. откройте командную строку и перейдите к корню проекта git. если вы используете vs, нажмите team, synch и нажмите «открыть командную строку» (см. изображение) ниже. </p><p> <a href="https://i.stack.imgur.com/seziw.png"> <img src="https://i.stack.imgur.com/seziw.png" alt="visual studio"> </a> </p><p>попав в cmd prompt, выполните следующие две инструкции. </p><pre><code>git fetch --all </code></pre><p>тогда вы делаете</p><pre><code>git reset --hard origin/master </code></pre><p>это заменит существующую локальную версию той, что на git server</p>

<pre><code>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 </code></pre>