Há um arquivo que estava sendo rastreado git, mas agora o arquivo está na .gitignorelista.

No entanto, esse arquivo continua aparecendo git statusapós ser editado. Como você força gita esquecê-lo completamente?

.gitignoreimpedirá que add -farquivos não rastreados sejam adicionados (sem um ) ao conjunto de arquivos rastreados pelo git; no entanto, o git continuará rastreando todos os arquivos que já estão sendo rastreados.

Para parar de rastrear um arquivo, você precisa removê-lo do índice. Isso pode ser alcançado com este comando.

git rm --cached <file>

Se você deseja remover uma pasta inteira, é necessário remover todos os arquivos nela de forma recursiva.

git rm -r --cached <folder>

A remoção do arquivo da revisão principal ocorrerá no próximo commit.

AVISO: Embora isso não remova o arquivo físico do seu local, os arquivos de outras máquinas de desenvolvedores serão removidos na próxima git pull.

A série de comandos abaixo removerá todos os itens do índice Git (não do diretório de trabalho ou repositório local) e atualiza o índice Git, respeitando o git ignorado. PS. Index = Cache

Primeiro:

git rm -r --cached . 
git add .

Então:

git commit -am "Remove ignored files"

Ou uma linha:

git rm -r --cached . && git add . && git commit -am "Remove ignored files"

O git update-index faz o trabalho para mim:

git update-index --assume-unchanged <file>

Nota: Esta solução é realmente independente em.gitignore pois o gitignore é apenas para arquivos não rastreados.

editar: desde que esta resposta foi publicada, uma nova opção foi criada e deve ser preferida. Você deve usar o --skip-worktreeque é para arquivos rastreados modificados que o usuário não deseja mais confirmar e manter o --assume-unchangeddesempenho para evitar que o git verifique o status de grandes arquivos rastreados. Consulte https://stackoverflow.com/a/13631525/717372 para obter mais detalhes ...

git update-index --skip-worktree <file>

git ls-files --ignored --exclude-standard -z | xargs -0 git rm --cached
git commit -am "Remove ignored files"

Isso pega a lista dos arquivos ignorados e os remove do índice e confirma as alterações.

Eu sempre uso esse comando para remover os arquivos não rastreados. Saída limpa de uma linha, estilo Unix:

git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

Ele lista todos os seus arquivos ignorados, substitui cada linha de saída por uma linha entre aspas para manipular caminhos com espaços internos e passar tudo para git rm -r --cached para remover os caminhos / arquivos / diretórios do índice.

mova-o para fora, confirme e depois mova-o novamente. Isso funcionou para mim no passado. Provavelmente, existe uma maneira 'mais cuidadosa' de conseguir isso.

Se você não puder git rmum arquivo rastreado porque outras pessoas precisam dele (aviso, mesmo que você git rm --cached , quando outra pessoa receber essa alteração, os arquivos serão excluídos no sistema de arquivos). Isso geralmente é feito devido a substituições de arquivos de configuração, credenciais de autenticação etc. Por favor, consulte https://gist.github.com/1423106 para saber como as pessoas resolveram o problema.

Para resumir:

• Faça com que seu aplicativo procure um arquivo ignorado config-overide.ini e use-o sobre o arquivo confirmado config.ini (ou, alternativamente, procure ~ / .config / myapp.ini ou $ MYCONFIGFILE)
• Confirme o arquivo config-sample.ini e ignore o arquivo config.ini, tenha um script ou semelhante copie o arquivo conforme necessário, se necessário.
• Tente usar a magia clean / smudge do gitattributes para aplicar e remover as alterações, por exemplo, borrar o arquivo de configuração como um checkout de uma ramificação alternativa e limpar o arquivo de configuração como um checkout do HEAD. Isso é complicado, eu não recomendo para o usuário iniciante.
• Mantenha o arquivo de configuração em uma ramificação de implantação dedicada a ele que nunca é mesclada ao mestre. Quando você deseja implantar / compilar / testar, mescla esse ramo e obtém esse arquivo. Essa é essencialmente a abordagem smudge / clean, exceto o uso de políticas de mesclagem humana e módulos extra-git.
• Anti-recommentação: Não use a função assumir inalterada, ela só terminará em lágrimas (porque mentir para si mesmo fará com que coisas ruins aconteçam, como a alteração perdida para sempre).

