Как мне отменить команду "git add" перед фиксацией?

Я по ошибке добавил файлы в Git с помощью команды:

git add myfile.txt

Я еще не запускал git commit. Есть ли способ отменить это, чтобы эти файлы не были включены в коммит?

Начиная с Git v1.8.4, все ответы ниже, которые используют HEAD или head, теперь могут использовать @ вместо HEAD. См. этот ответ (последний раздел), чтобы узнать, почему вы можете это сделать.

user456814 26.07.2013 06:04

Я сделал небольшое резюме, в котором показаны все способы деактивации файла: stackoverflow.com/questions/6919121/…

Daniel Alder 26.04.2014 16:09

Почему бы не использовать git checkout?

Erik Reppen 05.09.2016 17:57

@ErikReppen git checkout не удаляет поэтапные изменения из индекса фиксации. Он только возвращает неустановленные изменения к последней зафиксированной ревизии - что, кстати, тоже не то, что я хочу, я хочу эти изменения, я просто хочу, чтобы они были в более позднем коммите.

paxos1977 07.09.2016 00:08

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

Hamzahfrq 17.11.2016 15:49

Это отличный ресурс прямо с Github: Как отменить (почти) что угодно с помощью Git

jasonleonhard 04.02.2017 00:13

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

Sazzad Hissain Khan 15.06.2017 18:29

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

scubbo 03.02.2018 01:59

git удалить myfile.txt

Simon Berton 13.02.2018 14:48

Я всегда выполняю эту работу, используя git reset <file_name>. Для получения дополнительной информации обязательно взгляните на эта статья.

Nesha Zoric 07.05.2018 15:23

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

Uğur Gümüşhan 23.03.2020 12:04
git rm --cached <file>без сцены и без треков (помечен для удаления при следующей фиксации) заданный файл, а git reset HEAD <file> просто сцены файл
Dennis 31.01.2021 01:26
Получение данных из формы с помощью JavaScript - краткое руководство
Получение данных из формы с помощью JavaScript - краткое руководство
Получить данные из формы с помощью JS очень просто: вы запрашиваете элемент формы, передаете его конструктору new FormData() и, наконец, получаете...
Пользовательские правила валидации в Laravel
Пользовательские правила валидации в Laravel
Если вы хотите создать свое собственное правило валидации, Laravel предоставляет возможность сделать это. Создайте правило с помощью следующей...
3 метода стилизации элементов HTML
3 метода стилизации элементов HTML
Когда дело доходит до применения какого-либо стиля к нашему HTML, существует три подхода: встроенный, внутренний и внешний. Предпочтительным обычно...
Формы c голосовым вводом в React с помощью Speechly
Формы c голосовым вводом в React с помощью Speechly
Пытались ли вы когда-нибудь заполнить веб-форму в области электронной коммерции, которая требует много кликов и выбора? Вас попросят заполнить дату,...
Стилизация и валидация html-формы без использования JavaScript (только HTML/CSS)
Стилизация и валидация html-формы без использования JavaScript (только HTML/CSS)
Будучи разработчиком веб-приложений, легко впасть в заблуждение, считая, что приложение без JavaScript не имеет права на жизнь. Нам становится удобно...
Flatpickr: простой модуль календаря для вашего приложения на React
Flatpickr: простой модуль календаря для вашего приложения на React
Если вы ищете пакет для быстрой интеграции календаря с выбором даты в ваше приложения, то библиотека Flatpickr отлично справится с этой задачей....
9 637
12
3 586 471
37
Перейти к ответу Данный вопрос помечен как решенный

Ответы 37

Для этого можно использовать git remove или git rm с флагом --cached. Пытаться:

git help rm

Разве это не удалит файл полностью?

Willa 26.08.2015 08:29
git rm --cached ... удалит файлы из репозитория git. Они все еще будут существовать на вашем компьютере, но это ОЧЕНЬ отличается от удаления изменения в файл. Для тех, кто наткнулся на это, это неверный ответ на вопрос.
Addison 17.12.2018 23:02
Ответ принят как подходящий

Вы можете отменить git add перед фиксацией с помощью

git reset <file>

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

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

git reset

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

В старых версиях Git указанные выше команды эквивалентны git reset HEAD <file> и git reset HEAD соответственно и завершатся ошибкой, если значение HEAD не определено (потому что вы еще не сделали никаких коммитов в своем репозитории) или неоднозначно (потому что вы создали ветку с именем HEAD, которая это глупая вещь, которую вы не должны делать). Однако это был изменен в Git 1.8.2, поэтому в современных версиях Git вы можете использовать приведенные выше команды еще до совершения первого коммита:

"git reset" (without options or parameters) used to error out when you do not have any commits in your history, but it now gives you an empty index (to match non-existent commit you are not even on).

Документация: git сбросить

Конечно, это не настоящая отмена, потому что, если неправильный git add перезаписал предыдущую поэтапную незафиксированную версию, мы не сможем ее восстановить. Я попытался пояснить это в своем ответе ниже.

leonbloy 06.05.2013 23:10
git reset HEAD *.ext, где ext - это файлы с заданным расширением, которые вы хотите отменить. Для меня это были *.bmp и *.zip
boulder_ruby 26.11.2013 18:25

git reset сказал, что он отменил изменения, но когда я перешел к другому статусу git, они все еще показывали измененные

