Ao trabalhar com controle de versão Git, é comum haver arquivos que não devem ser incluídos no repositório. Isso pode incluir arquivos de log, arquivos temporários, artefatos de compilação ou configurações locais específicas do ambiente. O Git oferece um mecanismo para gerenciar esses arquivos através do arquivo .gitignore. Este arquivo permite definir padrões de nomes de arquivos e diretórios que o Git deve ignorar automaticamente ao executar comandos como git add ..

Ignorar arquivos é crucial para evitar que informações sensíveis sejam expostas ou que conflitos ocorram quando outros desenvolvedores clonam o projeto. Por exemplo, arquivos de configuração com credenciais de banco de dados ou chaves de API não devem ser versionados.

Existem três abordagens principais para configurar o Git para ignorar arquivos:

1. Arquivo .gitignore no Projeto

Esta é a abordagem mais comum e recomendada. Um arquivo .gitignore é criado na raiz do seu projeto. As regras definidas nele se aplicam a todo o repositório. Este arquivo pode (e deve) ser commitado no repositório, garantindo que todos os colaboradores do projeto sigam as mesmas regras de ignorar arquivos.

As regras são escritas em linhas separadas. Por exemplo:

*.log
*.tmp
/vendor

2. Arquivo .git/info/exclude

Para ignorar arquivos apenas para o seu clone local de um projeto específico, você pode editar o arquivo .git/info/exclude. As regras neste arquivo se aplicam apenas ao seu repositório local e não são compartilhadas com outros desenvolvedores. A raiz de correspondência para as regras aqui é o diretório raiz do projeto.

3. Arquivo .gitignore Global

Você pode configurar um arquivo .gitignore global que se aplica a todos os seus repositórios Git no seu sistema. Isso é útil para ignorar arquivos gerados pelo sistema operacional ou pelo seu editor de código que são comuns em todos os seus projetos. Para configurar isso, crie um arquivo .gitignore em qualquer local (por exemplo, no seu diretório home) e execute o seguinte comando:

git config --global core.excludesfile ~/.gitignore

Este arquivo global não é compartilhado entre desenvolvedores.

Princípios para Ignorar Arquivos

• Ignore arquivos gerados automaticamente pelo sistema operacional (ex: arquivos de miniatura).
• Ignore arquivos intermediários e executáveis de compilação. Se um arquivo é gerado a partir de outro, o arquivo gerado geralmente não precisa ser versionado (ex: arquivos .class em Java).
• Ignore arquivos de configuração que contenham informações sensíveis, como senhas ou chaves de API.

Como Usar o .gitignore

Crie um arquivo chamado .gitignore na raiz do seu diretório de trabalho. Adicione as regras de ignorar um arquivo por linha. Você pode encontrar modelos de arquivos .gitignore para diversas linguagens e ambientes no GitHub (por exemplo, para Java, Python, Node.js).

Um exemplo simples de .gitignore:

# Ignora todos os arquivos XML, LOG e APK
*.xml
*.log
*.apk

O caractere # no início da linha indica um comentário.

Prioridade das Regras de Ignorar

O Git avalia as regras de ignorar em uma ordem específica:

1. Regras de ignorar definidas na linha de comando.
2. Regras em arquivos .gitignore em diretórios atuais.
3. Regras em arquivos .gitignore em diretórios pais (recursivamente).
4. Regras no arquivo .git/info/exclude do repositório local.
5. Regras no arquivo .gitignore global especificado por core.excludesfile.

Sintaxe das Regras de Ignorar

As regras no arquivo .gitignore seguem a sintaxe de padrões glob (semelhante à do shell):