Use isso quando:

1. Você deseja rastrear muitos arquivos ou

2. Você atualizou seu arquivo gitignore

Link da fonte: http://www.codeblocq.com/2016/01/Untrack-files-already-added-to-git-repository-based-on-gitignore/

Digamos que você já tenha adicionado / confirmado alguns arquivos ao seu repositório git e depois os adicione ao seu .gitignore; esses arquivos ainda estarão presentes no seu índice de repositório. Este artigo vamos ver como se livrar deles.

Etapa 1: confirmar todas as suas alterações

Antes de continuar, verifique se todas as alterações foram confirmadas, incluindo o arquivo .gitignore.

Etapa 2: Remova tudo do repositório

Para limpar seu repo, use:

git rm -r --cached .

• rm é o comando remove
• -r permitirá a remoção recursiva
• –Cached irá remover apenas arquivos do índice. Seus arquivos ainda estarão lá.

O rmcomando pode ser implacável. Se você quiser tentar o que faz antes, adicione o -nou--dry-run sinalizador para testar as coisas.

Etapa 3: adicione novamente tudo

git add .

Etapa 4: confirmar

git commit -m ".gitignore fix"

Seu repositório está limpo :)

Envie as alterações para o controle remoto para ver as alterações efetivas também.

Eu consegui isso usando o filtro-ramo git . O comando exato que usei foi retirado da página de manual:

AVISO : isso excluirá o arquivo de todo o seu histórico

git filter-branch --index-filter 'git rm --cached --ignore-unmatch filename' HEAD

Este comando recriará todo o histórico de consolidação, executando git rmantes de cada consolidação e, portanto, eliminará o arquivo especificado. Não se esqueça de fazer backup antes de executar o comando, pois ele será perdido.

O que não funcionou para mim

(No Linux), eu queria usar as postagens aqui sugerindo a ls-files --ignored --exclude-standard | xargs git rm -r --cachedabordagem. No entanto, (alguns dos) arquivos a serem removidos tinham uma nova linha / LF / incorporada \nem seus nomes. Nenhuma das soluções:

git ls-files --ignored --exclude-standard | xargs -d"\n" git rm --cached
git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

lidar com esta situação (obter erros sobre arquivos não encontrados).

Então eu ofereço

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached
git commit -am "Remove ignored files"

Isso usa o -zargumento para ls-files e o -0argumento para xargs para atender com segurança / corretamente caracteres "desagradáveis" nos nomes de arquivos.

Na página de manual git-ls-files (1) , afirma:

Quando a opção -z não é usada, os caracteres TAB, LF e barra invertida nos nomes dos caminhos são representados como \ t, \ n e \\, respectivamente.

então acho que minha solução é necessária se os nomes de arquivos tiverem algum desses caracteres.

1. Atualize seu .gitignorearquivo - por exemplo, adicione uma pasta para a qual não deseja rastrear .gitignore.

2. git rm -r --cached .- Remova todos os arquivos rastreados, incluindo os desejados e os indesejados. Seu código estará seguro enquanto você salvar localmente.

3. git add .- Todos os arquivos serão adicionados novamente, exceto os arquivos .gitignore.

Gorjeta de chapéu para @AkiraYamamoto por nos indicar a direção certa.

Eu acho que talvez o git não possa esquecer totalmente o arquivo por causa de sua concepção ( seção "Instantâneos, não diferenças" ).

Esse problema está ausente, por exemplo, ao usar o CVS. O CVS armazena informações como uma lista de alterações baseadas em arquivos. Informações para o CVS são um conjunto de arquivos e as alterações feitas em cada arquivo ao longo do tempo.

Mas no Git, toda vez que você confirma ou salva o estado do seu projeto, basicamente tira uma foto do que todos os seus arquivos aparência de naquele momento e armazena uma referência a esse instantâneo. Portanto, se você adicionou o arquivo uma vez, ele sempre estará presente nesse instantâneo.

Estes 2 artigos foram úteis para mim:

git assume-inalterado vs skip-worktree e Como ignorar alterações nos arquivos rastreados com o Git

Baseando-me, faça o seguinte, se o arquivo já estiver rastreado:

