Às vezes, o git sugere git rm --cacheddesestabilizar um arquivo, às vezes git reset HEAD file. Quando devo usar qual?

EDITAR:

D:\code\gt2>git init
Initialized empty Git repository in D:/code/gt2/.git/
D:\code\gt2>touch a

D:\code\gt2>git status
# On branch master
#
# Initial commit
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       a
nothing added to commit but untracked files present (use "git add" to track)

D:\code\gt2>git add a

D:\code\gt2>git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#       new file:   a
#
D:\code\gt2>git commit -m a
[master (root-commit) c271e05] a
 0 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 a

D:\code\gt2>touch b

D:\code\gt2>git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       b
nothing added to commit but untracked files present (use "git add" to track)

D:\code\gt2>git add b

D:\code\gt2>git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   b
#

git rm --cached <filePath> não desestabiliza um arquivo, ele efetivamente prepara a remoção do (s) arquivo (s) do repositório (supondo que ele já foi confirmado anteriormente), mas deixa o arquivo na sua árvore de trabalho (deixando um arquivo não rastreado).

git reset -- <filePath>vai unstage qualquer encenado mudanças para o arquivo fornecido (s).

Dito isto, se você usasse git rm --cachedum novo arquivo preparado, basicamente pareceria que você o desestabilizou, pois nunca havia sido confirmado antes.

Atualizar git 2.24
Nesta versão mais recente do git, você pode usar em git restore --stagedvez de git reset. Veja os documentos do git .

git rm --cachedé usado para remover um arquivo do índice. No caso em que o arquivo já esteja no repositório, ele git rm --cachedserá removido do índice, deixando-o no diretório ativo e uma confirmação também o removerá do repositório. Basicamente, após a confirmação, você teria desversionado o arquivo e mantido uma cópia local.

git reset HEAD file(que por padrão está usando o --mixedsinalizador) é diferente, pois, no caso em que o arquivo já está no repositório, ele substitui a versão do índice pelo arquivo do repositório (HEAD), efetivamente desestabilizando as modificações nele.

No caso de arquivo não versionado, ele vai desestabilizar o arquivo inteiro, pois o arquivo não estava lá no HEAD. Nesse aspecto git reset HEAD filee git rm --cachedsão iguais, mas não são iguais (conforme explicado no caso de arquivos já existentes no repositório)

Para a questão de Why are there 2 ways to unstage a file in git?- nunca há realmente apenas uma maneira de fazer algo no git. Essa é a beleza disso :)

Muito simples:

• git rm --cached <file> faz com que o git pare de rastrear o arquivo completamente (deixando-o no sistema de arquivos, ao contrário do simples git rm*)
• git reset HEAD <file> desinstala as modificações feitas no arquivo desde a última confirmação (mas não as reverte no sistema de arquivos, ao contrário do que o nome do comando pode sugerir **). O arquivo permanece sob controle de revisão.

Se o arquivo não estava no controle de revisão antes (ou seja, você está desestabilizando um arquivo que você havia git addeditado pela primeira vez), os dois comandos têm o mesmo efeito, daí a aparência de serem "duas maneiras de fazer algo" "

_{* Lembre-se da ressalva que @DrewT menciona em sua resposta, referente a git rm --cachedum arquivo que foi previamente confirmado no repositório. No contexto desta pergunta, de um arquivo que acabou de ser adicionado e ainda não confirmado, não há com o que se preocupar.}

_{** Por um tempo embaraçosamente longo, fiquei com medo de usar o comando git reset por causa de seu nome - e ainda hoje hoje procuro a sintaxe para garantir que não estrague tudo. ( atualização : finalmente dediquei um tempo para resumir o uso de git resetem uma página tldr ; agora, tenho um modelo mental melhor de como ele funciona e uma referência rápida para quando esqueço alguns detalhes.)}

Este tópico é um pouco antigo, mas ainda quero adicionar uma pequena demonstração, pois ainda não é um problema intuitivo:

me$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   new file:   to-be-added
#   modified:   to-be-modified
#   deleted:    to-be-removed
#

me$ git reset -q HEAD to-be-added

    # ok

me$ git reset -q HEAD to-be-modified

    # ok

me$ git reset -q HEAD to-be-removed

    # ok

# or alternatively:

me$ git reset -q HEAD to-be-added to-be-removed to-be-modified

    # ok

me$ git status
# On branch master
# Changes not staged for commit:
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   modified:   to-be-modified
#   deleted:    to-be-removed
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#   to-be-added
no changes added to commit (use "git add" and/or "git commit -a")

git reset HEAD(sem -q) emite um aviso sobre o arquivo modificado e seu código de saída é 1, que será considerado um erro em um script.

