Como descarto alterações não estáveis ​​no Git?

Como descarto alterações na minha cópia de trabalho que não estão no índice?

Outra maneira mais rápida é:

git stash save --keep-index --include-untracked

Você não precisa incluir --include-untrackedse não quiser ser completo.

Depois disso, você pode soltar esse esconderijo com um git stash dropcomando, se quiser.

Para todos os arquivos não faseados no diretório de trabalho atual, use:

git checkout -- .

Para um arquivo específico, use:

git checkout -- path/to/file/to/revert

--aqui para remover a ambiguidade do argumento .

Parece que a solução completa é:

git clean -df
git checkout -- .

git cleanremove todos os arquivos não rastreados ( aviso : embora não exclua os arquivos ignorados mencionados diretamente em .gitignore, ele pode excluir os arquivos ignorados que residem nas pastas ) e git checkoutlimpa todas as alterações não faseadas.

Isso verifica o índice atual do diretório atual, descartando todas as alterações nos arquivos do diretório atual para baixo.

git checkout .

ou isso que verifica todos os arquivos do índice, substituindo os arquivos da árvore de trabalho.

git checkout-index -a -f

git clean -df

Limpa a árvore de trabalho removendo recursivamente os arquivos que não estão sob controle de versão, iniciando no diretório atual.

-d: Remova diretórios não rastreados, além de arquivos não rastreados

-f: Force (pode não ser necessário, dependendo do clean.requireForce configuração)

Corra git help cleanpara ver o manual

Meu favorito é

git checkout -p

Isso permite reverter seletivamente os pedaços.

Veja também:

git add -p

Como nenhuma resposta sugere a combinação exata de opções que eu uso, aqui está:

git clean -dfx
git checkout .

Este é o texto de ajuda on-line para as git cleanopções usadas :

-d

Remova os diretórios não rastreados, além dos arquivos não rastreados. Se um diretório não rastreado for gerenciado por um repositório Git diferente, ele não será removido por padrão. Use a -fopção duas vezes se você realmente deseja remover esse diretório.

-f

Se a variável de configuração Git clean.requireForcenão está definido para false, Git limpo irá se recusar a apagar arquivos ou diretórios a menos que recebam -f, -nou -i. O Git se recusará a excluir diretórios dentro do .gitsubdiretório ou arquivo, a menos que -fseja dado um segundo .

-x

Não use as regras de ignorar de .gitignore(por diretório) e $GIT_DIR/info/exclude, mas ainda use as regras de ignorar fornecidas com as -eopções. Isso permite remover todos os arquivos não rastreados, incluindo produtos de construção. Isso pode ser usado (possivelmente em conjunto com git reset) para criar um diretório de trabalho novo para testar uma compilação limpa.

Além disso, git checkout .precisa ser feito na raiz do repositório.

Se você deseja apenas remover as alterações nos arquivos existentes , use checkout( documentado aqui ).

git checkout -- .

• Nenhuma ramificação é especificada e, portanto, faz check-out da ramificação atual.
• O hífen duplo ( --) informa ao Git que o que segue deve ser considerado como seu segundo argumento (caminho), que você ignorou a especificação de um ramo.
• O ponto ( .) indica todos os caminhos.

Se você deseja remover os arquivos adicionados desde a sua última confirmação, use clean( documentado aqui ):

git clean -i 

• A -iopção inicia um interativo clean, para evitar exclusões equivocadas.
• Um punhado de outras opções estão disponíveis para uma execução mais rápida; veja a documentação.

Se você deseja mover as alterações para um espaço de espera para acesso posterior , use stash( documentado aqui ):

git stash

• Todas as alterações serão movidas para o Stash do Git, para possível acesso posterior.
• Um punhado de opções estão disponíveis para esconderijos com mais nuances; veja a documentação.

Eu realmente achei este artigo útil para explicar quando usar o que comando: http://www.szakmeister.net/blog/2011/oct/12/reverting-changes-git/

Existem alguns casos diferentes:

1. Se você não preparou o arquivo, então você o usa git checkout. O checkout "atualiza os arquivos na árvore de trabalho para corresponder à versão no índice". Se os arquivos não tiverem sido testados (ou seja, adicionados ao índice) ... esse comando reverterá essencialmente os arquivos para o seu último commit.

   git checkout -- foo.txt

2. Se você preparou o arquivo temporariamente, use git reset. Redefinir altera o índice para corresponder a uma confirmação.

   git reset -- foo.txt

Suspeito que o uso git stashseja uma escolha popular, pois é um pouco menos perigoso. Você sempre pode voltar a ele se acidentalmente explodir demais ao usar o git reset. A redefinição é recursiva por padrão.

Dê uma olhada no artigo acima para obter mais conselhos.

A maneira mais fácil de fazer isso é usando este comando:

Este comando é usado para descartar alterações no diretório de trabalho -

git checkout -- .

https://git-scm.com/docs/git-checkout

No comando git, a armazenagem de arquivos não rastreados é obtida usando:

git stash -u

http://git-scm.com/docs/git-stash

Se você não está interessado em manter as alterações não organizadas (especialmente se as alterações organizadas são novos arquivos), achei útil:

git diff | git apply --reverse

git checkout -f

man git-checkout:

-f, --force

Ao alternar ramificações, continue mesmo se o índice ou a árvore de trabalho diferirem de HEAD. Isso é usado para jogar fora as alterações locais.

Ao fazer o check-out de caminhos do índice, não falhe nas entradas não imersas; em vez disso, entradas não mescladas são ignoradas.

Conforme você digita o status do git, (use "git checkout - ..." para descartar as alterações no diretório de trabalho) é mostrado.

por exemplo git checkout -- .

Você pode usar o git stash - se algo der errado, você ainda poderá reverter a partir do stash. Semelhante a alguma outra resposta aqui, mas esta também remove todos os arquivos não faseados e também todas as exclusões não faseadas:

git add .
git stash

se você verificar se está tudo bem, jogue fora o esconderijo:

git stash drop

A resposta de Bilal Maqsood com git cleantambém funcionou para mim, mas com o esconderijo eu tenho mais controle - se eu o fizer acidentalmente, ainda posso recuperar minhas alterações

ATUALIZAR

Acho que há mais uma alteração (não sei por que isso funcionou para mim antes):

git add . -A ao invés de git add .

sem os -Aarquivos removidos não serão testados

Atualização de 2019:

Desde julho 2019 , houve um novo comando que faz exatamente isso: git restore.

Em git status, agora Git recomenda usar este comando em vez de git checkoutcomo ele costumava fazer.

Embora esse comando também possa ser usado para restaurar a árvore de trabalho para uma confirmação específica ou para restaurar o conteúdo do índice, por padrão, a árvore de trabalho é restaurada para o estado no índice (o que é solicitado aqui).

Portanto, para restaurar os arquivos que correspondem a um pathspec (se livrando de suas alterações não estágios), você deve:

git restore <pathspec>

Por exemplo, para restaurar todas as alterações não faseadas no diretório atual, você pode executar:

git restore .

Se você executar isso a partir da raiz do projeto, ele restaurará todas as alterações não-estágios em todo o repositório.

Observe que, como em git checkout -- .(como indicado por Mariusz Nowak), isso descartará apenas as alterações nos arquivos rastreados pelo Git e não descartará nenhum novo arquivo não rastreado. Se você deseja descartar as alterações não faseadas, incluindo novos arquivos não rastreados, poderá executar um adicional:

git clean -df

No entanto, tenha muito cuidado com este comando posterior, pois você pode descartar arquivos dos quais não pretendia se livrar.

Nota sobre git restore: como este é um novo comando, sua página de manual emite um aviso:

Este comando é experimental. O comportamento pode mudar.

Portanto, é possível que essa resposta fique desatualizada se o comportamento mudar no futuro. Portanto, pode ser aconselhável executar um rápido man git-restoreantes de usá-lo.

Em vez de descartar as alterações, redefino o controle remoto para a origem. Nota - este método é restaurar completamente sua pasta para a pasta do repositório.

Então, faço isso para garantir que eles não fiquem lá quando eu reiniciar o git (mais tarde - exclui gitignores no Origin / branchname)

NOTA: Se você deseja manter os arquivos ainda não rastreados, mas não em GITIGNORE, pode pular esta etapa, pois limpará esses arquivos não rastreados não encontrados no repositório remoto (obrigado @XtrmJosh).

git add --all

Então eu

git fetch --all

Então eu redefinir para origem

git reset --hard origin/branchname

Isso colocará de volta à estaca zero. Assim como a re-clonagem da ramificação, mantendo todos os meus arquivos marcados com local e localmente.

Atualizado por comentário do usuário abaixo: Variação para redefinir o para qualquer ramo atual em que o usuário esteja.

git reset --hard @{u}

Tentei todas as soluções acima, mas ainda não conseguia se livrar de arquivos novos e sem etapas.

Use git clean -fpara remover esses novos arquivos - com cuidado! Observe a opção de força.

simplesmente diga

git stash

Ele removerá todas as suas alterações locais. Você também pode usar mais tarde dizendo

git stash apply 

ou git stash pop

Apenas use:

git stash -u

Feito. Fácil.

Se você realmente se importa com sua pilha de stash, pode seguir com git stash drop. Mas, nesse ponto, é melhor usar (de Mariusz Nowak):

git checkout -- .
git clean -df

No entanto, eu gosto git stash -umais porque ele "descarta" todas as alterações rastreadas e não rastreadas em apenas um comando . No entanto, git checkout -- .única devoluções alterações controladas e git clean -dfmudanças só devoluções untracked ... e digitando os dois comandos é muito muito trabalho :)

Para fazer um descarte permanente: git reset --hard

Para salvar as alterações para mais tarde: git stash