git update-index --skip-worktree <file>

A partir deste momento, todas as alterações locais neste arquivo serão ignoradas e não serão remotas. Se o arquivo for alterado no controle remoto, ocorrerá conflito quando git pull. Stash não vai funcionar. Para resolvê-lo, copie o conteúdo do arquivo para o local seguro e siga estas etapas:

git update-index --no-skip-worktree <file>
git stash
git pull 

O conteúdo do arquivo será substituído pelo conteúdo remoto. Cole suas alterações de um local seguro para arquivar e execute novamente:

git update-index --skip-worktree <file>

Se todos que trabalham com o projeto tiverem git update-index --skip-worktree <file>problemas, os problemas pulldevem estar ausentes. Esta solução é adequada para arquivos de configurações, quando cada desenvolvedor tem sua própria configuração de projeto.

Não é muito conveniente fazer isso sempre, quando o arquivo foi alterado no controle remoto, mas pode protegê-lo contra a substituição por conteúdo remoto.

Siga as etapas a seguir em série, você ficará bem.

1. remova os arquivos adicionados por engano do diretório / armazenamento . Você pode usar o comando "rm -r" (para linux) ou excluí-los navegando nos diretórios. Ou mova-os para outro local no seu PC. [Talvez você precise fechar o IDE se estiver executando para mover / remover ]

2. adicione os arquivos / diretórios ao gitignorearquivo agora e salve-o.

3. agora remova- os do cache do git usando estes comandos (se houver mais de um diretório, remova-os um por um emitindo repetidamente este comando)

git rm -r --cached path-to-those-files

4. agora faça um commit e push , use estes comandos. Isso removerá esses arquivos do git remote e fará com que o git pare de rastrear esses arquivos.

git add .
git commit -m "removed unnecessary files from git"
git push origin

A resposta copiar / colar é git rm --cached -r .; git add .; git status

Este comando ignorará os arquivos que já foram confirmados em um repositório Git, mas agora os adicionamos .gitignore.

A resposta de Matt Fear foi o IMHO mais eficaz. A seguir, é apenas um script do PowerShell para quem está no Windows para remover apenas arquivos de seu repositório git que corresponda à sua lista de exclusão.

# Get files matching exclusionsfrom .gitignore
# Excluding comments and empty lines
$ignoreFiles =  gc .gitignore | ?{$_ -notmatch  "#"} |  ?{$_ -match  "\S"} | % {
                    $ignore = "*" + $_ + "*"
                    (gci -r -i $ignore).FullName
                }
$ignoreFiles = $ignoreFiles| ?{$_ -match  "\S"}

# Remove each of these file from Git 
$ignoreFiles | % { git rm $_}

git add .

Mova ou copie o arquivo para um local seguro, para não perdê-lo. Em seguida, git rm o arquivo e confirme. O arquivo ainda será exibido se você reverter para uma dessas confirmações anteriores ou para outra ramificação em que não foi removida. No entanto, em todas as confirmações futuras, você não verá o arquivo novamente. Se o arquivo estiver no git ignore, você poderá movê-lo novamente para a pasta e o git não o verá.

O uso do git rm --cachedcomando não responde à pergunta original:

Como você força gita esquecer completamente [um arquivo]?

De fato, esta solução fará com que o arquivo seja excluído em todas as outras instâncias do repositório ao executar um git pull!

A maneira correta de forçar o git a esquecer um arquivo é documentada pelo GitHub aqui .

Eu recomendo a leitura da documentação, mas basicamente:

git fetch --all
git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch full/path/to/file' --prune-empty --tag-name-filter cat -- --all
git push origin --force --all
git push origin --force --tags
git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

apenas substitua full/path/to/filepelo caminho completo do arquivo. Verifique se você adicionou o arquivo ao seu .gitignore.

Você também precisará (temporariamente) permitir empurrões de avanço rápido para seu repositório , pois está alterando seu histórico do git.

O BFG foi projetado especificamente para remover dados indesejados, como arquivos grandes ou senhas, dos repositórios do Git, por isso possui um sinalizador simples que remove todos os grandes arquivos históricos (que não estão no seu commit atual): '--strip-blobs- maior que'

$ java -jar bfg.jar --strip-blobs-bigger-than 100M

