Como faço para descartar unstaged alterações no Git?

Question

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

Answer 1

Outra maneira mais rápida é:

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

Você não precisa incluir --include-untracked se você não quer ser aprofundada sobre ele.

Depois disso, você pode descartar que o stash com uma git stash drop de comando, se você gosta.

Answer 2

Para todos os unstaged arquivos no diretório de trabalho atual uso:

git checkout -- .

Para um arquivo específico, use:

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

-- aqui remover argumento ambiguation.

Answer 3

Parece que a solução completa é:

git clean -df
git checkout -- .

git clean remove todos os arquivos não controlados (aviso:embora não exclua arquivos ignorados mencionado diretamente no .gitignore, ele pode excluir arquivos ignorados, residente em pastas) e git checkout limpa todos os unstaged alterações.

Answer 4

Este verifica o índice atual para o diretório atual, jogando fora todas as alterações em arquivos do diretório atual para baixo.

git checkout .

ou este que verifica todos os ficheiros de índice, substituindo a trabalhar árvore de arquivos.

git checkout-index -a -f

Answer 5

git clean -df

Limpa a árvore de trabalho, por recursivamente a remoção de arquivos que não estão sob controle de versão, começando a partir do diretório atual.

-d:Remover untracked diretórios, além de arquivos não controlados

-f:Força (pode não ser necessário, dependendo da clean.requireForce definição)

Executar git help clean para ver o manual

Answer 6

O meu favorito é

git checkout -p

Que permite que você seletivamente reverter pedaços.

Veja também:

git add -p

Answer 7

Uma vez que nenhuma resposta sugere a opção exata combinação que eu uso, aqui está ele:

git clean -dfx
git checkout .

Esta é a ajuda on-line texto utilizado para a git clean opções:

-d

Remover untracked diretórios, além de arquivos não controlados.Se um untracked diretório é gerenciado por um repositório Git, ele não é removido por padrão.Utilização -f opção duas vezes se você realmente deseja remover esse directório.

-f

Se a variável de configuração do Git clean.requireForce não está definido para false, Git clean irá recusar-se a excluir arquivos ou diretórios, a menos que determinado -f, -n, ou -i.O Git irá recusar-se a excluir diretórios dentro do .git subdiretório ou arquivo, a menos que um segundo -f é dada.

-x

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

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

Answer 8

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

Há um par de diferentes casos:

1. Se você ainda não organizou o arquivo e, em seguida, você usar git checkout.Checkout "atualizações de arquivos na árvore de trabalho para corresponder à versão no índice".Se os ficheiros não foram testados (aka adicionados ao índice)...este comando irá reverter os arquivos para que o seu último commit foi.

   git checkout -- foo.txt

2. Se você tem preparado o arquivo e, em seguida, usar o git reset.Repor as alterações do índice de corresponder a um compromisso.

   git reset -- foo.txt

Eu suspeito que a utilização git stash é uma escolha popular já que é um pouco menos perigoso.Você pode sempre voltar a ele, se você acidentalmente golpe muito longe ao usar o git reset.A reposição é recursivo por padrão.

Dê uma olhada no artigo acima para mais informações.

Answer 9

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

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

git checkout -- .

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

No comando svn, esconder de arquivos não controlados é conseguido através de:

git stash -u

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

Answer 10

Se você quiser para remover as alterações nos arquivos existentes, uso checkout (documentado aqui).

git checkout -- .

• Nenhum ramo é especificado, então ele verifica a corrente de ramo.
• O duplo hífen (--) indica o Git que o que se segue deve ser tomado como seu segundo argumento (o caminho), que você pulou a especificação de um ramo.
• Período (.) indica que todos os caminhos.

Se você quiser para remover os arquivos adicionados desde o último commit, use clean (documentado aqui):

git clean -i 

• O -i opção inicia uma interativo clean, para evitar enganado exclusões.
• Um punhado de outras opções estão disponíveis para uma rápida execução;consulte a documentação.

Se você deseja para mover alterações a uma exploração de espaço para acesso posterior, uso stash (documentado aqui):

git stash

• Todas as alterações serão movidos para o Git Stash, para possível acessar posteriormente.
• Um punhado de opções estão disponíveis para mais sutil esconder;consulte a documentação.

Answer 11

Se você não está interessado em manter o unstaged alterações (especialmente se o encenado alterações são novos arquivos), eu encontrei este útil:

git diff | git apply --reverse

Answer 12

Como você digite o git status, (use "git checkout -- ..." para descartar as alterações na pasta de trabalho) é mostrado.

exemplo: git checkout -- .

Answer 13

git checkout -f

---

man git-checkout:

-f, --force

Quando mudar de ramos, de continuar, mesmo se o índice ou a árvore de trabalho difere da CABEÇA.Este é usado para jogar fora as alterações locais.

Quando a verificação de caminhos a partir do índice, não falham ao não integradas entradas;em vez disso, não integradas entradas serão ignoradas.

Answer 14

Você pode usar o git stash - se algo der errado, você ainda pode reverter a partir do stash.Semelhante a alguns outros resposta aqui, mas este também remove todos os unstaged arquivos e também todos os unstaged exclui:

git add .
git stash

se você verificar que está tudo OK, jogue o stash de distância:

git stash drop

A resposta de Bilal Maqsood com git clean também trabalhou para mim, mas com o stash tenho mais controle - se eu fizer hts, acidentalmente, eu ainda posso entrar minha mudança de volta

ATUALIZAÇÃO

Eu acho que não há mais 1 alteração (não sei por que isso funcionou para mim antes):

git add . -A em vez de git add .

sem o -A os arquivos removidos não será encenada

Answer 15

Em vez de descartar as alterações, redefinir a minha remoto para a origem.Nota - este método é para restaurar completamente a sua pasta para que o acordo de recompra.

Então, eu faço isso para se certificar de que eles não se sentam lá, quando eu git reset (mais tarde - exclui gitignores sobre a Origem/branchname)

NOTA:Se você deseja manter os arquivos ainda não foram controladas, mas não em GITIGNORE você pode pular este passo, como ele vai Limpar esses arquivos não controlados não encontrado no seu repositório remoto (obrigado @XtrmJosh).

git add --all

Em Seguida, Eu

git fetch --all

Em seguida, repor a origem

git reset --hard origin/branchname

Que vai colocá-lo de volta à estaca zero.Assim como RE-Clonagem do ramo, mantendo todos os meus gitignored arquivos localmente e no lugar.

Atualizado por usuário comentário abaixo:Variação para repor o para qualquer que seja o ramo actual do utilizador é no.

git reset --hard @{u}

Answer 16

Tentei todas as soluções acima, mas ainda não conseguia livrar-se de novo, unstaged arquivos.

Utilização git clean -f para remover os arquivos novos - com cuidado, porém! Nota a opção force.

Answer 17

simplesmente dizer

git stash

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

git stash apply 

ou git stash pop

Answer 18

Basta usar:

git stash -u

Feito.É fácil.

Se você realmente cuidado com seu stash pilha, em seguida, você pode seguir com git stash drop.Mas em que ponto você é melhor fora de usar (a partir de Mariusz Nowak):

git checkout -- .
git clean -df

No entanto, eu gosto de git stash -u o melhor, porque "não descarta" todas as controladas e não controladas alterações em apenas um comando.Ainda git checkout -- . só descarta alterações controladas, e git clean -df só descarta untracked alterações...e digitar os dois comandos é longe muito trabalho :)

Answer 19

Isso funciona mesmo em diretórios;fora do normal git permissões.

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

Aconteceu-me recentemente

Answer 20

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

Answer 21

Não importa em que estado o seu repo é que você pode sempre repor anterior que o commit:

git reset --hard <commit hash>

---

Isto irá descartar todas as alterações que foram feitas depois que confirmar.

Answer 22

Outra maneira de se livrar de novos arquivos, que é mais específico do que o git limpa -df (ele irá permitir que você se livrar de alguns arquivos que não necessariamente todos), é adicionar novos arquivos para o primeiro índice e, em seguida, stash, em seguida, solte o stash.

Esta técnica é útil quando, por algum motivo, você não pode facilmente excluir todos os arquivos não controlados por alguns ordinária mecanismo (como rm).

Answer 23

Na minha opinião,

git clean -df

deve fazer o truque.Como por Git documentação sobre git limpo

git-limpeza - Remover arquivos não controlados a partir da árvore de trabalho

Descrição

Limpa a árvore de trabalho, por recursivamente a remoção de arquivos que não estão sob controle de versão, começando a partir do diretório atual.