Editar: git checkout HEAD to-be-modified to-be-removedtambém funciona para desestágio, mas remove a alteração completamente do espaço de trabalho

Atualização git 2.23.0: De tempos em tempos, os comandos mudam. Agora git statusdiz:

  (use "git restore --staged <file>..." to unstage)

... que funciona para todos os três tipos de mudança

se você preparou arquivos acidentalmente que não gostaria de confirmar e deseja ter certeza de que mantém as alterações, também pode usar:

git stash
git stash pop

isso executa uma redefinição para HEAD e reaplica suas alterações, permitindo reestabelecer arquivos individuais para confirmação. isso também é útil se você esqueceu de criar um ramo de recurso para solicitações pull ( git stash ; git checkout -b <feature> ; git stash pop).

Esses 2 comandos têm várias diferenças sutis se o arquivo em questão já estiver no repositório e sob controle de versão (confirmado anteriormente etc.):

• git reset HEAD <file> desestágena o arquivo no commit atual.
• git rm --cached <file>desestabilizará o arquivo para confirmações futuras também. É sem estágio até que seja adicionado novamente git add <file>.

E há mais uma diferença importante:

• Depois de executar git rm --cached <file>e enviar sua ramificação para o controle remoto, qualquer pessoa que puxe sua ramificação do controle remoto receberá o arquivo REALMENTE excluído da pasta, embora no conjunto de trabalho local o arquivo se torne não rastreado (ou seja, não excluído fisicamente da pasta).

Essa última diferença é importante para projetos que incluem um arquivo de configuração em que cada desenvolvedor da equipe possui uma configuração diferente (por exemplo, URL de base, IP ou configuração de porta diferente); portanto, se você estiver usando git rm --cached <file>alguém que puxa sua ramificação, precisará refazer manualmente crie a configuração ou envie-os seus e eles poderão editá-los novamente para as configurações de ip (etc.), porque a exclusão afeta apenas as pessoas que puxam sua ramificação do controle remoto.

Digamos que você stageexiba um diretório inteiro via git add <folder>, mas você deseja excluir um arquivo da lista faseada (ou seja, a lista que é gerada durante a execução git status) e manter as modificações no arquivo excluído (você estava trabalhando em algo e ele não está pronto para confirmação, mas você não quer perder seu trabalho ...). Você pode simplesmente usar:

git reset <file>

Ao executar git status, você verá que quaisquer arquivos que você reseté unstagede o restante dos arquivos addedainda estão na stagedlista.

1

D:\code\gt2>git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#       new file:   a

(use "git rm --cached ..." para desestabilizar)

• git é um sistema de ponteiros

• você ainda não tem um commit para alterar seu ponteiro para

• a única maneira de 'retirar arquivos do bucket apontado' é remover os arquivos que você disse ao git para observar as alterações

2)

D:\code\gt2>git commit -m a
[master (root-commit) c271e05] a
0 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 a

git commit -ma

• você comprometeu, ' salvou '

3)

D:\code\gt2>git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   b
#

(use "git reset HEAD ..." para desmontar)

• você fez um commit no seu código no momento
• agora você pode redefinir o ponteiro para o seu commit ' reverter para o último salvamento '

Estou surpreso que ninguém tenha mencionado o reflit git ( http://git-scm.com/docs/git-reflog ):

# git reflog
<find the place before your staged anything>
# git reset HEAD@{1}

O reflog é um histórico do git que não apenas rastreia as alterações no repositório, mas também as ações do usuário (por exemplo, pull, checkout para diferentes ramificações, etc.) e permite desfazer essas ações. Portanto, em vez de desagrupar o arquivo que foi preparado por engano, você pode reverter para o ponto em que não os preparou.

Isso é semelhante, git reset HEAD <file>mas em certos casos pode ser mais granular.

Desculpe - realmente não estou respondendo à sua pergunta, mas apenas apontando mais uma maneira de arquivar arquivos que eu uso com frequência (eu gosto de respostas de Ryan Stewart e Waldyrious.);) Espero que ajude.

Apenas use:

git reset HEAD <filename>

Isso desinstala o arquivo e mantém as alterações feitas nele, para que você possa, por sua vez, alterar ramificações, se desejar, e git addesses arquivos para outra ramificação. Todas as alterações são mantidas.

Parece-me que git rm --cached <file>remove o arquivo do índice sem removê-lo do diretório em que uma planície git rm <file>faria as duas coisas, assim como um sistema operacional rm <file>remove o arquivo do diretório sem remover seu controle de versão.

Somente para as versões 2.23 e acima,

Em vez dessas sugestões, você pode usar git restore --staged <file>para unstageo (s) arquivo (s).