Como desfazer 'git add' antes de confirmar?


14 Answers

Você quer:

git rm --cached <added_file_to_undo>

Raciocínio:

Quando eu era novo nisso, eu tentei pela primeira vez

git reset .

(para desfazer todo o meu add inicial), apenas para obter essa (não tão) mensagem útil:

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

Acontece que isso acontece porque a ref de HEAD (branch?) 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, for algo como:

  1. cd para o meu novo diretório de projetos para testar 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 "CABEÇA" como referência válida

Acontece que há um bug registrado contra a falta de utilidade disso na lista de discussão.

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

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

E a solução, na verdade, é usar git rm --cached FILE .

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

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

Eu continuo a usar

git rm --cached .

para remover tudo e começar de novo. Não funcionou, porque enquanto add . é recursivo, verifica-se a necessidade de -r recurse. Suspiro.

git rm -r --cached .

Ok, agora estou de volta para onde comecei. Da próxima vez eu vou usar -n para fazer uma corrida seca e ver o que será adicionado:

git add -n .

Fechei tudo em um lugar seguro antes de confiar no git help rm sobre o --cached não destruindo nada (e se eu --cached errado).

Question

Eu, por engano, adicionei arquivos ao git usando o comando:

git add myfile.txt

Eu ainda não git commit . Existe uma maneira de desfazer isso, então esses arquivos não serão incluídos no commit?

Existem 48 respostas até agora (algumas excluídas). Por favor, não adicione um novo, a menos que você tenha alguma informação nova.




git add myfile.txt # isso adicionará seu arquivo na lista de commits

Muito oposto a este comando é,

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

então, você estará em estado anterior. especificado será novamente na lista untracked (estado anterior).

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




Suponha que eu crie um novo arquivo newFile.txt .

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

Agora eu quero desfazer esse add, antes de commit, git reset newFile.txt




Para esclarecer: git add move as alterações do diretório de trabalho atual para a área de preparação (índice).

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

git stage

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

Pena que não há git unstage nem git unadd commands. O mais 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 eu uso aliases ainda mais curtos:

git a #for staging
git u #for unstaging



De acordo com muitas das outras respostas, você pode usar o git reset

MAS:

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

Simplesmente,

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

Agora você pode

git unadd foo.txt bar.txt



use o comando * para manipular vários arquivos por vez

git reset *

etc




No SourceTree você pode fazer isso facilmente através do gui. Você pode verificar qual comando o sourcetree usa para desassociar um arquivo.

Eu criei um novo arquivo e o adicionei ao git. Então eu tirei a nota usando o guia SourceTree. Este é o resultado:

Desvendar arquivos [08/12/15 10:43]
git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = restauração de sourcetree -q - path / to / file / filename.java

O SourceTree usa resetpara desassociar arquivos novos.




Estou surpreso que ninguém mencione o modo interativo:

git add -i

escolha a opção 3 para adicionar arquivos. No meu caso, muitas vezes eu quero adicionar mais de um arquivo, com o modo interativo, você pode usar números como este para adicionar arquivos. Isso levará todos menos 4: 1,2,3,5

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

Arquivos de teste do Git




Use git add -i para 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)
# [...]#

Indo para o add interativo para desfazer o seu add (os comandos digitados no git aqui são "r" (revert), "1" (a primeira entrada na lista reverte shows), 'return' para sair do modo revert 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 na lista não acompanhada:

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



O Git tem comandos para cada ação imaginável, mas precisa de extenso conhecimento para acertar as coisas e, por isso, é contra-intuitivo na melhor das hipóteses ...

O que você fez antes:

  • Mudou um arquivo e usou o git add . ou git add <file> .

O que você quer:

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

    git reset head <file>
    
  • Redefina o arquivo para o último estado de 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 desde que o git reset --hard HEAD não funcionará com arquivos únicos.

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

    git rm --cached <file>
    
  • Remova o <file> da cópia de trabalho e do versionamento completamente:

    git rm <file>
    



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

git rm --cached FILE

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




Desfazer um arquivo que já adicionado é bastante fácil usando o git , para resetar o arquivo myfile.txt que já adicionei, use:

git reset HEAD myfile.txt

Explicar:

Depois de colocar o (s) arquivo (s) indesejado (s), para desfazer, você pode fazer o git reset , Head é o head do seu arquivo em local e o último parâmetro é o nome do seu arquivo.

Eu crio as etapas na imagem abaixo com mais detalhes para você, incluindo todas as etapas que podem acontecer nesses casos:




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 .

Isso deve ser o que você está procurando.




Este comando irá unstash suas alterações:

git reset HEAD filename.txt

Você também pode usar

git add -p 

para adicionar partes de arquivos.




git rm --cached . -r

irá "un-adicionar" tudo o que você adicionou a partir do seu diretório atual de forma recursiva




Related