Normalmente, somente os arquivos desconhecidos para o Git são removidos, mas se a opção-x é especificado, os arquivos ignorados também são removidos.Isto pode, por exemplo, ser útil para remover toda a criação de produtos.

Se qualquer opcional ...os argumentos são fornecidos, apenas os caminhos são afetados.

Opções

-d Remova untracked diretórios, além de arquivos não controlados.Se um untracked diretório é gerenciado por um repositório Git, é não removidos por padrão.Usar a opção-f duas vezes se você realmente quer remover um diretório.

-f --force Se o Git variável de configuração limpa.requireForce não está definido para false, o git clean irá recusar-se a executar, a menos que determinado -f, -n ou -i.

Answer 24

O que se segue é realmente apenas uma solução se você estiver trabalhando com um garfo de um repositório onde você sincronize regularmente (por exemplo,pull request) com outro repositório.Resposta curta:excluir garfo e refork, mas leia os avisos no github.

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

Muitas vezes tenho git status de mensagens como esta (que envolvam, 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 afiado, vai notar que estes ficheiros têm doppelgangers que são uma única carta, no caso, fora.De alguma forma, e eu não tenho nenhuma idéia o que me levou para o caminho para começar (como eu não estava trabalhando com esses arquivos-me do montante de recompra), eu tinha mudado a esses arquivos.Tente as soluções apresentadas nesta página (e de outras páginas) não parecem ajudar.

Eu era capaz de corrigir o problema excluindo o meu parágrafos repositório e todos os repositórios locais, e reforking.Isso por si só não era suficiente;upstream tive que renomear os arquivos em questão para novos nomes. Contanto que você não tem qualquer uncommited trabalho, não wikis, e não problemas que divergem do montante repositório, você deve ser apenas a de multa.Upstream pode não ser muito feliz com você, para dizer o mínimo.Como para o meu problema, é, sem dúvida, um erro, pois não estou acostumado com o git, mas o fato de que ele está longe de ser fácil para corrigir aponta para um problema com o git bem.

Answer 25

Quando você deseja transferir um baú de 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 comentei, não é possível ao nome de estoques.Bem, use esta opção se deseja partilhar o seu stash ;)

Answer 26

Você pode criar o seu próprio alias, que descreve como fazê-lo de uma forma descritiva.

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

---

Descartar as alterações em uma lista de) arquivo(s) na árvore de trabalho

discard = checkout --

Em seguida, você pode usá-lo como avançar para descartar todas as alterações:

discard .

Ou apenas um arquivo:

discard filename

---

Caso contrário, se você deseja descartar todas as alterações e também os arquivos não controlados, eu uso uma mistura de checkout e limpo:

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

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

Por isso, o uso é simples como o seguinte:

cleanout

---

Agora está disponível no seguinte Github repositório que contém um monte de aliases:

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

Answer 27

Se todos os arquivos de teste foram realmente cometidos, em seguida, o ramo pode ser simplesmente repor e.g.a partir de sua interface gráfica, com cerca de três cliques do mouse: Ramo, Repor, Sim!

Então, o que faço com frequência, na prática, reverter indesejados alterações locais é consolidar todas as coisas boas, e, em seguida, repor o ramo.

Se as coisas boas é cometida em um único commit, então você pode usar "alterar último commit" para trazê-lo de volta para ser encenado ou unstaged se pretende, em última análise, como a cometê-lo de maneira um pouco diferente.

Esse pode não ser o técnico da solução que você procura para o seu problema, mas acho que é uma solução bem prática.Ele permite que você descarte unstaged alterações seletivamente, redefinindo as alterações que você não gosta e manter o que você faz.

Então, em resumo, eu simplesmente não confirmar, ramo de reposição de, e alterar último commit.

Answer 28

Se você estiver no caso do submódulo e não outras soluções funcionar, tente:

• Para verificar qual é o problema (talvez um "suja" o caso), use:

  git diff

• Para remover o stash

  git submodule update

Answer 29

Eu tinha uma estranha situação onde um arquivo é sempre unstaged, isso me ajuda a resolver.

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

Answer 30

Se é quase impossível para a regra de modificações dos arquivos, você já pensou em ignorá-las?Se esta afirmação é certo e que você não toque os arquivos durante o seu desenvolvimento, este comando pode ser útil:

git update-index --assume-unchanged file_to_ignore