PositiveGuy 16.10.2015 06:39

Значит, противоположность «добавить» - это «сбросить»? А как насчет «удалить»?

Jonny 17.02.2016 08:53

@Jonny, индекс (он же промежуточная область) содержит файлы все, а не только измененные файлы. Он «запускает жизнь» (когда вы проверяете фиксацию или клонируете репо) как копию всех файлов в фиксации, на которые указывает HEAD. Итак, если вы Удалить файла из индекса (git rm --cached), это означает, что вы готовитесь сделать фиксацию этого удаляет этого файла. git reset HEAD <filename>, с другой стороны, скопирует файл из HEAD в индекс, так что следующая фиксация не покажет никаких изменений, внесенных в этот файл.

Wildcard 16.03.2016 15:27

Я только что обнаружил, что есть git reset -p, как и git add -p. Это круто!

donquixote 18.07.2016 02:23
-p определенно великолепен, и он используется во многих командах git (а не только в сбросе и добавлении). Но чтобы ответить на @ WeDoTDD.com и @Johnny, git reset сам по себе просто выясняет, «знает ли Git об изменениях»; он не очищает сами изменения. Для этого вам нужно сделать git checkout someFile.txt (для отдельных файлов) или git reset --hard (чтобы стереть все чисто). Однако ни одна из этих команд не вернется назад, поэтому будьте очень осторожны при их использовании.
machineghost 15.12.2016 21:33

но «git reset file» удаляет и другие файлы, которые также были подготовлены для фиксации. нехорошо.

Arthur 17.02.2017 19:29

На самом деле вы может восстанавливать перезаписанные ранее поставленные, но незавершенные изменения, но не удобным для пользователя способом и не на 100% безопасным (по крайней мере, я не нашел): goto .git / objects, поиск файлов, созданных во время git add, которые вы хотите восстановить (61/3AF3... -> идентификатор объекта 613AF3...) , затем git cat-file -p <object-id> (возможно, стоит восстановить несколько часов работы, но также урок, который нужно делать чаще ...)

Peter Schneider 31.07.2017 17:03

Другой способ восстановить изменения, которые были поставлены, но не зафиксированы, а затем перезаписаны, например, другой git add - через git fsck --unreachable, который перечислит все недостижимые объекты, которые вы затем можете проверить с помощью git show SHA-1_ID или git fsck --lost-found, которые будут> записывать висячие объекты в .git/lost-found/commit/ или .git/lost-found/other/, в зависимости от типа. См. Также git fsck --help

iolsmit 27.04.2018 18:27

Начиная с git 2.23.0, теперь есть "git restore --staged <file>..." to unstage. См. stackoverflow.com/a/16044987/40422

Bill Hoag 20.11.2019 22:31

