Como desfazer 'git add' antes de confirmar?

8964

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?

paxos1977
fonte
22
Começando com Git v1.8.4, todas as respostas abaixo que o uso HEADou headagora pode usar @no lugar de HEADvez. Veja esta resposta (última seção) para saber por que você pode fazer isso.
3
Eu fiz um pouco de verão que mostra todas as maneiras de unstage um arquivo: stackoverflow.com/questions/6919121/...
Daniel Alder
5
Por que não fazer check-out no git?
Erik Reppen
13
O @ErikReppen git checkoutnão remove as alterações faseadas do índice de confirmação. Ele apenas reverte as alterações não organizadas para a última revisão confirmada - que, a propósito, também não é o que eu quero, quero essas alterações, apenas as desejo em uma consolidação posterior.
precisa saber é o seguinte
4
Se você usa o Eclipse, é tão simples como desmarcando os arquivos no cometer caixa de diálogo
Hamzahfrq

Respostas:

10372

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

genehack
fonte
92
Obviamente, isso não é um desfazer verdadeiro, porque se o erro git addsubstituir uma versão faseada anterior, não podemos recuperá-la. Tentei esclarecer isso na minha resposta abaixo.
Leonbloy
7
git reset HEAD *.extOnde extestão os arquivos da extensão especificada que você deseja remover. Para mim, foi *.bmpe*.zip
boulder_ruby
18
@ Jonny, o índice (também conhecido como área de preparação) contém todos os arquivos, não apenas os arquivos alterados. Ele "inicia a vida" (quando você faz check-out de um commit ou clona um repo) como uma cópia de todos os arquivos no commit apontados pelo HEAD. Portanto, se você remover um arquivo do index ( git rm --cached), significa que você está se preparando para fazer uma confirmação que exclui esse arquivo. git reset HEAD <filename>por outro lado, copiará o arquivo de HEAD para o índice, para que o próximo commit não mostre as alterações feitas nesse arquivo.
Curinga
11
Acabei de descobrir que existe um git reset -pigual git add -p. Isso é incrível!
17746 donquixote
10
Na verdade, você pode recuperar as alterações substituídas anteriormente preparadas, mas não confirmadas, mas não de maneira amigável e não 100% segura (pelo menos nenhuma que eu encontrei): vá para .git / objects, pesquise arquivos criados no momento em git addque deseja recuperar ( 61/3AF3...- > identificação do objeto 613AF3...), então git cat-file -p <object-id>(pode valer a pena para recuperar várias horas de trabalho, mas também uma lição para cometer mais vezes ...)
Peter Schneider
2151

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

