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

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

git add myfile.txt

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

Ответы

Ответ 1

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

git reset <file>

который удалит его из текущего индекса (список "about to be commit" ) без изменения чего-либо еще.

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

git reset

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

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

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

Ответ 2

Ты хочешь:

git rm --cached <added_file_to_undo>

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

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

git reset .

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

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

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

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

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

=> Черт, я не хотел добавлять все это.
google "отменить git add"

=> найти переполнение стека - ууу
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 ничего не уничтожает (и что, если я его неправильно написал).

Ответ 3

Если вы введете:

git status

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

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

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

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

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

Ответ 4

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

Ответ 5

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

git gc --prune=now

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

Итак, что же является настоящей отменой git add?

git reset HEAD <file>?

или же

git rm --cached <file>?

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

git add нельзя отменить - безопасно, в общем.

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

Если <file> ранее не отслеживался, git add добавляет его в кеш с его текущим содержимым.
Если <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)}

Ответ 6

git rm --cached . -r

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

Ответ 7

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

git reset HEAD myfile.txt

Объясните:

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

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

Ответ 8

Run

git gui

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

Ответ 9

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

Ответ 10

Вопрос явно не задан. Причина в том, что 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

Ответ 11

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

Ответ 12

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

НО:

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

Просто,

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

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

git unadd foo.txt bar.txt

Ответ 13

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

git help rm

Ответ 14

Используйте 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)
$

Ответ 15

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

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

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

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

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

Ответ 16

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

$> git --version
git version 1.6.2.1

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

git reset HEAD .

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

Ответ 17

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

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)

Ответ 18

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

git rm --cached FILE

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

Ответ 19

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

git reset *

Ответ 20

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

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

и т.д.

Ответ 21

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

Ответ 22

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

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

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

Ответ 23

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

git reset my_file.txt

git checkout my_file.txt

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

git reset

Git Checkout.

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

Ответ 24

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

git reset HEAD filename.txt

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

git add -p

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

Ответ 25

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

git add -i

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

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

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

Ответ 26

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

git reset filename

Ответ 27

git reset filename.txt

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

Ответ 28

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

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

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

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

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

Ответ 29

В 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, чтобы отключить новые файлы.

Ответ 30

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

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