version-control alteração - Como desfazer 'git add' antes de confirmar?




ultimo drop (25)

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.


Answers

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

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.


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

git reset *

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 [12/08/15 10:43]
git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = fonte_de_redefinição -q - caminho / para / arquivo / nomedoarquivo.java

O SourceTree usa resetpara desassociar arquivos novos.


Observe que, se você não conseguir 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>

(versão 1.7.5.4 do git)


Para desfazer git add use

git reset filename


git add myfile.txt # isso adicionará seu arquivo na lista de confirmação

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


Se você está no seu commit inicial e não pode usar o git reset, apenas declare "Git bankruptcy" e apague a pasta .git e comece novamente.


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

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

etc


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 rm precisa -r para 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).


Corre

git gui

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


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.


A questão não é claramente colocada. A razão é que o git add tem dois significados:

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

em caso de dúvida, use

git reset HEAD file

Porque faz o esperado em ambos os casos.

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

git status informará se o arquivo era novo ou 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

Apenas digite git reset ele irá reverter e é como se você nunca git add . digitado git add . desde o seu último commit. Certifique-se de ter cometido antes.


git reset filename.txt

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


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

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.
  • Execute o git init .
  • Agora crie um arquivo .gitignore (mesmo se estiver vazio).
  • Confirme seu arquivo .gitignore.

O Git torna muito difícil fazer o git reset se você não tem nenhum commit. Se você criar um pequeno commit inicial apenas por uma questão de ter um, depois disso você pode git add -A e git reset quantas vezes você quiser, a fim de obter tudo certo.

Outra vantagem desse método é que, se você se deparar com problemas de finalização de linha mais tarde e precisar atualizar todos os arquivos, será fácil:

  • Confira esse commit inicial. Isso removerá todos os seus arquivos.
  • Então confira seu commit mais recente novamente. Isso recuperará cópias novas de seus arquivos, usando suas 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 .

Isso deve ser o que você está procurando.


Você pode desfazer git add antes de commitar com

git reset <file>

que irá removê-lo do índice atual (a lista "prestes a ser confirmada") sem alterar nada.

Você pode usar

git reset

sem qualquer nome de arquivo para desassociar 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.

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

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


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

git rm --cached . -r

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


Se você digitar:

git status

O git lhe dirá o que é encenado, etc, incluindo instruções sobre como desassociar:

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

Eu acho que o git faz um bom trabalho me cutucando para fazer a coisa certa em situações como essa.

Nota: Versões git recentes (1.8.4.x) mudaram esta mensagem:

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

git remove ou git rm pode ser usado para isso, com o sinalizador --cached . Experimentar:

git help rm

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 restaurar todos os arquivos excluídos em uma pasta, digite o seguinte comando.

git ls-files -d | xargs git checkout --






git version-control git-commit git-stage