Como desfazer 'git add' antes de confirmar?

Por engano, adicionei arquivos ao Git usando o comando:

git add myfile.txt

Ainda não corri git commit. Existe uma maneira de desfazer isso, para que esses arquivos não sejam incluídos no commit?

Você pode desfazer git addantes de confirmar com

git reset <file>

que o removerá do índice atual (a lista "prestes a ser confirmada") sem alterar mais nada.

Você pode usar

git reset

sem qualquer nome de arquivo para desestabilizar todas as alterações devidas. Isso pode ser útil quando houver muitos arquivos a serem listados um por um em um período de tempo razoável.

Nas versões antigas do Git, os comandos acima são equivalentes git reset HEAD <file>e git reset HEAD, respectivamente, e falharão se HEADfor indefinido (porque você ainda não fez nenhum commit no seu repositório) ou ambíguo (porque você criou um ramo chamado HEAD, o que é uma coisa estúpida que você não deveria fazer). Isto foi mudado em Git 1.8.2 , embora, por isso em versões modernas de Git você pode usar os comandos acima, mesmo antes de fazer sua primeira cometer:

"git reset" (sem opções ou parâmetros) costumava errar quando você não tem nenhum commit no seu histórico, mas agora ele fornece um índice vazio (para combinar com o commit inexistente, você nem está participando).

Você quer:

git rm --cached <added_file_to_undo>

Raciocínio:

Quando eu era novo nisso, tentei pela primeira vez

git reset .

(para desfazer toda a minha adição inicial), apenas para receber esta (não tão) mensagem útil:

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

Acontece que isso ocorre porque a referência HEAD (ramificação?) Não existe até depois do primeiro commit. Ou seja, você terá o mesmo problema de iniciante que eu, se o seu fluxo de trabalho, como o meu, fosse algo como:

1. CD para o meu grande diretório novo projeto para experimentar o Git, o novo hotness
2. git init
3. git add .

4. git status

   ... muitos rolos de porcaria por ...

   => Porra, eu não queria adicionar tudo isso.

5. google "desfazer git add"

   => encontrar estouro de pilha - yay

6. git reset .

   => fatal: falha ao resolver 'HEAD' como uma referência válida.

Acontece ainda que há um bug registrado contra a imprudência disso na lista de discussão.