• Espaços em branco: Não correspondem a nenhum caractere de arquivo, a menos que sejam escapados com uma barra invertida (\).
• Comentários: Linhas que começam com # são ignoradas.
• Padrões Glob: Permitem corresponder a nomes de arquivos e diretórios.
• Diretórios: Um padrão com / no início corresponde a um diretório a partir da raiz do projeto. Um padrão com / no final corresponde a um diretório e seu conteúdo.
• *: Corresponde a zero ou mais caracteres.
• **: Corresponde a zero ou mais diretórios intermediários. Ex: a/**/z corresponde a a/z, a/b/z, a/b/c/z.
• ?: Corresponde a um único caractere.
• []: Define um conjunto de caracteres a serem correspondidos. Ex: [abc] corresponde a 'a', 'b' ou 'c'. [0-9] corresponde a qualquer dígito.
• !: Negação. Um padrão precedido por ! significa que o arquivo ou diretório correspondente *não* deve ser ignorado, mesmo que corresponda a uma regra anterior. No entanto, se um diretório pai já foi ignorado, um padrão de negação para um arquivo dentro desse diretório não terá efeito.

É importante notar que o Git processa as regras de cima para baixo. Se uma regra mais abrangente for encontrada primeiro, regras posteriores que tentam incluir um arquivo específico dentro dessa área podem não funcionar se o diretório pai já foi completamente ignorado.

Exemplos de Regras

# Ignora todos os arquivos .log
*.log

# Ignora o arquivo TODO apenas na raiz do projeto
/TODO

# Ignora todo o conteúdo do diretório build
build/

# Ignora arquivos .txt dentro do diretório doc, mas não em subdiretórios
doc/*.txt

# Ignora o diretório bin e todo o seu conteúdo
bin/

# Ignora arquivos .c apenas na raiz do projeto
/*.c

# Ignora arquivos .obj no diretório debug, mas não em subdiretórios
debug/*.obj

# Ignora arquivos foo em qualquer nível de subdiretório
**/foo

# Ignora arquivos b a partir de a, em qualquer nível de subdiretório
a/**/b

# Não ignora o arquivo run.sh dentro do diretório bin
!/bin/run.sh

# Ignora arquivos .zip
*.zip

# Ignora o arquivo one.txt dentro do diretório mtk
/mtk/one.txt

# Ignora todo o conteúdo de /mtk/, exceto one.txt
/mtk/*
!/mtk/one.txt

Resolvendo Problemas com .gitignore

Se você adicionou arquivos ao Git antes de criar ou modificar o .gitignore, esses arquivos continuarão sendo rastreados. O .gitignore só afeta arquivos que ainda não foram rastreados pelo Git.

Para resolver isso, você precisa remover os arquivos do cache do Git:

# Remove todos os arquivos do cache
git rm -r --cached .

# Adiciona todos os arquivos novamente (incluindo os ignorados corretamente agora)
git add .

# Commita as alterações
git commit -m "Update .gitignore"

# Envia para o repositório remoto
git push

Se um arquivo já foi enviado para o repositório remoto e você deseja parar de rastreá-lo:

# Remove o arquivo do cache do Git
git rm --cached path/to/your/file

# Commita a remoção
git commit -m "Stop tracking file"

# Envia para o repositório remoto
git push

Verificando Regras de Ignorar

Você pode usar o comando git check-ignore para verificar qual regra está ignorando um determinado arquivo:

git check-ignore -v nome_do_arquivo

Exemplo de .gitignore para Java

Um exemplo comum para projetos Java:

# Compiled class file
*.class

# Log file
*.log

# BlueJ files
*.ctxt

# Mobile Tools for Java (J2ME)
.mtj.tmp/

# Package Files
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar

# virtual machine crash logs
hs_err_pid*

Estados dos Arquivos no Git

É útil entender os diferentes estados dos arquivos em um repositório Git:

• Untracked (Não Rastreado): Arquivos novos que ainda não foram adicionados ao Git.
• Unmodified (Não Modificado): Arquivos que foram adicionados e não sofreram alterações desde o último commit.
• Modified (Modificado): Arquivos que foram alterados desde o último commmit, mas ainda não foram adicionados ao stage.
• Staged (Preparado): Aruqivos que foram adicionados ao stage (usando git add) e estão prontos para serem commitados.

Untracked refere-se a arquivos completamente novos. Not staged (ou Unmodified, dependendo do contexto) refere-se a arquivos que já estão sendo rastreados, mas foram modificados e ainda não foram adicionados ao stage.