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

Question

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

git add myfile.txt

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

Answer 1

Вы можете отменить git add перед совершением с

git reset <file>

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

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

git reset

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

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

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

Answer 2

Ты хочешь:

git rm --cached <added_file_to_undo>

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

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

git reset .

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

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

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

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

4. git status

   ...мимо прокручивается куча дерьма ...

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

5. google "отменить добавление git"

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

6. git reset .

   => смертельный исход:Не удалось разрешить 'HEAD' как допустимую ссылку.

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

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

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

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

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

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

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

git rm --cached .

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

git rm -r --cached .

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

git add -n .

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

Answer 3

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

git status

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

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

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

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

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

Answer 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

Answer 5

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

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

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

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

---

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

Answer 6

git rm --cached . -r

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

Answer 7

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

git reset HEAD myfile.txt

Объясните:

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

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

Answer 8

Беги

git gui

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

Answer 9

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

Answer 10

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

Answer 11

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

Answer 12

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

НО:

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

Просто,

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

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

git unadd foo.txt bar.txt

Answer 13

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

git help rm

Answer 14

Использование 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" (revert), "1" (отображается первая запись в списке revert), "return" для выхода из режима revert и "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)
$

Answer 15

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

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

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

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

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

Answer 16

Возможно, Git эволюционировал с тех пор, как вы опубликовали свой вопрос.

$> git --version
git version 1.6.2.1

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

git reset HEAD .

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

Answer 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)

Answer 18

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

git rm --cached FILE

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

Answer 19

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

git reset *

Answer 20

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

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

и т.д.

Answer 21

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

Answer 22

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

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

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

Answer 23

Для определенного файла:

• сброс git my_file.txt
• проверка git my_file.txt

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

• сброс git .
• проверка git .

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

Answer 24

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

git reset HEAD filename.txt

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

git add -p 

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

Answer 25

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

git add -i

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

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

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

Answer 26

Чтобы отменить добавление git, используйте

git reset filename

Answer 27

git reset filename.txt

Удалит файл с именем filename.txt из текущего индекса, область "готовится к фиксации", без изменения чего-либо еще.

Answer 28

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

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

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

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

это сбросит ваш head с помощью этого указанного файла.итак, если в вашей голове нет этого средства, она просто сбросит его

Answer 29

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

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

Нестагнирующие файлы [12.08.15 10:43]
git -c diff.mnemonicprefix=false -ядро c.quotepath=false -учетные данные c.helper= сброс исходного дерева -q -- path/to/file/filename.java

Использование SourceTree reset чтобы отменить форматирование новых файлов.

Answer 30

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

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