uteis Como desfazer 'git add' antes de confirmar?




revert this commit (24)

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.


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 remove ou git rm pode ser usado para isso, com o sinalizador --cached . Experimentar:

git help rm

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

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

etc


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

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.

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.


Corre

git gui

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


Uma adição à resposta aceita, se o seu arquivo adicionado por engano foi enorme, você provavelmente notará que, mesmo depois de removê-lo do índice com ' git reset ', ele ainda parece ocupar espaço no diretório .git . 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á eventualmente recuperado - embora talvez não muito em breve. Se você está ansioso, você pode executar:

git gc --prune=now

Atualização (o que segue é minha tentativa de esclarecer alguma confusão que pode surgir das respostas mais votadas):

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

git reset HEAD <file> ?

ou

git rm --cached <file> ?

Estritamente falando, e se não estou enganado: nenhum .

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

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

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

  2. Se <file> foi rastreado , git add salva o conteúdo atual (snapshot, versão) no cache. No GIT, essa ação ainda é chamada de add (não apenas atualização ), porque duas versões diferentes (snapshots) de um arquivo são consideradas como dois itens diferentes: portanto, estamos de fato adicionando um novo item ao cache, para ser eventualmente comprometido depois.

Em vista disso, a questão é um pouco ambígua:

Eu, 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 este for o caso, então está ok rodar git rm --cached <file> .

E também podemos executar o git reset HEAD <file> . Em geral, isso é preferível, porque funciona em ambos os 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 apontado na resposta) apenas um cenário no qual o git reset HEAD não funciona, mas git rm --cached faz: um novo repositório (sem commits). Mas, na verdade, esse é um caso praticamente irrelevante.

Segundo: Esteja ciente de que o git reset HEAD não pode magicamente recuperar o conteúdo do arquivo armazenado em cache, apenas o ressincroniza a partir do HEAD. Se nosso git add indevido git add uma versão anterior não confirmada, não poderemos 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 lost irrevocably "version 2"
-version 1
+version 3

É claro que 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 (case 1), e nós atualizarmos novos conteúdos via commit, git commit -a comando.

* (Edit: o acima é praticamente correto, mas ainda pode haver algumas maneiras ligeiramente hackish / convoluted para recuperar as alterações que foram encenadas, mas não comprometidas e, em seguida, substituídas - ver os comentários por Johannes Matokic e iolsmit)


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.


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 check - out altera o código nos arquivos e passa para o último estado atualizado (confirmado). reset não altera os códigos; apenas restaura o cabeçalho.


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


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


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.


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

git reset *

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

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


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

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


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:


git rm --cached . -r

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


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

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







git-stage