Como usar o .gitignore: Uma introdução prática com exemplos

Sintaxe de .gitignore

Conforme mencionado, os arquivos .gitignore contêm padrões que são comparados com os nomes de arquivos no seu repositório para determinar se eles devem ou não ser ignorados.

Sintaxe básica

Em sua essência, o arquivo .gitignore consiste em linhas, cada uma representando um padrão a ser ignorado. Os padrões podem corresponder:

• Arquivos específicos
• Tipos de arquivos
• Diretórios 

O arquivo também suporta comentários, que podem ser adicionados iniciando uma linha com #, e linhas em branco para melhorar a legibilidade.

Aqui está uma visão geral da estrutura básica:

• Ignorar um arquivo específico: Você pode listar o nome do arquivo diretamente para ignorá-lo.

secrets.txt

• Ignorar um diretório inteiro: Ao adicionar um / no final do nome do diretório, você pode ignorar tudo o que estiver dentro desse diretório.

logs/

• Ignorar todos os arquivos de um tipo específico: Os curingas (*) podem ser usados para ignorar todos os arquivos com uma extensão específica.

*.py

• Negação: Você pode usar ! para negar um padrão e rastrear explicitamente determinados arquivos ou diretórios que, de outra forma, seriam ignorados.

*.txt  # Ignores all .txt files
!readme.txt  # Except for readme.txt

Como criar e usar um arquivo .gitignore

Criar e usar o site .gitignore é bastante simples. Nesta seção, examinarei as etapas.

Criando um arquivo .gitignore

Etapa 1: Navegue até a raiz do seu repositório. O arquivo .gitignore é normalmente colocado no diretório raiz de um projeto Git. Abra o terminal ou a linha de comando e navegue até o diretório raiz do seu repositório Git:

cd /path/to/your/repo

Etapa 2: Crie o arquivo .gitignore. Uma vez no diretório raiz, crie o arquivo .gitignore usando qualquer editor de texto ou executando um comando no terminal, como, por exemplo, " ":

touch .gitignore

Etapa 3: Adicione padrões ao arquivo. Abra o arquivo .gitignore em um editor de texto e adicione os padrões necessários para ignorar arquivos ou diretórios. Cada linha representa um padrão diferente.

Aqui está um exemplo de arquivo .gitignore comumente usado em um projeto básico:

# Ignore node_modules and dependency directories
node_modules/
vendor/

# Ignore build artifacts
dist/
build/
*.log

# Ignore system-generated files
.DS_Store
Thumbs.db

# Ignore environment and secret files
.env
config.json

Quando você tiver adicionado os padrões necessários, salve o arquivo. Agora, o Git ignorará automaticamente esses arquivos ao preparar ou fazer o commit das alterações.

Etapa 4: Faça o commit do arquivo no repositório. É importante que você envie o arquivo .gitignore para o repositório para que todos os colaboradores usem as mesmas regras de ignorar. Isso garante a consistência em todo o projeto para todos os envolvidos.

git add .gitignore
git commit -m "Add .gitignore file"
git push

Depois que o arquivo .gitignore for confirmado, você estabelecerá regras de ignorar compartilhadas para toda a equipe.

Você quer dominar o push e o pull no Git? Saiba como sincronizar seu trabalho com repositórios remotose neste tutorial de push e pull do Git.

Práticas recomendadas para usar o .gitignore

Embora a criação de um arquivo .gitignore seja uma parte simples da manutenção de um repositório Git limpo, várias práticas recomendadas devem ser seguidas para garantir que o arquivo seja gerenciado de forma eficaz ao longo do tempo.

Use um .gitignore global

Para os desenvolvedores que trabalham em vários projetos, há arquivos específicos que você pode querer excluir de cada repositório, independentemente do tipo de projeto.

Em vez de adicioná-los ao arquivo .gitignore de cada projeto, você pode configurar um .gitignore global que se aplique a todos os repositórios do seu sistema.

Para configurar um arquivo global .gitignore:

• Crie um arquivo .gitignore_global:

touch ~/.gitignore_global

• Adicione padrões para arquivos que você deseja ignorar globalmente, como:

.DS_Store
*.log
/.vscode/
/.idea/

• Defina o Git para usar o site global .gitignore:

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

Aproveite os modelos existentes

Em vez de criar um arquivo .gitignore do zero para cada novo projeto, você pode aproveitar os modelos .gitignore pré-configurados para linguagens, estruturas ou ambientes específicos.

Um dos melhores recursos para esses modelosé o repositório .gitignore oficial do GitHub, onde você pode encontrar arquivos .gitignore adaptados a centenas de linguagens de programação e estruturas.

