Как отменить 'git add' перед коммитом?

Ты хочешь:

git rm --cached <added_file_to_undo>

Обоснование:

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

git reset .

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

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

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

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

4. git status

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

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

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

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

6. git reset.

   => fatal: Не удалось разрешить 'HEAD' в качестве действительного ссылки.

Кроме того, выясняется, что в списке рассылки зарегистрировано сообщение об ошибке.

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

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

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

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

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

Я приступаю к использованию

git rm --cached .

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

git rm -r --cached .

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

git add -n .

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

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

git status

git расскажет вам, что устраивается и т.д., включая инструкции о том, как отключиться:

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

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

Примечание. Последние версии git (1.8.4.x) изменили это сообщение:

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

Чтобы уточнить: 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

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

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

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

Сценарий 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 lost irrevocably "version 2"
-version 1
+version 3

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

^{* (Редактировать: вышеупомянутое практически правильно, но все же могут быть несколько хакерские/запутанные способы восстановления изменений, которые были поставлены, но не зафиксированы, а затем перезаписаны - см. Комментарии Йоханнеса Матокича и iolsmit)}

git rm --cached . -r

будет "un- добавить" все, что вы добавили из текущего каталога рекурсивно

Run

git gui

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

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

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

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

Что вы хотите:

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

  git reset head <file>
  

• Reset файл с последним состоянием из 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> из индекса и версии, сохраняя файл с версией un- с изменениями в рабочей копии:

  git rm --cached <file>
  

• Удалите <file> из рабочей копии и версии:

  git rm <file>
  

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

git reset HEAD myfile.txt

Объясните:

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

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

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

• добавление нового файла в промежуточную область, затем отмените с помощью git rm --cached file.
• добавление файла измененного в промежуточную область, затем отмените с помощью 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

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

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

НО:

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

Просто,

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

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

git unadd foo.txt bar.txt

git remove или git rm можно использовать для этого с флагом --cached. Попробуйте:

git help rm

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

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

$ 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" (первая запись в списке вернется), "возврат" к выходу из режима возврата, и "q" (quit):

$ 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 init.
• Теперь создайте файл .gitignore (даже если он пуст).
• Зафиксируйте файл .gitignore.

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

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

• Отметьте, что начальная фиксация. Это приведет к удалению всех ваших файлов.
• Затем снова проверьте свою последнюю фиксацию. Это приведет к восстановлению свежих копий ваших файлов, используя текущие настройки окончания line-.

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

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 развился с тех пор, как вы разместили свой вопрос.

$> git --version
git version 1.6.2.1

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

git reset HEAD .

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

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

git rm --cached FILE

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

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

git reset *

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

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

и т.д.

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

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

Предположим, что я случайно добавляю файл, git add newFile.txt

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

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

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

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

• git reset
• Git Checkout.

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

Для отмены git add используйте

git reset filename

Я удивлен, что никто не упоминает интерактивный режим:

git add -i

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

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

Git промежуточных файлов

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

git reset HEAD filename.txt

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

git add -p 

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

git add myfile.txt # это добавит ваш файл в список, посвященный фиксации

В отличие от этой команды,

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

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

он будет reset головой с указанным файлом. поэтому, если ваша голова не имеет этого, это просто reset it

git reset filename.txt

Удалит файл с именем filename.txt из текущего индекса, область "about to be commit", не изменяя ничего.

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

Я создал новый файл и добавил его в git. Затем я отключил его, используя guit SourceTree. Это результат:

Unstaging files [08/12/15 10:43]
git -c diff. mnemonicprefix=false -c core. quotepath=false -c учетные данные. helper=sourcetree reset -q - путь /to/file/filename.java

SourceTree использует reset, чтобы отключить новые файлы.

git reset filename.txt  

Удалит файл с именем filename.txt из текущего индекса, область "about to be commit", не изменяя ничего.

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

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

Команда git reset помогает вам изменить либо область подготовки, либо область подготовки и рабочее дерево. Способность Git создавать коммиты в точности так, как вы хотите, означает, что вам иногда нужно отменить изменения, внесенные вами с помощью git add. Вы можете сделать это, вызвав git reset HEAD. У вас есть два варианта, чтобы полностью избавиться от изменений. git checkout HEAD - это быстрый способ отменить изменения в вашей области подготовки и рабочем дереве. Будьте осторожны с этой командой, потому что она удаляет все изменения в вашем рабочем дереве. Git не знает об этих изменениях, так как они никогда не совершались. Невозможно вернуть эти изменения после запуска этой команды. Другая команда в вашем распоряжении - это git reset --hard. Это в равной степени разрушительно для вашего рабочего дерева - любые незафиксированные изменения или поэтапные изменения теряются после его запуска. Запуск git reset -hard HEAD делает то же самое, что и git checkout HEAD. он просто не требует файла или пути для работы. Вы можете использовать --soft с git reset. Он сбрасывает репозиторий в указанный вами коммит и выполняет все эти изменения. На любые изменения, которые вы уже подготовили, это не влияет, равно как и изменения в вашем рабочем дереве. Наконец, вы можете использовать --mixed для сброса рабочего дерева без внесения каких-либо изменений. Это также не выполняет этапные изменения.

git stash && git stash pop

Будет стирать сцену.

Команда git reset --hard HEAD должна работать. Следует отметить, что вам нужно изменить каталог (cd) обратно в обычный рабочий каталог. В противном случае, если вы запустите команду из каталога, вы ошибочно сделали git add ..... вы не сможете вернуться и вместо этого получить ошибки, упомянутые в других сообщениях, в отношении "неизвестной версии или пути не в рабочем дереве".