E que a solução correta estava lá na saída de status do Git (que, sim, encarei como 'porcaria)

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

E a solução é realmente usar git rm --cached FILE.

Observe os avisos em outros lugares aqui - git rmexclui sua cópia de trabalho local do arquivo, mas não se você usar --cached . Aqui está o resultado de git help rm:

--cached Use esta opção para desestabilizar e remover os caminhos apenas do índice. Os arquivos da árvore de trabalho, modificados ou não, serão deixados.

Eu uso

git rm --cached .

para remover tudo e começar de novo. No entanto, não funcionou, porque, embora add .seja recursivo, acaba sendo rmnecessário -rrecuperar. Suspiro.

git rm -r --cached .

Ok, agora voltei para onde comecei. Da próxima vez, vou -nfazer uma corrida a seco e ver o que será adicionado:

git add -n .

Eu fechei tudo em um lugar seguro antes de confiar git help rmem --cachednão destruir nada (e se eu escrevesse errado).

Se você digitar:

git status

O Git lhe dirá o que está sendo preparado etc., incluindo instruções sobre como desestágio:

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

Acho que o Git faz um bom trabalho em me convencer a fazer a coisa certa em situações como essa.

Nota: As versões recentes do Git (1.8.4.x) alteraram esta mensagem:

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

Para esclarecer: git addmove as alterações do diretório de trabalho atual para a área intermediária (índice).

Esse processo é chamado de preparação . Portanto, o comando mais natural para preparar as alterações (arquivos alterados) é o óbvio:

git stage

git add é apenas um alias mais fácil de digitar para git stage

Pena que não há git unstagenem git unaddcomandos. O relevante é mais difícil de adivinhar ou lembrar, mas é bastante óbvio:

git reset HEAD --

Podemos facilmente criar um alias para isso:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

E, finalmente, temos novos comandos:

git add file1
git stage file2
git unadd file2
git unstage file1

Pessoalmente, uso apelidos ainda mais curtos:

git a # For staging
git u # For unstaging

Além da resposta aceita, se o arquivo adicionado por engano for enorme, você provavelmente perceberá que, mesmo depois de removê-lo do índice com ' git reset', ele ainda parece ocupar espaço no .gitdiretório.

Isso não é nada para se preocupar; o arquivo ainda está no repositório, mas apenas como um "objeto solto". Ele não será copiado para outros repositórios (via clone, push) e o espaço será recuperado eventualmente - embora talvez não em breve. Se você estiver ansioso, você pode executar:

git gc --prune=now

Atualização (a seguir, é minha tentativa de esclarecer algumas confusões que podem surgir das respostas mais votadas):

Então, qual é o verdadeiro desfazer de git add?

git reset HEAD <file> ?

ou

git rm --cached <file>?

A rigor, e se não me engano: nenhum .

git add não pode ser desfeito - com segurança, em geral.

Vamos lembrar primeiro o que git add <file>realmente faz:

1. Se não<file> foi rastreado anteriormente , o git add adiciona ao cache , com seu conteúdo atual.

2. Se já<file> foi rastreado , git add salva o conteúdo atual (instantâneo, versão) no cache. No Git, essa ação ainda é chamada de adição (não apenas uma atualização ), porque duas versões diferentes (instantâneos) de um arquivo são consideradas como dois itens diferentes: portanto, estamos realmente adicionando um novo item ao cache, para ser eventualmente cometido mais tarde.

À luz disso, a questão é um pouco ambígua:

Por engano, adicionei arquivos usando o comando ...

O cenário do OP parece ser o primeiro (arquivo não rastreado), queremos que o "desfazer" remova o arquivo (não apenas o conteúdo atual) dos itens rastreados. Se for esse o caso, não há problema em executar git rm --cached <file>.

E também poderíamos correr git reset HEAD <file>. Geralmente, isso é preferível, porque funciona nos dois cenários: ele também desfaz quando adicionamos erroneamente uma versão de um item já rastreado.

Mas existem duas advertências.

Primeiro: existe (como indicado na resposta) apenas um cenário em que git reset HEADnão funciona, mas git rm --cachedfunciona: um novo repositório (sem confirmação). Mas, realmente, este é um caso praticamente irrelevante.

Segundo: esteja ciente de que git reset HEAD não é possível recuperar magicamente o conteúdo do arquivo em cache anteriormente, apenas o ressincroniza a partir do HEAD. Se nossos git adderros de orientação substituíram uma versão não confirmada em etapas anterior, não podemos recuperá-la. É por isso que, estritamente falando, não podemos desfazer [*].

Exemplo:

$ 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

Obviamente, isso não é muito crítico se apenas seguirmos o fluxo de trabalho preguiçoso usual de fazer 'git add' apenas para adicionar novos arquivos (caso 1) e atualizarmos novos conteúdos por meio do git commit -acomando commit,

^{* (Editar: o acima exposto está praticamente correto, mas ainda pode haver algumas maneiras levianas / complicadas de recuperar as mudanças que foram encenadas, mas não confirmadas e depois substituídas - veja os comentários de Johannes Matokic e iolsmit)}

Desfazer um arquivo que já foi adicionado é bastante fácil usando o Git. Para redefinir myfile.txt, que já foram adicionados, use:

git reset HEAD myfile.txt

Explicação:

Depois de preparar os arquivos indesejados, para desfazer, você pode fazer git reset. Headé o chefe do seu arquivo no local e o último parâmetro é o nome do seu arquivo.

Eu criei as etapas na imagem abaixo em mais detalhes para você, incluindo todas as etapas que podem ocorrer nesses casos:

git rm --cached . -r

irá "un-add" tudo que você adicionou do seu diretório atual recursivamente

Corre

git gui

e remova todos os arquivos manualmente ou selecionando todos eles e clicando no botão unstage from commit .

O Git possui comandos para todas as ações imagináveis, mas precisa de amplo conhecimento para acertar as coisas e, por isso, é contra-intuitivo na melhor das hipóteses ...

O que você fez antes:

• Alterou um arquivo e usou git add ., ou git add <file>.

O que você quer:

• Remova o arquivo do índice, mas mantenha-o com versão e com alterações não confirmadas na cópia de trabalho:

  git reset head <file>
  

• Redefina o arquivo para o último estado do HEAD, desfazendo as alterações e removendo-as do índice:

  # Think `svn revert <file>` IIRC.
  git reset HEAD <file>
  git checkout <file>
  
  # If you have a `<branch>` named like `<file>`, use:
  git checkout -- <file>

  Isso é necessário, pois git reset --hard HEADnão funcionará com arquivos únicos.

• Remova <file>do índice e controle de versão, mantendo o arquivo sem versão com alterações na cópia de trabalho:

  git rm --cached <file>
  

• Remova <file>completamente a cópia de trabalho e o controle de versão:

  git rm <file>
  

A questão não está claramente colocada. A razão é que git addtem dois significados:

1. adicionando um novo arquivo à área de preparação e desfaz com git rm --cached file.
2. adicionando um arquivo modificado à área de preparação, e desfaça com git reset HEAD file.

Em caso de dúvida, use

git reset HEAD file

Porque faz a coisa esperada nos dois casos.

Aviso: se você fizer git rm --cached fileum arquivo que foi modificado (um arquivo que existia anteriormente no repositório), o arquivo será removido git commit! Ele ainda existirá no seu sistema de arquivos, mas se alguém puxar sua confirmação, o arquivo será excluído da árvore de trabalho.

git statusdirá se o arquivo foi um novo arquivo ou foi modificado :

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

Se você está no seu commit inicial e não pode usá-lo git reset, basta declarar "Git bankruptcy", excluir a .gitpasta e começar de novo

Conforme muitas das outras respostas, você pode usar git reset

MAS:

Eu encontrei este ótimo post que realmente adiciona o comando Git (bem, um apelido) para git unadd: veja git unadd para obter detalhes ou ..

Simplesmente,

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

Agora você pode

git unadd foo.txt bar.txt

Use git add -ipara remover arquivos recém-adicionados do seu próximo commit. Exemplo:

Adicionando o arquivo que você não queria:

$ 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)
# [...]#