Se você deseja especificar arquivos por nome, também pode fazer isso:

$ java -jar bfg.jar --delete-files *.mp4

O BFG é 10-1000x mais rápido que o git filter-branch e geralmente muito mais fácil de usar - consulte as instruções e exemplos de uso completos para obter mais detalhes.

Fonte: https://confluence.atlassian.com/bitbucket/reduce-repository-size-321848262.html

Se você não quiser usar a CLI e estiver trabalhando no Windows, uma solução muito simples é usar o TortoiseGit , que possui a ação "Excluir (manter local)" no menu que funciona bem.

Gostei da resposta de JonBrave, mas tenho diretórios de trabalho confusos o suficiente que comprometem -a me assusta um pouco, então aqui está o que eu fiz:

git config - global alias.exclude-ignorado '! git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached && git ls-files -z --ignored --exclude-standard | xargs -0 git stage && git stage .gitignore && git commit -m "novo gitignore e remova arquivos ignorados do índice" '

dividindo:

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached 
git ls-files -z --ignored --exclude-standard | xargs -0 git stage 
git stage .gitignore 
git commit -m "new gitignore and remove ignored files from index"

• remover arquivos ignorados do índice
• estágio .gitignore e os arquivos que você acabou de remover
• comprometer

Isso não é mais um problema no último git (v2.17.1 no momento da redação).

O .gitignorefinalmente ignora os arquivos rastreados, mas excluídos. Você pode testar isso executando o seguinte script. A git statusdeclaração final deve relatar "nada a confirmar".

# Create empty repo
mkdir gitignore-test
cd gitignore-test
git init

# Create a file and commit it
echo "hello" > file
git add file
git commit -m initial

# Add the file to gitignore and commit
echo "file" > .gitignore
git add .gitignore
git commit -m gitignore

# Remove the file and commit
git rm file
git commit -m "removed file"

# Reintroduce the file and check status.
# .gitignore is now respected - status reports "nothing to commit".
echo "hello" > file
git status

No caso de já estar comprometido DS_Store:

find . -name .DS_Store -print0 | xargs -0 git rm --ignore-unmatch

Ignore-os por:

echo ".DS_Store" >> ~/.gitignore_global
echo "._.DS_Store" >> ~/.gitignore_global
echo "**/.DS_Store" >> ~/.gitignore_global
echo "**/._.DS_Store" >> ~/.gitignore_global
git config --global core.excludesfile ~/.gitignore_global

Finalmente, faça um commit!

Especialmente para os arquivos baseados em IDE, eu uso este:

Por exemplo, o slnx.sqlite, acabei de me livrar completamente da seguinte maneira:

git rm {PATH_OF_THE_FILE}/slnx.sqlite -f
git commit -m "remove slnx.sqlite"

Lembre-se de que alguns desses arquivos armazenam algumas configurações e preferências locais do usuário para projetos (como os arquivos que você abriu). Portanto, toda vez que você navega ou faz algumas alterações em seu IDE, esse arquivo é alterado e, portanto, faz check-out e mostra como existem alterações não confirmadas.

A resposta aceita não "faz o Git " esquecer " um arquivo ..." (historicamente). Faz apenas o git ignorar o arquivo no presente / futuro.

Este método faz com que o git esqueça completamente os arquivos ignorados ( passado / presente / futuro), mas não exclui nada do diretório ativo (mesmo quando retirado novamente do controle remoto).

Este método requer o uso de /.git/info/exclude(preferencial) OU um pré-existente .gitignore em todas as confirmações que possuem arquivos a serem ignorados / esquecidos. ¹

Todos os métodos de impor o git ignoram o comportamento depois que o fato reescreve o histórico e, portanto, têm ramificações significativas para quaisquer repositórios públicos / compartilhados / colaborativos que possam ser extraídos após esse processo. ²

Conselho geral: comece com um repositório limpo - tudo confirmado, nada pendente no diretório ou índice ativo e faça um backup !

Além disso, os comentários / histórico de revisões desta resposta ( e o histórico de revisões desta pergunta ) podem ser úteis / esclarecedores.

#commit up-to-date .gitignore (if not already existing)
#this command must be run on each branch

git add .gitignore
git commit -m "Create .gitignore"

