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

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

git help rm

Вы можете отменить 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 status

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

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

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

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

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

Ты хочешь:

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 rm --cached FILE

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

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

$> git --version
git version 1.6.2.1

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

git reset HEAD .

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

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

git rm --cached . -r

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

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

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

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

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

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

Запустить

git gui

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

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

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

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

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 *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

и т.п.

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

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

git add -i

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

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

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

В 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 для деактивации новых файлов.

git reset filename.txt

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

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

git reset filename

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

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

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

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

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

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 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 my_file.txt
• git checkout my_file.txt

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

• git reset .
• git checkout .

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

Команда 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, чтобы отключить все, что вы поставили

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

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

git reset File.txt 

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

git reset File1.txt File2.txt File3.txt

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

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

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

git gui

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

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

git restore --staged <filename>

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

git reset HEAD <filename>