repositorio - verificar arquivos git




Como fazer o Git “esquecer” de um arquivo que foi rastreado mas agora está no.gitignore? (14)

Use isto quando:

1. Você deseja remover 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 / enviado alguns arquivos para o seu repositório git e, em seguida, adicione-os 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: confirme todas as suas alterações

Antes de prosseguir, certifique-se de que todas as suas alterações sejam confirmadas, incluindo o seu arquivo .gitignore.

Etapa 2: remover tudo do repositório

Para limpar seu repo, use:

git rm -r --cached .
  • rm é o comando de remoção
  • -r permitirá a remoção recursiva
  • –Cached só irá remover arquivos do índice. Seus arquivos ainda estarão lá.

O comando rm pode ser implacável. Se você quiser experimentar o que ele faz de antemão, adicione o --dry-run -n ou --dry-run para testar as coisas.

Passo 3: Re adicionar tudo

git add .

Etapa 4: confirmar

git commit -m ".gitignore fix"

Seu repositório está limpo :)

Empurre as alterações para o seu controle remoto para ver as mudanças efetivas lá também.

Existe um arquivo que estava sendo rastreado pelo git , mas agora o arquivo está na lista .gitignore .

No entanto, esse arquivo continua aparecendo no git status depois de ser editado. Como você força o git a esquecer completamente?


O que não funcionou para mim

(Sob o Linux), eu queria usar os posts aqui sugerindo ls-files --ignored --exclude-standard | xargs git rm -r --cached ls-files --ignored --exclude-standard | xargs git rm -r --cached abordagem em ls-files --ignored --exclude-standard | xargs git rm -r --cached . No entanto, (alguns dos) arquivos a serem removidos tinham uma nova linha incorporada / LF / \n em 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

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

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

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

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

EDIT: Fui solicitado a adicionar que --- como qualquer comando git rm --- isso deve ser seguido por um commit para tornar as remoções permanentes, por exemplo, git commit -am "Remove ignored files" .


A resposta de Matt Fear foi a mais eficaz IMHO. A seguir, há apenas um script do PowerShell para os usuários do Windows removerem apenas os arquivos do repositório do git que correspondem à 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 .

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

Primeiro:

git rm -r --cached . 
git add .

Então:

git commit -am "Remove ignored files"

Eu consegui isso usando git filter-branch . O comando exato que usei foi retirado da página man:

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 commits, executando git rm antes de cada commit e assim irá se livrar do arquivo especificado. Não se esqueça de fazer o backup antes de executar o comando, pois ele será perdido.


Eu gostei da resposta de JonBrave, mas eu tenho diretórios de trabalho bagunçados o suficiente que cometem - me assusta um pouco, então aqui está o que eu fiz:

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

quebrando:

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
  • stage .gitignore e os arquivos que você acabou de remover
  • cometer

Faça os seguintes passos em série, você vai ficar bem.

1. remova os arquivos adicionados por engano do diretório / armazenamento . Você pode usar o comando "rm -r" (para linux) ou apagá-los, navegando pelos diretórios.

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

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

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

4. Agora faça um commit e push , use esses comandos. Isso irá remover esses arquivos do git remote e fazer o git stop rastrear esses arquivos.

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

Mova ou copie o arquivo para um local seguro, para não perdê-lo. Então git rm o arquivo e commit. O arquivo ainda será exibido se você reverter para uma das confirmações anteriores ou outra ramificação em que não foi removida. No entanto, em todos os commits futuros, você não verá o arquivo novamente. Se o arquivo está no git ignore, então você pode movê-lo de volta para a pasta, e o git não o verá.


O BFG é projetado especificamente para remover dados indesejados, como arquivos grandes ou senhas do Git repos, então ele tem um sinalizador simples que removerá qualquer arquivo grande histórico (não em seu commit atual): '- blip-blobs- maior que'

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

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

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

O BFG é 10-1000x mais rápido do que o git filter-branch, e geralmente é muito mais fácil de usar - verifique as instruções completas de uso e examples para mais detalhes.

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


Se você não pode git rm um arquivo rastreado porque outras pessoas podem precisar dele (aviso, mesmo se você git rm --cached , quando alguém recebe essa mudança, seus arquivos serão apagados em seu sistema de arquivos). Geralmente, isso ocorre devido a substituições de arquivos de configuração, credenciais de autenticação, etc. Consulte https://gist.github.com/1423106 para https://gist.github.com/1423106 como as pessoas lidaram com o problema.

Para resumir:

  • Faça com que seu aplicativo procure por um arquivo ignorado config-overide.ini e use-o sobre o arquivo commit.ini (ou alternativamente, procure por ~ / .config / myapp.ini ou $ MYCONFIGFILE)
  • Confirme o arquivo config-sample.ini e ignore o arquivo config.ini, tenha um script ou cópia semelhante do arquivo conforme necessário, se necessário.
  • Tente usar gitattributes clean / smudge magic para aplicar e remover as alterações para você, 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 implementação dedicada a ele que nunca é mesclada ao mestre. Quando você deseja implantar / compilar / testar, você mescla a essa ramificação e obtém esse arquivo. Esta é essencialmente a abordagem borrar / limpar, exceto usando políticas de mesclagem humana e módulos extra-git.
  • Anti-recommentação: não use assumir-inalterado, só vai acabar em lágrimas.

mova-o para fora, comprometa-o e volte a colocá-lo. Isso funcionou para mim no passado. Há provavelmente uma maneira mais “engenhosa” de realizar isso.


.gitignore impedirá que arquivos não rastreados sejam adicionados (sem um add -f ) ao conjunto de arquivos rastreados pelo git, entretanto o git continuará a rastrear quaisquer arquivos que já estejam sendo rastreados.

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

git rm --cached <file>

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


git update-index faz o trabalho para mim:

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

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

edit: Desde que esta resposta foi publicada, uma nova opção foi criada e deve ser preferida. Você deve usar --skip-worktree que é para arquivos rastreados modificados que o usuário não deseja mais confirmar e manter --assume-unchanged para desempenho para evitar que o git verifique o status de grandes arquivos rastreados. Veja https://.com/a/13631525/717372 para mais detalhes ...


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, remove-os do índice e, em seguida, confirma as alterações.





git-rm