Ruibarbo
fonte
15
Hah. Eu segui esse mesmo processo. Exceto que desisti e disse rm -rf .git, git initporque não confiava git rm --cachedem manter minha cópia de trabalho. Diz um pouco sobre como o git ainda é excessivamente complexo em alguns lugares. git unstagedeve ser apenas um comando padrão de estoque, não me importo se posso adicioná-lo como um alias.
Adrian Macneil
5
Para mim, o git dizgit reset HEAD <File>...
drahnr 12/12/12
16
git rm --cached <file> é na verdade a resposta correta, se for a importação inicial de <file> para o repositório. Se você está tentando desestabilizar uma alteração no arquivo, git reset é a resposta correta. As pessoas que dizem que esta resposta está errada estão pensando em uma pergunta diferente.
Barry Kelly
14
Na verdade, isso funcionará, mas apenas na primeira confirmação, onde o arquivo não existia antes ou onde o git addcomando adicionou novos arquivos, mas não altera os arquivos existentes.
precisa saber é o seguinte
4
apenas mostra como o git não intuitivo e complicado é. em vez de ter comandos "desfazer" paralelos, você precisa descobrir como desfazê-los. Como tentar liberar sua perna na areia rápida e, em seguida, prender o braço e prender o outro braço ... todos os comandos devem ser feitos através da GUI, com itens de menus suspensos para as opções ... Pense em toda a interface do usuário, ganhos de produtividade que tivemos, mas temos essa bagunça de uma interface de linha de comando retro. Não é como se os programas da GUI do git tornassem isso mais intuitivo.
Ahnbizcad
532

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)
Paul Beckingham
fonte
19
A mensagem será diferente dependendo se o addarquivo ed já estava sendo rastreado (a addúnica salva foi uma nova versão no cache - aqui será exibida sua mensagem). Em outros lugares, se o arquivo não foi previamente encenado, ele irá mostraruse "git rm --cached <file>..." to unstage
leonbloy
Ótimo! O git reset HEAD <file>um é o único que vai funcionar no caso de você querer unstage um arquivo de exclusão
skerit
2
Minha versão 2.14.3 do git diz git reset HEADpara o palco.
SilverWolf - Restabelece Monica
246

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
leva
fonte
3
"movimentos"? Isso indicaria que saiu do diretório de trabalho. Esse não é o caso.
Thomas Weller
4
Por que isso é óbvio?
Lenar Hoyt 23/06
Na verdade, git stageé o alias para git add, que é o comando histórico, tanto no Git quanto em outro SCM. Foi adicionado em dezembro de 2008 com o commit 11920d28da no "repositório git do git", se posso dizer.
Obsidian
1
Isso pode não estar relacionado, mas achei que validar o arquivo antes mesmo de ser uma ideia útil, algo como nome do arquivo de comando check && git add filename, substituí o git por um g mais curto na minha máquina e, até agora, funcionou ok para mim: github.com/dataf3l/g , não sei se isso será útil para alguém, mas vou colocá-lo aqui na esperança de economizar o tempo de algumas pessoas.
Felipe Valdes
167

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

leonbloy
fonte
4
A rigor, existe uma maneira de recuperar um arquivo já preparado que foi substituído pelo git add. Como você mencionou, o git add cria um objeto git para esse arquivo que se tornará um objeto solto, não apenas ao remover o arquivo completamente, mas também ao ser substituído pelo novo conteúdo. Mas não há comando para recuperá-lo automaticamente. Em vez disso, o arquivo deve ser identificado e extraído manualmente ou com ferramentas escritas apenas para este caso (a libgit2 permitirá isso). Mas isso só será útil se o arquivo for muito importante e grande e não puder ser reconstruído editando a versão anterior.
Johannes Matokic
2
Para me corrigir: Uma vez que o arquivo de objeto solto seja encontrado (use metadados como data / hora da criação) git cat-filepoderá ser usado para recuperar seu conteúdo.
Johannes Matokic
2
Outra maneira de recuperar as alterações preparadas, mas não confirmadas e substituídas por, por exemplo, outra git addé a via git fsck --unreachableque listará todos os objetos inacessíveis, que você poderá inspecionar git show SHA-1_IDou git fsck --lost-foundque irá> Escrever objetos pendentes em .git/lost-found/commit/ou .git/lost-found/other/, dependendo do tipo. Veja tambémgit fsck --help
iolsmit
110

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:

arquivo git reset HEAD

Alireza
fonte
Imagem: "O comando adiciona ...""O comando adiciona ..." ( presente no tempo simples, terceira pessoa )
Peter Mortensen
Image: queroquiser (não há necessidade de usar gíria aqui)
Peter Mortensen
92
git rm --cached . -r

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

Braitsch
fonte
3
Eu não estava procurando desapertar tudo, apenas UM arquivo específico.
paxos1977 9/12/09
3
Também é útil se você não tiver nenhum commit anterior. Na ausência de confirmação anterior, git reset HEAD <file>diriafatal: Failed to resolve 'HEAD' as a valid ref.
Priya Ranjan Singh
6
Não, isso adiciona uma exclusão de tudo no seu diretório atual. Muito diferente de apenas mudanças não estáveis.
Mark Amery
88

Corre

git gui

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

