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

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

git add myfile.txt

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

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

git reset <file>

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

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

git reset

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

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

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

Ты хочешь:

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пробный прогон и посмотреть, что будет добавлено:

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

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

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

Похоже, что сценарий 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 -acommand.

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

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

git reset HEAD myfile.txt

Объяснение:

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

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

git rm --cached . -r

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

Запустить

git gui

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

У 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 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 reset, просто объявите «Git банкротство», удалите .gitпапку и начните сначала.

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

НО:

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

Просто,

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

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

git unadd foo.txt bar.txt

использование 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» (первая запись в списке показывает возврат), «возврат», чтобы выйти из режима возврата, и «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 removeили git rmможет быть использован для этого с --cachedфлагом. Пытаться:

git help rm

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

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

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

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

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

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

$> git --version
git version 1.6.2.1

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

git reset HEAD .

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

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

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

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

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

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 reset HEAD filename.txt

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

git add -p 

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

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

git add -i

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

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

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

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

git reset filename

git reset filename.txt

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

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

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

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

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

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

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

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

Unstaging файлы [12/12/15 10:43] git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = сброс исходного файла -q - путь / к / файлу / имени файла.java

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

git reset filename.txt  

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