Isso funciona mesmo em diretórios que são; fora das permissões normais do git.

sudo chmod -R 664 ./* && git checkout -- . && git clean -dfx

Aconteceu comigo recentemente

você tem um comando git muito simples git checkout .

cd path_to_project_folder  # take you to your project folder/working directory 
git checkout .             # removes all unstaged changes in working directory

Na minha opinião,

git clean -df

deve fazer o truque. Conforme documentação do Git no git clean

git-clean - Remove arquivos não rastreados da árvore de trabalho

Descrição

Limpa a árvore de trabalho removendo recursivamente os arquivos que não estão sob controle de versão, iniciando no diretório atual.

Normalmente, apenas os arquivos desconhecidos pelo Git são removidos, mas se a opção -x for especificada, os arquivos ignorados também serão removidos. Por exemplo, isso pode ser útil para remover todos os produtos de construção.

Se algum argumento ... opcional for fornecido, apenas esses caminhos serão afetados.

Opções

-d Remova os diretórios não rastreados, além dos arquivos não rastreados. Se um diretório não rastreado for gerenciado por um repositório Git diferente, ele não será removido por padrão. Use a opção -f duas vezes se você realmente deseja remover esse diretório.

-f --force Se a variável de configuração Git clean.requireForce não estiver definida como false, o git clean se recusará a executar, a menos que seja fornecido -f, -n ou -i.

Independentemente do estado do seu repo, você sempre pode redefinir para qualquer confirmação anterior:

git reset --hard <commit hash>

Isso descartará todas as alterações feitas após a confirmação.

Outra maneira de se livrar de novos arquivos mais específicos do que o git clean -df (isso permitirá que você se livre de alguns arquivos, não necessariamente de todos), é adicionar os novos arquivos ao índice primeiro, depois esconder e soltar o botão esconderijo.

Essa técnica é útil quando, por algum motivo, você não pode excluir facilmente todos os arquivos não rastreados por algum mecanismo comum (como rm).

O que se segue é realmente apenas uma solução se você estiver trabalhando com uma bifurcação de um repositório onde você sincroniza regularmente (por exemplo, solicitação de recebimento) com outro repositório. Resposta curta: exclua fork e refork, mas leia os avisos no github .

Eu tive um problema semelhante, talvez não idêntico, e lamento dizer que minha solução não é ideal, mas é, em última análise, eficaz.

Eu geralmente teria mensagens de status do git como esta (envolvendo pelo menos 2/4 arquivos):

$ git status
# Not currently on any branch.
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/constraint_s2var.dats
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/parsing/parsing_s2var.dats
#
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/constraint_s2Var.dats
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/parsing/parsing_s2Var.dats

Um olho atento notará que esses arquivos têm dopplegangers que são uma única letra no caso de desligamento. De alguma forma, e não tenho idéia do que me levou a seguir esse caminho (como eu não estava trabalhando com esses arquivos no repositório upstream), eu havia trocado esses arquivos. Experimente as muitas soluções listadas nesta página (e em outras páginas) que parecem não ajudar.

Consegui resolver o problema excluindo meu repositório bifurcado e todos os repositórios locais e reforçando. Isso por si só não foi suficiente; o upstream teve que renomear os arquivos em questão para novos nomes de arquivos. Contanto que você não tenha nenhum trabalho não solicitado, wikis e problemas que divergem do repositório upstream, você deve estar bem. O rio acima pode não estar muito feliz com você, para dizer o mínimo. Quanto ao meu problema, é sem dúvida um erro do usuário, pois não sou tão proficiente com o git, mas o fato de estar longe de ser fácil corrigir pontos de um problema com o git também.

Quando você deseja transferir um estoque para outra pessoa:

# add files
git add .  
# diff all the changes to a file
git diff --staged > ~/mijn-fix.diff
# remove local changes 
git reset && git checkout .
# (later you can re-apply the diff:)
git apply ~/mijn-fix.diff

[editar] como comentado, é possível nomear esconderijos. Bem, use isso se você quiser compartilhar seu estoque;)

Você pode criar seu próprio apelido, que descreve como fazê-lo de maneira descritiva.

Eu uso o próximo alias para descartar as alterações.

Descartar alterações em um (lista de) arquivos na árvore de trabalho

discard = checkout --

Em seguida, você pode usá-lo como o próximo para descartar todas as alterações:

discard .

Ou apenas um arquivo:

discard filename

Caso contrário, se você quiser descartar todas as alterações e também os arquivos não rastreados, utilizo uma combinação de checkout e clean:

Limpar e descartar alterações e arquivos não rastreados na árvore de trabalho

cleanout = !git clean -df && git checkout -- .

Portanto, o uso é simples como a seguir:

cleanout

Agora está disponível no próximo repositório do Github, que contém muitos aliases:

• https://github.com/GitAlias/gitalias

Eu tive uma situação estranha em que um arquivo está sempre sem estágio, isso me ajuda a resolver.

git rm .gitattributes
git add -A
git reset --hard