Я также добавил на сцену несколько файлов из общей библиотеки. Поскольку это угловое приложение, мне пришлось использовать git reset */commonlib/styles/*.scss, чтобы найти все такие файлы, и это сработало.

akgupta 22.01.2020 22:22

Хорошо объяснено ... полезно для новичков

Satish Hawalppagol 06.08.2020 09:20

Спасибо, это было легко понять и было полезно.

wesley franks 18.08.2020 04:25

Я не знаю, правильно ли я сделал это, но git reset <file>, похоже, также удалил файл из моей файловой системы, что, очевидно, не то, что вы хотите.

crobar 14.10.2020 13:18

Если вы наберете:

git status

Git расскажет, что ставится, и т. д., Включая инструкции по отключению:

use "git reset HEAD <file>..." to unstage

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

Примечание. В последних версиях Git (1.8.4.x) это сообщение было изменено:

(use "git rm --cached <file>..." to unstage)

Сообщение будет отличаться в зависимости от того, отслеживался ли уже файл added (add сохранил в кеш только новую версию - здесь будет отображаться ваше сообщение). В другом месте, если файл ранее не создавался, будет отображаться use "git rm --cached <file>..." to unstage.

leonbloy 06.05.2013 22:25

Большой! git reset HEAD <file> - единственный, который будет работать, если вы хотите отключить удаление файла.

skerit 24.02.2018 03:25

Моя версия git 2.14.3 говорит, что git reset HEAD отключен.

SilverWolf 23.04.2018 22:16

Начиная с Git v2.23 сообщение снова изменилось. Теперь там написано git restore --staged <file>. Смотрите мой ответ ниже для обновления.

prosoitos 19.11.2020 20:02

Ты хочешь:

git rm --cached <added_file_to_undo>

Рассуждение:

Когда я был новичком в этом, я сначала попробовал

git reset .

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

fatal: Failed to resolve 'HEAD' as a valid ref.

Оказывается, это потому, что ссылка HEAD (ветка?) Не существует до момента первого коммита. То есть вы столкнетесь с той же проблемой новичка, что и я, если бы ваш рабочий процесс, как и мой, был примерно таким:

  1. cd в каталог моего нового великого проекта, чтобы опробовать Git, новую популярность
  2. git init
  3. git add .
  4. git status

    ... много свитков дерьма от ...

    => Блин, я не хотел все это добавлять.

  5. Google "отменить git add"

    => найти переполнение стека - ура

  6. git reset .

    => фатальный: не удалось разрешить "HEAD" как действительную ссылку.

Далее выясняется, что в списке рассылки есть ошибка зарегистрирована против бесполезности этого.

И что правильное решение было прямо там, в выводе статуса Git (что, да, я замалчивал как `` дерьмо)

...
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
...

И решение действительно - использовать git rm --cached FILE.

Обратите внимание на предупреждения в другом месте - git rm удаляет вашу локальную рабочую копию файла, но нет, если вы используете --cached. Вот результат git help rm:

--cached Use this option to unstage and remove paths only from the index. Working tree files, whether modified or not, will be left.

Я продолжаю использовать

git rm --cached .

удалить все и начать заново. Однако это не сработало, потому что, хотя add . является рекурсивным, оказывается, что rm нуждается в -r для рекурсии. Вздох.

git rm -r --cached .

Хорошо, теперь я вернулся к тому, с чего начал. В следующий раз я собираюсь использовать -n для пробного запуска и посмотреть, что будет добавлено:

git add -n .

Я заархивировал все в безопасное место, прежде чем поверить git help rm в том, что --cached ничего не разрушает (и что, если я ошибся в написании).

Не просто "git reset" без. делай что хочешь, или я чего-то упускаю?

ustun 11.11.2009 15:21

Ха. Я последовал тому же самому процессу. За исключением того, что я сдался и сказал rm -rf .git, git init, потому что я не доверял git rm --cached, чтобы сохранить мою рабочую копию. Это немного говорит о том, что git в некоторых местах все еще слишком сложен. git unstage должен быть стандартной стандартной командой, мне все равно, могу ли я добавить ее в качестве псевдонима.

Adrian Macneil 29.03.2011 07:45

Сделал это, и он удалил все остальные мои существующие файлы - без изменений - из резервной копии git. Их повторное добавление делает все больше и разрушает настоящую историю. Git - это полностью незаконченный проект.

SamGoody 01.06.2011 13:09

в последних версиях git (проверено v1.7.1.1) git rm -r --cached . работает нормально

Tom Davies 22.11.2011 19:23

Если вам нравится git reset, попробуйте git reset * вместо git reset . - он разложит все ранее поставленные файлы.

Marius Butuc 10.12.2011 01:58

Блестящий ответ, который точно описал мой рабочий процесс. Это действительно должен быть принятый ответ, чтобы быть первым, поскольку этот Q - это то, что находится вверху результатов поиска для "git unstage".

Henric 16.12.2011 13:36

Вместо пробного прогона пройдите адд с git add -p

jlundqvist 29.04.2012 02:05

Для меня git говорит git reset HEAD <File>...

drahnr 12.09.2012 10:50

Вы также можете использовать git stash/git stash pop, чтобы избежать архивирования / резервного копирования всего.

chachan 03.11.2012 23:05

git rm --cached <file> на самом деле правильный ответ, если это начальный импорт <file> в репозиторий. Если вы пытаетесь отключить изменение файла, правильным ответом будет git reset. Люди, утверждающие, что это неверный ответ, думают о другом вопросе.

Barry Kelly 01.03.2013 02:14

Это действительно сработает, но Только при первой фиксации, если файл не существовал ранее или когда команда git add добавила новые файлы, но нет изменяет существующие файлы.

naught101 10.04.2013 06:33

Я определенно считаю, что если это совершенно новый репозиторий, удаление каталога .git и повторная инициализация - лучший способ. Для случаев в хорошо используемом репозитории, когда вы просто случайно добавили один файл, лучше всего подходит git rm --cached <file>, хотя после фиксации я получаю пугающий delete mode 100644 file.

deed02392 15.07.2013 02:28

в соответствии с выводом git status git версии 1.8.1.4 правильный способ деактивации новых файлов: git reset HEAD <file>...

akostadinov 28.08.2013 22:25

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

ahnbizcad 24.05.2014 14:54

@BarryKelly, нет, это неправильный ответ. На самом деле вы хотите сделать либо git reset, чтобы отменить все добавленные файлы, либо git reset <file>, чтобы отменить определенный добавленный файл. git rm --cached может работать на поверхности, но что на самом деле происходит, так это то, что он также удаляет его из истории отслеживания, что не является тем, что вы хотели бы делать, если только вы не добавили этот файл в файл gitignore, где этот файл не должен был отслеживаться в первое место, тогда в таком случае все было бы нормально.

JoeMoe1984 03.06.2014 01:14

@ JoeMoe1984 git reset не работает с пустыми репозиториями (начальный импорт)

Barry Kelly 03.06.2014 17:40

@BarryKelly Я пытался отредактировать свой комментарий, когда перечитывал ваш, но опоздал. Я пропустил ту часть того, что вы написали;). Но да, вы правы, это был бы еще один пример использования git rm --cached

JoeMoe1984 03.06.2014 21:33

При первоначальном заполнении репозитория git "git reset" из верхнего ответа не работает: не удалось разрешить HEAD. Мы добавили слишком много одного файла к первоначальной фиксации. Как следует из этого ответа, в этом случае у меня работает «git rm --cached <file>». Может быть, "git rm --cached." делает больше, чем предназначено для некоторых людей, но (как предполагает git status) git rm --cached <file> работает ....

rew 20.10.2015 14:31

Почему бы просто не удалить скрытую папку .git lol .. и снова выполнить git init ... (при условии, что вы делаете репозиторий git в ПЕРВЫЙ раз и не выполняете никаких коммитов)

Kevin Lee 05.04.2016 17:16

Если файлы еще не в индексе, используйте git rm --cache <filename>, если файлы уже в индексе, но вы не хотите, чтобы они были в этом коммите, используйте git reset <filename>

Ding-Yi Chen 20.10.2016 04:46

Это могло быть применимо на момент написания, но, похоже, работает сейчас.

Thomas Weller 08.06.2017 13:20

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

Vladimir Despotovic 27.09.2018 16:22

Эта команда ОЧИЩАЕТ / УДАЛЯЕТ МАТЕРИАЛЫ В ИНДЕКСЕ. На самом деле ОП и другие люди хотят ОТМЕНИТЬ ИЗМЕНЕНИЯ В ИНДЕКСЕ, а НЕ УДАЛИТЬ МАТЕРИАЛЫ. Сброс Git. это правильный ответ.

bhavya_w 18.02.2019 11:43

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

TheTechRobo36414519 29.06.2020 20:15

Я только что обнаружил, что есть git reset -p, как и git add -p. Это круто!

Ahmad 29.12.2020 02:56

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

git rm --cached FILE

Используйте rm --cached только для случайно добавленных новых файлов.

Имейте в виду, что --cached здесь действительно важная часть.

takeshin 12.04.2013 16:21

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

Mark Amery 31.10.2015 02:42

Возможно, Git изменился с тех пор, как вы разместили свой вопрос.

$> git --version
git version 1.6.2.1

Теперь вы можете попробовать:

git reset HEAD .

Это должно быть то, что вы ищете.

Конечно, но тогда у вас есть следующий вопрос о том, как следует отменить добавление одного из добавленных файлов два (или более). Однако в руководстве «git reset» упоминается, что «git reset <paths>» является противоположностью «git add <paths>».

Alex North-Keys 15.05.2013 17:36

Если вы делаете первоначальную фиксацию и не можете использовать git reset, просто объявите «Git банкротство», удалите папку .git и начните заново.

Один совет - скопируйте файл .git / config, если вы добавили удаленное происхождение, перед удалением папки.

Tiago 09.03.2010 02:15

Комментарий @ChrisJohnsen - это точно. Иногда вы хотите зафиксировать все файлы, кроме одного: git add -A && git rm --cached EXCLUDEFILE && git commit -m 'awesome commit' (это также работает, когда нет предыдущих коммитов, из-за проблемы с Failed to resolve 'HEAD')

user246672 29.03.2013 08:20
git rm --cached . -r

будет рекурсивно «отменить добавление» всего, что вы добавили из текущего каталога

Я не собирался убирать все, только ОДИН конкретный файл.

paxos1977 10.12.2009 01:35

Также полезно, если у вас нет предыдущих коммитов. В отсутствие предыдущей фиксации git reset HEAD <file> скажет fatal: Failed to resolve 'HEAD' as a valid ref.

Priya Ranjan Singh 02.06.2013 07:46

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

Mark Amery 30.10.2015 04:33

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

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

paxos1977 31.01.2013 20:21

Для пояснения: git add перемещает изменения из текущего рабочего каталога в плацдарм (индекс).

Этот процесс называется постановка. Итак, наиболее естественная команда для сцена изменений (измененных файлов) очевидна:

git stage

git add - это просто более простой псевдоним для git stage.

Жаль, что нет ни git unstage, ни git unadd команд. Соответствующий труднее угадать или запомнить, но он довольно очевиден:

git reset HEAD --

Мы можем легко создать для этого псевдоним:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

И наконец, у нас есть новые команды:

git add file1
git stage file2
git unadd file2
git unstage file1

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

git a # For staging
git u # For unstaging

"движется"? Это будет означать, что он ушел из рабочего каталога. Это не так.

Thomas Weller 08.06.2017 12:18

Почему это очевидно?

Lenar Hoyt 23.06.2017 21:25

Фактически, git stage - это псевдоним для git add, исторической команды как для Git, так и для других SCM. Он был добавлен в декабре 2008 года с коммитом 11920d28da в «репозиторий Git git», если можно так выразиться.

Obsidian 12.09.2018 21:13

Это может быть не связано, но я обнаружил, что проверка файла до того, как даже добавить, была полезной идеей, что-то вроде check-command filename && git add filename, я заменил git на более короткий g на моей машине, и до сих пор он работал хорошо для меня: github.com/dataf3l/g, я не знаю, будет ли это кому-то полезно, но я помещу его сюда в надежде, что это сэкономит время некоторых людей.

Felipe Valdes 12.07.2019 13:21

Как и многие другие ответы, вы можете использовать git reset

НО:

Я нашел этот замечательный небольшой пост, который на самом деле добавляет команду Git (ну, псевдоним) для git unadd: подробности см. В git unadd или ..

Просто,

git config --global alias.unadd "reset HEAD"

Теперь вы можете

git unadd foo.txt bar.txt

Альтернативно / напрямую:

git reset HEAD foo.txt bar.txt

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

Не о чем беспокоиться; файл действительно все еще находится в репозитории, но только как «свободный объект». Он не будет скопирован в другие репозитории (через clone, push), а пространство в конечном итоге будет освобождено - хотя, возможно, не очень скоро. Если вы беспокоитесь, можете бежать:

git gc --prune=now

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

Итак, каков настоящий отменитьgit add?

git reset HEAD <file>?

или же

git rm --cached <file>?

Собственно говоря, и если не ошибаюсь: никто.

git addне могут быть отменены - безопасно, в общем.

Давайте сначала вспомним, что на самом деле делает git add <file>:

  1. Если <file> был ранее не отслеживался, git addдобавляет его в кеш, с его текущим содержимым.

  2. Если <file> был уже отслежено, git addсохраняет текущий контент (снимок, версия) в кэш. В Git это действие по-прежнему называется добавлять (не просто Обновить it), потому что две разные версии (снимки) файла рассматриваются как два разных элемента: следовательно, мы действительно добавляем новый элемент в кеш, чтобы в конечном итоге совершено позже.

В свете этого вопрос несколько двусмысленный:

I mistakenly added files using the command...

Сценарий OP кажется первым (неотслеживаемый файл), мы хотим, чтобы «отмена» удаляла файл (а не только текущее содержимое) из отслеживаемых элементов. Если это так, тогда можно запустить git rm --cached <file>.

А еще мы могли запустить git reset HEAD <file>. В целом это предпочтительнее, потому что это работает в обоих сценариях: оно также отменяет действие, когда мы по ошибке добавили версию уже отслеживаемого элемента.

Но есть два предостережения.

Во-первых: существует (как указано в ответе) только один сценарий, в котором git reset HEAD не работает, а git rm --cached работает: новый репозиторий (без коммитов). Но на самом деле это практически не относящийся к делу случай.

Во-вторых: имейте в виду, что git reset HEAD не может волшебным образом восстановить содержимое ранее кэшированного файла, он просто повторно синхронизирует его с HEAD. Если наш ошибочный git add перезаписал предыдущую поэтапную незафиксированную версию, мы не сможем ее восстановить. Поэтому, строго говоря, мы не можем отменить [*].

Пример:

$ git init
$ echo "version 1" > file.txt
$ git add file.txt   # First add of file.txt
$ git commit -m 'first commit'
$ echo "version 2" > file.txt
$ git add  file.txt   # Stage (don't commit) "version 2" of file.txt
$ git diff --cached file.txt
-version 1
+version 2
$ echo "version 3" > file.txt
$ git diff  file.txt
-version 2
+version 3
$ git add  file.txt    # Oops we didn't mean this
$ git reset HEAD file.txt  # Undo?
$ git diff --cached file.txt  # No dif, of course. stage == HEAD
$ git diff file.txt   # We have irrevocably lost "version 2"
-version 1
+version 3

Конечно, это не очень важно, если мы просто следуем обычному ленивому рабочему процессу, выполняя «git add» только для добавления новых файлов (случай 1), и мы обновляем новое содержимое с помощью команды commit, git commit -a.


* (Edit: the above is practically correct, but still there can be some slightly hackish/convoluted ways for recovering changes that were staged, but not committed and then overwritten - see the comments by Johannes Matokic and iolsmit)

Строго говоря, есть способ восстановить уже подготовленный файл, который был заменен git add. Как вы упомянули, git add создает объект git для этого файла, который станет свободным объектом не только при полном удалении файла, но и при перезаписи новым содержимым. Но нет команды для его автоматического восстановления. Вместо этого файл должен быть идентифицирован и извлечен вручную или с помощью инструментов, написанных только для этого случая (libgit2 позволяет это). Но это будет выплачиваться только в том случае, если файл очень важный и большой и не может быть восстановлен путем редактирования предыдущей версии.

Johannes Matokic 06.12.2017 16:07

Чтобы исправить себя: как только свободный объектный файл будет найден (используйте метаданные, такие как дата / время создания), git cat-file можно использовать для восстановления его содержимого.

Johannes Matokic 06.12.2017 16:22

Другой способ восстановить изменения, которые были поставлены, но не зафиксированы, а затем перезаписаны, например, другой git add - через git fsck --unreachable, который перечислит все недостижимые объекты, которые вы затем можете проверить с помощью git show SHA-1_ID или git fsck --lost-found, которые будут> записывать висячие объекты в .git/lost-found/commit/ или .git/lost-found/other/, в зависимости от типа. См. Также git fsck --help

iolsmit 27.04.2018 18:29

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

  • Создайте главный каталог для вашего нового проекта.
  • Запустите git init.
  • Теперь создайте файл .gitignore (даже если он пуст).
  • Зафиксируйте свой файл .gitignore.

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

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

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

Подтвержденный! Пробовал сбросить git после добавления git. и git жаловался на поврежденную HEAD. Следуя вашему совету, я мог бы без проблем git add & reset туда и обратно :)

Kounavi 04.10.2012 01:32

Вторая часть работает, но немного коряво. Как обрабатываются окончания строк, зависит от значения autocrlf ... Это не будет работать в каждом проекте, в зависимости от настроек.

sjas 29.03.2013 15:26

Этот ответ был разумным в то время, когда он был опубликован, но теперь устарел; git reset somefile и git reset теперь работают до совершения первого коммита. Так было после нескольких выпусков Git.

Mark Amery 31.10.2015 02:38

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

Ryan Lundy 31.10.2015 23:01

Запустить

git gui

и удалите все файлы вручную или выбрав их все и нажав кнопку отключение от фиксации.

Да, я это понимаю. Я только хотел косвенно предложить, чтобы вы указали, что в своем ответе, например, «Вы можете использовать git-gui ....» :)

Alexander Suraphel 01.08.2014 20:11

Он говорит: «git-gui: команда не найдена». Я не уверен, работает ли это.

Parinda Rajapaksha 13.09.2017 07:19

Вау, это намного проще, чем вводить командные строки, которые вы не понимаете. Это определенно рекомендуется для новичков вроде меня. Спасибо, что написали это!

Irfandy Jip 11.04.2019 07:27

Спасибо. Не хотел рисковать, поэтому пришлось использовать графический интерфейс.

Sagar Khatri 21.08.2019 10:48

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

git reset <path_to_file>
fatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

git reset -- <path_to_file>
Unstaged changes after reset:
M    <path_to_file>

(Git версии 1.7.5.4)

Я попробовал git reset <path>, и он отлично работает без разделителя. Я также использую git 1.9.0. Может в старых версиях не работает?

user456814 05.04.2014 09:32

Используйте git add -i, чтобы удалить только что добавленные файлы из вашего предстоящего коммита. Пример:

Добавление файла, который вам не нужен:

$ git add foo
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   foo
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]#

Переход в интерактивное добавление для отмены добавления (команды, введенные в git здесь: «r» (возврат), «1» (первая запись в списке показывает возврат), «return» для выхода из режима возврата и «q» (покидать):

$ git add -i
           staged     unstaged path
  1:        +1/-0      nothing foo

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> r
           staged     unstaged path
  1:        +1/-0      nothing [f]oo
Revert>> 1
           staged     unstaged path
* 1:        +1/-0      nothing [f]oo
Revert>> 
note: foo is untracked now.
reverted one path

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> q
Bye.
$

Вот и все! Вот ваше доказательство, показывающее, что "foo" снова в списке неотслеживаемых:

$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]
#       foo
nothing added to commit but untracked files present (use "git add" to track)
$

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

git reset *

Фактически, это не сбрасывает каждый файл, потому что * использует расширение оболочки и игнорирует точечные файлы (и точечные каталоги).

Luc 05.05.2014 03:20

Вы можете запустить git status, чтобы увидеть все, что осталось, и сбросить его вручную, например, git reset file.

Zorayr 07.05.2014 19:23

Эта команда откроет ваши изменения:

git reset HEAD filename.txt

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

git add -p 

добавлять части файлов.

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

Что ты делал раньше:

  • Изменил файл и использовал git add . или git add <file>.

Что ты хочешь:

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

     git reset HEAD <file>
    
  • Сбросьте файл в последнее состояние из HEAD, отменив изменения и удалив их из индекса:

     # Think `svn revert <file>` IIRC.
     git reset HEAD <file>
     git checkout <file>
    
     # If you have a `<branch>` named like `<file>`, use:
     git checkout -- <file>
    

    Это необходимо, поскольку git reset --hard HEAD не работает с отдельными файлами.

  • Удалите <file> из индекса и управления версиями, сохранив файл без версий с изменениями в рабочей копии:

     git rm --cached <file>
    
  • Полностью удалите <file> из рабочей копии и управления версиями:

     git rm <file>
    

Я не могу понять разницу между git reset head <file> и git rm --cached <file>. Не могли бы вы это объяснить?

jeswang 14.08.2013 04:39

Файлы @jeswang либо «известны» git (изменения в них отслеживаются), либо не контролируются версиями. reset head отменяет ваши текущие изменения, но файл все еще отслеживается git. rm --cached выводит файл из системы управления версиями, поэтому git больше не проверяет его на наличие изменений (а также удаляет в конечном итоге проиндексированные текущие изменения, сообщенные git предыдущим add), но измененный файл будет храниться в вашей рабочей копии, то есть в вас файловую папку на жестком диске.

sjas 15.08.2013 19:09

Разница в том, что git reset HEAD <file> носит временный характер - команда будет применена только к следующей фиксации, но git rm --cached <file> отключится до тех пор, пока не будет добавлен снова с git add <file>. Кроме того, git rm --cached <file> означает, что если вы нажмете эту ветку на удаленный компьютер, любой, кто потянет ветку, получит ДЕЙСТВИТЕЛЬНО удаленный файл из своей папки.

DrewT 10.08.2014 23:54

Используйте команду * для одновременной обработки нескольких файлов:

git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

и т.п.

Помните, что * обычно не включает точечные файлы или точечные каталоги, если вы явно не укажете .* или .*.prj.

Luc 05.05.2014 03:21

Вопрос четко не поставлен. Причина в том, что git add имеет два значения:

  1. добавив новый файл в промежуточную область, затем отмените с помощью git rm --cached file.
  2. добавление файла модифицированный в промежуточную область, а затем отменить с помощью git reset HEAD file.

Если сомневаетесь, используйте

git reset HEAD file

Потому что в обоих случаях он делает ожидаемую вещь.

Предупреждение:, если вы выполняете git rm --cached file с файлом, который был модифицированный (файл, который раньше существовал в репозитории), то файл будет удален на git commit! Он по-прежнему будет существовать в вашей файловой системе, но если кто-то еще извлечет вашу фиксацию, файл будет удален из его рабочего дерева.

git status сообщит вам, был ли файл новый файл или модифицированный:

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   my_new_file.txt
    modified:   my_modified_file.txt

+1. Чрезвычайное количество высоко оцененных ответов и комментариев на этой странице просто категорически неверно о поведении git rm --cached somefile. Я надеюсь, что этот ответ дойдет до страницы на видном месте, где он может защитить новичков от введения в заблуждение всеми ложными утверждениями.

Mark Amery 31.10.2015 02:44

один из лучших ответов здесь, к сожалению, он довольно низкий в списке

Creos 10.06.2019 04:10

Также есть интерактивный режим:

git add -i

Выберите вариант 3, чтобы отменить добавление файлов. В моем случае я часто хочу добавить более одного файла, а в интерактивном режиме вы можете использовать такие числа для добавления файлов. Это займет все, кроме 4: 1, 2, 3 и 5.

Чтобы выбрать последовательность, просто введите 1-5, чтобы взять все от 1 до 5.

Промежуточные файлы Git

«Я удивлен, что никто не упомянул интерактивный режим» - сделали: stackoverflow.com/a/10209776/1709587
Mark Amery 31.10.2015 02:52

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

Я создал новый файл и добавил его в Git. Затем я отключил его с помощью графического интерфейса Sourcetree. Вот результат:

Unstaging files [08/12/15 10:43] git -c diff.mnemonicprefix=false -c core.quotepath=false -c credential.helper=sourcetree reset -q -- path/to/file/filename.java

Sourcetree использует reset для деактивации новых файлов.

Да, тот же метод можно использовать с TortoiseGit, получая команды Git для общих случаев использования.

Peter Mortensen 03.11.2019 16:43
git reset filename.txt

Удалит файл с именем filename.txt из текущего индекса, области «собирается быть зафиксированным», без каких-либо изменений.

Чтобы отменить git add, используйте:

git reset filename

Предположим, я создаю новый файл newFile.txt:

Enter image description here

Допустим, я случайно добавил файл git add newFile.txt:

Enter image description here

Теперь я хочу отменить это добавление перед фиксацией git reset newFile.txt:

Enter image description here

Предположим, я нахожусь на 1-м рисунке, что означает, что я даже не делал "git.add". Кроме того, я совсем не хочу, чтобы все это изменялось. Я имею в виду, что когда я делаю git status, он не должен показывать никаких красных файлов. Я имею в виду, что он должен быть синхронизирован, как если бы ни один файл не был изменен с момента последнего git push. как этого добиться.

Unbreakable 26.03.2017 03:59

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

Unbreakable 26.03.2017 04:00

Когда я делаю git status. Я вообще не должен видеть никаких изменений. Все красные файлы должны быть возвращены.

Unbreakable 26.03.2017 04:00

Привет, я думаю, ваш вопрос заключается в том, как удалить неотслеживаемые файлы из текущего дерева. Для этого вы можете использовать «git clean -f -d». Это также удалит неотслеживаемые каталоги.

Vidura Mudalige 26.03.2017 13:19

Если вы не хотите удалять неотслеживаемые файлы, просто игнорируйте флаг «-f».

Vidura Mudalige 26.03.2017 13:20

Это не работает. Предположим, я сделал git push. Теперь, если я добавлю одну строку в свой код и проверю git status. Он покажет файл красного цвета. Предположим, я вообще не хочу, чтобы эта одна строка менялась. Один из вариантов - я могу нажать cntrl + z. Но я хочу, чтобы git сделал это за меня. Я хочу, чтобы мой локальный проект синхронизировался с главным репозиторием. Я имею в виду, что когда я делаю «git status», я должен видеть сообщение «Он синхронизируется с мастером». И когда я открываю свой код, у меня должно быть сообщение типа «какой-то внешний источник вносит изменения», и когда я говорю «Да» в ответ на это приглашение, то одно изменение строки, которое я сделал, должно исчезнуть.

Unbreakable 26.03.2017 14:06

в основном мне нужна команда git, которая отменит все изменения, которые делают статус git, чтобы отображать "красные файлы"

Unbreakable 26.03.2017 14:07

Итак, я внес изменения в файл. Больше я ничего не делал. НЕТ команды git вообще (нет git push, даже git add или git commit). Но теперь мне нужна команда git, которая отменит эти изменения в моем локальном репо.

Unbreakable 26.03.2017 14:10

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

Unbreakable 26.03.2017 14:21

Разве вы не пробовали "git checkout file_name". Кроме того, вы можете сохранить изменения с помощью «git stash».

Vidura Mudalige 26.03.2017 15:14

Git reset без Head использует текущие поэтапные файлы. Используйте команду git reset head, чтобы указать другую фиксацию. Как git reset Head ~ 2, чтобы вернуться к предыдущим коммитам. 2 - количество коммитов

ozkary 30.07.2017 15:53

Одно из самых интуитивно понятных решений - использование Sourcetree.

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

Enter image description here

git add myfile.txt # Это добавит ваш файл в список для фиксации

Совершенно противоположно этой команде,

git reset HEAD myfile.txt  # This will undo it.

Итак, вы будете в предыдущем состоянии. Указанный будет снова в неотслеживаемом списке (предыдущее состояние).

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

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

git reset HEAD myfile.txt

Объяснение:

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

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

git reset HEAD file

Изображение: "Команда добавить ..."«Команда добавляет ...» (настоящее простое время, третье лицо)

Peter Mortensen 03.11.2019 16:52

Изображение: хочухочу (здесь нет необходимости использовать сленг)

Peter Mortensen 03.11.2019 16:53
git reset filename.txt  

Will remove a file named filename.txt from the current index, the "about to be committed" area, without changing anything else.

git reset [имя файла] пример: git reset src / main / java / com / dao / ImportCsvDataDaoImpl.java

Rohit Chaurasiya 02.03.2020 13:10

Для конкретного файла:

  • git reset my_file.txt
  • git checkout my_file.txt

Для всех добавленных файлов:

  • git reset .
  • git checkout .

Примечание: проверить изменяет код в файлах и переходит в последнее обновленное (зафиксированное) состояние. сброс настроек не меняет коды; он просто сбрасывает заголовок.

Объясните, пожалуйста, разницу между git reset <file> и git checkout <file>.

Trent 23.01.2018 02:47

reset не изменяет файл, просто убирает его со сцены (= index, куда он был помещен git add)

franc 12.03.2018 14:18

checkout изменить коды в файле и перейти к последнему обновленному состоянию. сброс не меняет коды, он просто сбрасывает заголовок. Например, сбросить использование для добавленных или зафиксированных файлов, сбросить перед использованием push и checkout для возврата к последнему обновленному / зафиксированному этапу перед git add.

Hasib Kamal 14.03.2018 14:38

reset = удалить файл со сцены, однако изменения все равно будут. checkout = получает обновленный файл из репозитория и заменяет текущий файл

Imam Bux 12.09.2018 13:16

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

Вы можете сделать это, позвонив в git reset HEAD <file to change>. У вас есть два варианта, чтобы полностью избавиться от изменений. git checkout HEAD <file(s) or path(s)> - это быстрый способ отменить изменения в промежуточной области и рабочем дереве.

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

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

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

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

Обновление 2019

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

git restore --staged <file>

и отключить все файлы (из корня репо) с:

git restore --staged .

Заметки

git restore был представлен в Июль 2019 и выпущен в версии 2.23.
С флагом --staged он восстанавливает содержимое индекса (о чем здесь спрашивают).

При запуске git status с поэтапными незафиксированными файлами теперь Git предлагает использовать для деактивации файлов (вместо git reset HEAD <file>, как это было до v2.23).

В первый раз, когда у меня возникла эта проблема, я обнаружил здесь эта почта и из первого ответа понял, что мне нужно просто сделать git reset <filename>. Работало нормально.

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

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

Я нашел следующий метод (который не записывается как здесь или здесь) относительно простым. Надеюсь, это будет полезно:

Допустим, у вас есть следующая ситуация:

Folder/SubFolder1/file1.txt
Folder/SubFolder2/fig1.png
Folder/SubFolderX/fig.svg
Folder/SubFolder3/<manyfiles>
Folder/SubFolder4/<file1.py, file2.py, ..., file60.py, ...>

Вы хотите добавить все папки и файлы, но не fig1.png, и не SubFolderX, и не file60.py, и список продолжает расти ...

Сначала сделайте / создайте bash shell script и дайте ему имя. Скажем, git_add.sh:

Затем добавьте все пути ко всем папкам и файлам, которые вы хотите сохранить в git reset, перед git reset -- . Вы можете легко скопировать и вставить пути в скрипт git_add.sh по мере роста вашего списка файлов. Скрипт git_add.sh должен выглядеть так:

#!/bin/bash

git add .
git reset -- Folder/SubFolder2/fig1.png
git reset -- Folder/SubFolderX
git reset -- Folder/SubFolder4/file60.py

#!/bin/bash важен. После этого вам нужно сделать chmod -x git_add.shв командной строке, чтобы сделать скрипт исполняемым, а затем source git_add.sh, чтобы запустить его. После этого вы можете сделать git commit -m "some comment", а затем git push -u origin master, если вы уже настроили Bitbucket / Github.

Отказ от ответственности: я тестировал это только в Linux.


Если у вас есть много файлов и папок, которые вы всегда сохраняете в локальном репозитории git, но вы не хотите, чтобы git отслеживал изменения, когда вы выполняете git add ., например файлы видео и данных, вы должны научиться использовать .gitignore. Может от здесь.

Используйте git reset HEAD, чтобы отключить все, что вы поставили

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

Jonathan Leffler 19.02.2021 19:44

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

Rubaiyat Jahan Mumu 19.02.2021 20:12

Вы можете отключить / отменить с помощью команды git или git с графическим интерфейсом.

Отдельный файл

git reset File.txt 

Несколько файлов

git reset File1.txt File2.txt File3.txt

Пример - Допустим, вы по ошибке добавили Home.js, ListItem.js, Update.jsenter image description here и хотите отменить / сбросить =>

git reset src/components/home/Home.js src/components/listItem/ListItem.js src/components/update/Update.js

enter image description here

Тот же пример с использованием git GUI

git gui

открывает окно => Снимите отметку с ваших файлов из Поэтапные изменения (будут зафиксированы)enter image description here

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

Jonathan Leffler 18.09.2020 20:32

Вы можете использовать эту команду после git версии 2.23:

git restore --staged <filename>

Или вы можете использовать эту команду:

git reset HEAD <filename>

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

Jonathan Leffler 27.10.2020 08:48

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