Khaja Minhajuddin
fonte
1
Sim eu entendo isso. Eu só queria implicitamente sugerem que seu indicam que, em sua resposta como "Você pode usar git-gui...." :)
Alexander Suraphel
1
Ele diz: "git-gui: comando não encontrado". Não tenho certeza se isso funciona.
Parinda Rajapaksha
Uau, é muito simples fazer linhas de comando que você não entendeu. Definitivamente, isso é recomendado para iniciantes como eu. Obrigado por escrever isso!
precisa saber é o seguinte
Obrigado. Não queria arriscar, então tinha que usar a GUI.
Sagar Khatri
83

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>
    
sjas
fonte
1
Não consigo entender a diferença de 'git reset head <file>' e 'git rm --cached <file>. Você poderia explicar isso?
Jswang
6
Os arquivos @jeswang são 'conhecidos' pelo git (alterações estão sendo rastreadas.) ou não são 'versionados'. reset headdesfaz suas alterações atuais, mas o arquivo ainda está sendo monitorado pelo git. rm --cachedremove o arquivo do controle de versão, para que o git não o verifique mais em busca de alterações (e também remove as alterações atuais eventualmente indexadas, informadas ao git pelo anterior add), mas o arquivo alterado será mantido na sua cópia de trabalho, que está na sua pasta de arquivos no disco rígido.
sjas
3
A diferença é git reset HEAD <file>temporária - o comando será aplicado apenas ao próximo commit, mas git rm --cached <file>será instável até que seja adicionado novamente git add <file>. Além disso, git rm --cached <file>significa que se você enviar essa ramificação para o controle remoto, qualquer pessoa que puxe a ramificação receberá o arquivo REALMENTE excluído de sua pasta.
precisa saber é o seguinte
80

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
Michael_Scharf
fonte
7
+1. Um número extraordinário de respostas e votos altamente votados nesta página são completamente errados sobre o comportamento de git rm --cached somefile. Espero que esta resposta suba a página para uma posição de destaque, onde possa proteger os novatos de serem enganados por todas as falsas alegações.
Mark Amery
uma das melhores respostas aqui, infelizmente, é bastante baixo na lista
Creos
64

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

Ana Betts
fonte
5
Uma dica é copiar o arquivo .git / config, se você adicionou origem remota, antes de excluir a pasta.
Tiago
4
O comentário do @ChrisJohnsen está no local. Às vezes, você quer confirmar todos os arquivos, exceto um: git add -A && git rm --cached EXCLUDEFILE && git commit -m 'awesome commit' (Isto também funciona quando não há commits anteriores, re Failed to resolve 'HEAD'problema)
57

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
electblake
fonte
45

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)
$
Alex North-Keys
fonte
42

git removeou git rmpode ser usado para isso, com a --cachedbandeira. Tentar:

git help rm
gnud
fonte
9
Isso não vai remover o arquivo completamente?
Willa
8
git rm --cached ...irá remover arquivos de um repositório git. Eles ainda existirão no seu computador, mas isso é MUITO diferente das alterações desatualizadas em um arquivo. Para quem se deparar com isso, não é uma resposta válida para a pergunta.
Addison
38

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.
Ryan Lundy
fonte
1
Confirmado! Tentei redefinir o git após um add do git. e o git estava reclamando da HEAD corrompida. Seguindo seu conselho, eu poderia git add & back de reset e para trás sem problemas :)
Kounavi
1
A segunda parte funciona, mas é um pouco desajeitada. Como as terminações de linha são manipuladas depende do autocrlfvalor ... Isso não funcionará em todos os projetos, dependendo das configurações.
S28
1
Essa resposta era razoável no momento em que foi postada, mas agora está obsoleta; git reset somefilee git resetambos trabalham antes de fazer o primeiro commit, agora. Este tem sido o caso desde que vários Git são lançados de volta.
Mark Amery
@ MarkAmery, você pode estar certo (seria legal se você postasse uma fonte para sua afirmação), mas ainda há valor em iniciar seu repo com um commit limpo ou dois.
Ryan Lundy
34

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.

Kokotte23
fonte
2
Claro, mas você tem a pergunta seguinte sobre como adicionar um dos dois (ou mais) arquivos adicionados. O manual "git reset" menciona que "git reset <paths>" é o oposto de "git add <paths>", no entanto.
Alex-Chaves-do-norte
34

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)