#apply standard git ignore behavior only to current index, not working directory (--cached)
#if this command returns nothing, ensure /.git/info/exclude AND/OR .gitignore exist
#this command must be run on each branch

git ls-files -z --ignored --exclude-standard | xargs -0 git rm --cached

#Commit to prevent working directory data loss!
#this commit will be automatically deleted by the --prune-empty flag in the following command
#this command must be run on each branch

git commit -m "ignored index"

#Apply standard git ignore behavior RETROACTIVELY to all commits from all branches (--all)
#This step WILL delete ignored files from working directory UNLESS they have been dereferenced from the index by the commit above
#This step will also delete any "empty" commits.  If deliberate "empty" commits should be kept, remove --prune-empty and instead run git reset HEAD^ immediately after this command

git filter-branch --tree-filter 'git ls-files -z --ignored --exclude-standard | xargs -0 git rm -f --ignore-unmatch' --prune-empty --tag-name-filter cat -- --all

#List all still-existing files that are now ignored properly
#if this command returns nothing, it's time to restore from backup and start over
#this command must be run on each branch

git ls-files --other --ignored --exclude-standard

Por fim, siga o restante deste guia do GitHub (começando na etapa 6), que inclui avisos / informações importantes sobre os comandos abaixo .

git push origin --force --all
git push origin --force --tags
git for-each-ref --format="delete %(refname)" refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

Outros desenvolvedores que obtêm do repositório remoto modificado agora devem fazer um backup e, em seguida:

#fetch modified remote

git fetch --all

#"Pull" changes WITHOUT deleting newly-ignored files from working directory
#This will overwrite local tracked files with remote - ensure any local modifications are backed-up/stashed

git reset FETCH_HEAD

Notas de rodapé

¹ Como /.git/info/excludepode ser aplicado a todas as confirmações históricas usando as instruções acima, talvez os detalhes sobre a inserção de um .gitignorearquivo nas confirmações históricas necessárias estejam além do escopo desta resposta. Eu queria que um apropriado .gitignoreestivesse no commit raiz, como se fosse a primeira coisa que fiz. Outros podem não se importar, pois /.git/info/excludepodem realizar a mesma coisa, independentemente de onde .gitignoreexista no histórico de confirmação, e reescrever claramente o histórico é um assunto muito delicado, mesmo quando está ciente das ramificações .

FWIW, métodos potenciais podem incluir git rebaseou um git filter-branchque copia um externo .gitignore para cada confirmação, como as respostas a esta pergunta

^{2 A} imposição do comportamento do git ignore após a confirmação dos resultados de um git rm --cachedcomando independente pode resultar na exclusão de arquivos recém-ignorados em futuras tentativas do controle remoto forçado. O --prune-emptysinalizador no git filter-branchcomando a seguir evita esse problema removendo automaticamente a confirmação somente do índice "excluir todos os arquivos ignorados" anterior. Reescrever o histórico do git também altera os hashes de confirmação, o que causará estragos em futuras solicitações de repositórios públicos / compartilhados / colaborativos. Por favor, entenda as ramificações completamente antes de fazer isso em um repositório desse tipo. Este guia do GitHub especifica o seguinte:

Diga a seus colaboradores para refazer , e não mesclar, quaisquer ramificações que eles criaram do histórico de repositório antigo (contaminado). Um commit de mesclagem pode reintroduzir parte ou toda a história corrompida que você acabou de dar ao trabalho de eliminar.

Soluções alternativas que não afetam o repositório remoto são git update-index --assume-unchanged </path/file>ou git update-index --skip-worktree <file>, exemplos dos quais podem ser encontrados aqui .

Se alguém com dificuldade no Windows e você deseja ignorar a pasta inteira, 'cd' deseja a 'pasta' e faça 'Git Bash Here'.

git ls-files -z | xargs -0 git update-index --assume-unchanged

No meu caso aqui, eu tinha vários arquivos .lock em vários diretórios que precisava remover. Eu executei o seguinte e funcionou sem ter que entrar em cada diretório para removê-los:

git rm -r --cached **/*.lock

Fazer isso foi para cada pasta na 'raiz' de onde eu estava e excluiu todos os arquivos que correspondiam ao padrão.

Espero que isso ajude os outros!