git - uteis - revert this commit




Como desfazer 'git add' antes de confirmar? (20)

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.


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.


Corre

git gui

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


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

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

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.


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)

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.


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

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


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

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

etc


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


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:


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.


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


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.


git reset filename.txt  

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





git-stage