Entrar em add interativo para desfazer seu add (os comandos digitados no git aqui são "r" (reverter), "1" (primeira entrada na lista mostra shows de reversão), 'return' para sair do modo de reversão e "q" (Sair):

$ 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.
$

É isso aí! Aqui está sua prova, mostrando que "foo" está de volta à lista não rastreada:

$ 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 removeou git rmpode ser usado para isso, com a --cachedbandeira. Tentar:

git help rm

Aqui está uma maneira de evitar esse problema irritante quando você inicia um novo projeto:

• Crie o diretório principal para o seu novo projeto.
• Corra git init.
• Agora crie um arquivo .gitignore (mesmo que esteja vazio).
• Confirme seu arquivo .gitignore.

O Git torna muito difícil fazer isso git resetse você não tiver nenhum commit. Se você criar um pequeno commit inicial apenas para ter um, depois disso, você pode git add -Ae git resetquantas vezes quiser para obter tudo certo.

Outra vantagem desse método é que, se você enfrentar problemas de final de linha posteriormente e precisar atualizar todos os seus arquivos, é fácil:

• Confira essa confirmação inicial. Isso removerá todos os seus arquivos.
• Em seguida, verifique seu commit mais recente novamente. Isso recuperará novas cópias de seus arquivos, usando as configurações atuais de final de linha.

Talvez o Git tenha evoluído desde que você postou sua pergunta.

$> git --version
git version 1.6.2.1

Agora você pode tentar:

git reset HEAD .

Deve ser o que você está procurando.

Observe que, se você não especificar uma revisão, precisará incluir um separador. Exemplo do meu console:

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 versão 1.7.5.4)

Para remover novos arquivos da área de preparação (e apenas no caso de um novo arquivo), conforme sugerido acima:

git rm --cached FILE

Use rm --cached apenas para novos arquivos adicionados acidentalmente.

Para redefinir todos os arquivos em uma pasta específica (e suas subpastas), você pode usar o seguinte comando:

git reset *

Use o *comando para manipular vários arquivos por vez:

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

etc.

Basta digitar git resetque irá reverter e é como se você nunca tivesse digitado git add .desde o seu último commit. Verifique se você se comprometeu antes.

Suponha que eu crie um novo arquivo newFile.txt:

Suponha que eu adicione o arquivo acidentalmente git add newFile.txt:

Agora eu quero desfazer este complemento, antes de confirmar git reset newFile.txt:

Para um arquivo específico:

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

Para todos os arquivos adicionados:

• git reset.
• git checkout.

Nota: o checkout altera o código nos arquivos e passa para o último estado atualizado (confirmado). reset não altera os códigos; apenas redefine o cabeçalho.

Este comando irá descompactar suas alterações:

git reset HEAD filename.txt

Você também pode usar

git add -p 

para adicionar partes de arquivos.

Há também o modo interativo:

git add -i

Escolha a opção 3 para adicionar arquivos. No meu caso, geralmente quero adicionar mais de um arquivo e, no modo interativo, você pode usar números como este para adicionar arquivos. Isso levará tudo, exceto 4: 1, 2, 3 e 5

Para escolher uma sequência, basta digitar 1-5 para obter todos de 1 a 5.

Arquivos de teste do Git

Para desfazer git add, use:

git reset filename

git reset filename.txt

Removerá um arquivo chamado filename.txt do índice atual, a área "prestes a ser confirmada", sem alterar mais nada.

git add myfile.txt # Isso adicionará seu arquivo à lista a ser confirmada

Bem oposto a este comando,

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

então, você estará no estado anterior. O especificado estará novamente na lista não rastreada (estado anterior).

Ele redefinirá sua cabeça com o arquivo especificado. então, se sua cabeça não tiver, significa que ela será redefinida.

No Sourcetree, você pode fazer isso facilmente através da GUI. Você pode verificar qual comando o Sourcetree usa para desfazer um arquivo.

Criei um novo arquivo e o adicionei ao Git. Em seguida, desfiz o estágio usando a GUI do Sourcetree. Este é o resultado:

Desagrupando arquivos [08/12/15 10:43] git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = sourcetree reset -q - caminho / para / file / filename.java

O Sourcetree usa resetpara desfazer novos arquivos.

git reset filename.txt  

Removerá um arquivo chamado filename.txt do índice atual, a área "prestes a ser confirmada", sem alterar mais nada.