Revisar o .gitignore regularmente

À medida que os projetos evoluem, pode ser necessário incluir novos arquivos e diretórios no arquivo .gitignore. É importante revisar e atualizar periodicamente seu arquivo para refletir o estado atual de seus projetos.

Alguns cenários em que você pode precisar atualizar o arquivo .gitignore incluem:

• Adotar novas ferramentas ou bibliotecas que geram arquivos adicionais (por exemplo, mudar para um novo sistema de compilação).
• Refatoração ou reorganização de diretórios, o que pode resultar em novos arquivos que devem ser excluídos.
• Remoção de arquivos ou diretórios obsoletos que não fazem mais parte do projeto.

Solução de problemas com o .gitignore

Mesmo depois de configurar um arquivo .gitignore, você pode se deparar com cenários em que arquivos específicos estão sendo rastreados ou em que os padrões não parecem funcionar como esperado. Esta seção abordará duas áreas comuns de solução de problemas e como resolvê-las.

Programa de arquivos já confirmados 

O arquivo .gitignore não se aplica retroativamente a arquivos já confirmados. 

Se você adicionar um padrão a .gitignore depois que determinados arquivos já tiverem sido confirmados, o Git continuará a rastreá-los, mesmo que correspondam ao padrão no arquivo .gitignore.

Para parar de programar arquivos que já foram confirmados, siga estas etapas:

• Remova os arquivos do programa Git: Use o comando git rm para removê-los do repositório e mantê-los em seu diretório de trabalho.

git rm --cached <file_or_directory_name>

• Confirmar as alterações: Depois de remover os arquivos do rastreamento do Git, faça o commit das alterações para garantir que os arquivos não façam mais parte do histórico de controle de versão.

git commit -m "Stop tracking ignored files"

• Envie as alterações para o repositório remoto: Por fim, envie as alterações para o repositório remoto para garantir que os arquivos não sejam mais programados.

git push

Depois de executar essas etapas, o Git deixará de rastrear os arquivos. O arquivo confirmado ainda estará no seu diretório de trabalho, mas será ignorado por futuros commits com base nos seus padrões .gitignore.

Verifique se os padrões estão funcionando 

Às vezes, você pode notar que arquivos específicos que você esperava que fossem ignorados ainda aparecem no status do Git ou estão sendo programados. 

Siga estas etapas para garantir que os padrões do .gitignore estejam funcionando corretamente:

• Verifique o status dos seus arquivos: Use o comando git status para ver quais arquivos estão sendo monitorados pelo Git. Isso ajudará você a verificar se os arquivos ignorados ainda estão listados.

git status

• Verifique se o padrão está correto: Verifique novamente a sintaxe dos padrões do site .gitignore para garantir que eles estejam formatados corretamente. Por exemplo:
• Certifique-se de que você use o caminho correto do diretório (relativo à raiz do repositório).
• Adicione um / para direcionar diretórios específicos e evitar que você rastreie todos os arquivos com nomes semelhantes.

• Atualize o cache: Se você atualizou recentemente o arquivo .gitignore e as alterações não estão sendo aplicadas, o Git pode estar mantendo o cache anterior. Para atualizar o cache, execute o seguinte comando:

git rm -r --cached .
git add .
git commit -m "Refresh .gitignore"

• Verifique se há exceções: Às vezes, um padrão específico em .gitignore pode ser substituído por um padrão mais específico em outra parte do arquivo. Revise suas regras para garantir que não haja padrões conflitantes.

Você está procurando uma referência rápida do Git? Mantenha os comandos essenciais ao alcance de seus dedoscom esta folha de dicas do Git.

Conclusão

Um arquivo .gitignore pode parecer pequeno, mas ele desempenha um papel importante para manter o repositório Git limpo e gerenciável. Ao ignorar arquivos desnecessários - como dependências, artefatos de compilação e arquivos gerados pelo sistema - você garante que seu projeto permaneça organizado e livre de desordem.

Neste tutorial, você aprendeu a criar um arquivo .gitignore, adicionar padrões e aplicar práticas recomendadas para manter seu repositório eficiente. Com essas habilidades, você evitará dores de cabeça com o controle de versão e tornará a colaboração mais fácil para todos na sua equipe.

Se você deseja aprofundar suas habilidades no Git, confira Git Fundamentals para obter um caminho de aprendizagem estruturado. Você também pode explorar cursos práticos, como Foundations of Git e Introduction to GitHub Concepts, para desenvolver uma sólida compreensão do controle de versão e dos fluxos de trabalho de colaboração!