powlo
fonte
2
Eu tentei git reset <path>e funciona muito bem sem um separador. Também estou usando o git 1.9.0. Talvez não funcione em versões mais antigas?
31

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.

Correu
fonte
4
Lembre-se de que --cachedé uma parte realmente importante aqui.
takeshin
1
-1; não, isso não desfaz o arquivo, ele apaga uma exclusão do arquivo (sem realmente excluí-lo da sua árvore de trabalho).
Mark Amery
25

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

git reset *
Zorayr
fonte
4
Na verdade, isso não redefine todos os arquivos porque * usa a expansão do shell e ignora os arquivos de ponto (e os diretórios de ponto).
Luc
Você pode correr git statuspara ver qualquer coisa restante e redefini-lo manualmente, ou seja git reset file.
Zorayr
25

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

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

etc.

boulder_ruby
fonte
3
Lembre-se de que * normalmente não inclui arquivos de ponto ou 'diretórios de ponto', a menos que você especifique explicitamente .*ou.*.prj
Luc
23

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.

Donovan
fonte
Por acaso, houve um último commit ... mas eu estava perguntando especificamente sobre como remover um único arquivo do commit, nem todos os arquivos do commit.
paxos1977
20

Suponha que eu crie um novo arquivo newFile.txt:

Digite a descrição da imagem aqui

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

Digite a descrição da imagem aqui

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

Digite a descrição da imagem aqui

Vidura Mudalige
fonte
Suponha que eu esteja na 1ª foto, significando que eu nem fiz "git.add". Além disso, não quero de todo essa mudança. Quero dizer, quando eu faço o status git, ele não deve mostrar nenhum arquivo vermelho. Quero dizer, deve estar sincronizado como se não houvesse um único arquivo alterado desde o último push do git. como conseguir isso.
Inquebrável
Então, suponha que você esteja apenas no primeiro passo. E você quer se livrar de todas as alterações feitas que estão fazendo o "newFile.txt" ficar vermelho.
Inquebrável
Quando eu faço o status git. Eu não deveria ver nenhuma mudança. Todos os arquivos vermelhos devem ser revertidos.
Inquebrável
Olá, acho que sua pergunta é como remover arquivos não rastreados da árvore atual. Para isso, você pode usar "git clean -f -d". Isso removerá diretórios não rastreados também.
Vidura Mudalige 26/03
Se você não deseja excluir os arquivos não rastreados, ignore o sinalizador "-f".
Vidura Mudalige 26/03/17
19

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.

Hasib Kamal
fonte
3
Por favor, explique a diferença entre git reset <file>e git checkout <file>.
Trent
1
reset não alterar o arquivo, basta colocá-lo longe do palco (= índice, onde foi colocada pelo add git)
franc
checkout altere os códigos no arquivo e vá para o último estado atualizado. reset não altera os códigos, apenas redefine o cabeçalho. Como exemplo, redefina o uso para arquivos adicionados ou confirmados, redefinindo antes do envio e check-out, para voltar ao último estágio atualizado / confirmado antes do git add.
Hasib Kamal
1
reset = remove o arquivo do palco, mas as alterações ainda estarão lá. check-out = recebe o arquivo atualizado a partir do repositório e substitui o arquivo atual
Imam Bux
14

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.

wallerjake
fonte
14

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

Jonathan
fonte
"Estou surpreso que ninguém mencione o modo interativo" - eles fizeram: stackoverflow.com/a/10209776/1709587
Mark Amery
14

Para desfazer git add, use:

git reset filename
Anirudh Sood
fonte
10
git reset filename.txt

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

Rahul Sinha
fonte
10

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.

Mohideen bin Mohammed
fonte
9

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.

miva2
fonte
Sim, a mesma técnica pode ser usada com o TortoiseGit , obtendo os comandos Git para os casos de uso comuns.
Peter Mortensen
8
git reset filename.txt  

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

Joseph Mathew
fonte
git reset [nome do arquivo] ex: git reset src / main / java / com / dao / ImportCsvDataDaoImpl.java
Rohit Chaurasiya