Ignorando arquivos com Gitignore

Introdução

Durante o desenvolvimento de software, a pasta do projeto pode ficar cheia de arquivos que não deveriam ser compartilhados. Entre eles, estão:

• Arquivos temporários: gerados pelo editor ou pelo sistema operacional, como .DS_Store.
• Artefatos de compilação: código compilado, como .exe e .class.
• Logs: arquivos que registram a execução do programa, como debug.log.
• Segredos: chaves de API ou senhas (NUNCA faça commit desses arquivos!).

O Git oferece um recurso chamado .gitignore. Ele é uma lista simples de regras que definem o que não deve ser rastreado. Quando um arquivo corresponde a uma regra dessa lista, o Git o deixa sem rastreamento por padrão.

Esse arquivo funciona como um mecanismo de política para a árvore de trabalho. Ele informa ao Git quais arquivos sem rastreamento devem ser tratados como arquivos secundários normais, e não como possíveis arquivos-fonte para adicionar.

Isso não serve apenas para manter tudo organizado. Um bom .gitignore ajuda a evitar ruído, repositórios grandes demais e commits acidentais de segredos ou arquivos específicos da máquina.

Neste laboratório, você vai:

1. Criar um arquivo de “lixo” que queremos ignorar.
2. Configurar um arquivo .gitignore.
3. Verificar se o Git ignora corretamente o arquivo de lixo.

Criar um arquivo de log

Primeiro, crie um arquivo que represente dados de “lixo”. Imagine que seu aplicativo gere um arquivo de log sempre que é executado. Queremos manter esse arquivo na máquina local para depuração, mas não queremos compartilhá-lo com a equipe nem salvá-lo no histórico.

Navegue até o diretório do projeto:

cd ~/project

Crie um arquivo chamado debug.log com um conteúdo de exemplo:

echo "System started at $(date)" > debug.log

Verifique se o arquivo existe:

ls

Neste momento, se você executar git status, o Git verá esse arquivo como “Untracked” e continuará sugerindo que você o adicione.

Esse é o comportamento normal para arquivos que o Git detecta, mas que ainda não estão sendo ignorados. Na prática, o Git está perguntando se o arquivo deve passar a fazer parte do repositório.

Criar o arquivo .gitignore

Para informar ao Git que ele deve ignorar determinados arquivos, precisamos de um arquivo de configuração especial chamado .gitignore.

Crie o arquivo na raiz do projeto:

touch .gitignore

Verifique se ele foi criado. Lembre-se de que ele fica oculto porque começa com um ponto:

ls -a

O arquivo .gitignore é apenas um arquivo de texto simples. Normalmente, você deve fazer commit do próprio arquivo .gitignore, para que todas as pessoas da equipe compartilhem as mesmas regras de ignorância.

Essa é uma distinção importante: os arquivos ignorados geralmente são artefatos locais, enquanto o próprio .gitignore normalmente é uma configuração do projeto e deve fazer parte do controle de versão.

Configurar as regras de ignorância

Agora, adicione uma regra para ignorar todos os arquivos de log.

Você pode usar o curinga * para indicar “qualquer coisa que termine com .log”.

Adicione o padrão *.log ao arquivo .gitignore:

echo "*.log" > .gitignore

Verifique o conteúdo do arquivo:

cat .gitignore

Saída:

*.log

Essa única linha informa ao Git: “Ignore qualquer arquivo neste diretório e em qualquer subdiretório cujo nome termine com .log”.

As regras de ignorância são baseadas em padrões, e não são instruções válidas para apenas um arquivo. Por isso, um arquivo .gitignore curto pode gerenciar várias categorias de arquivos gerados ou indesejados.

Verificar o status de ignorância

Vamos testar se a regra está funcionando.

Execute git status:

git status

Analise a saída:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
    .gitignore

Espere! Onde está debug.log?

Ele desapareceu da lista! Isso significa que o Git está ignorando o arquivo corretamente. O Git está informando apenas sobre o próprio .gitignore (que futuramente devemos incluir em um commit), enquanto debug.log está invisível para o Git.

Essa é a diferença prática entre sem rastreamento e ignorado. Os arquivos sem rastreamento continuam sendo sugeridos para adição, enquanto os arquivos ignorados são excluídos intencionalmente dessa verificação.

Se quiser ter certeza absoluta, use o comando check-ignore para perguntar: “Por que este arquivo está sendo ignorado?”:

git check-ignore -v debug.log

Saída:

.gitignore:1:*.log debug.log

Isso significa: “O arquivo debug.log é ignorado por causa da regra *.log, na linha 1 de .gitignore”.

Resumo

Neste laboratório, você aprendeu a manter o repositório limpo.

Principais aprendizados:

1. .gitignore: um arquivo de texto que lista padrões de arquivos que o Git deve ignorar.
2. Curingas: use * para corresponder a vários arquivos, como *.log.
3. Sem rastreamento vs. ignorado: um arquivo ignorado é tratado como se não existisse pelo Git, embora continue existindo no disco.

Esse arquivo simples é muito poderoso. Ele evita que você faça commit acidentalmente de arquivos temporários, binários ou chaves confidenciais, mantendo o projeto profissional e seguro.