O que é um arquivo .gitignore e como você o usa?

Question

Accepted Answer

Um arquivo **.gitignore** diz ao Git quais arquivos e diretórios **ignorar** — não rastrear no controle de versão. É usado para excluir arquivos gerados, dependências, segredos e arquivos específicos do ambiente que não devem ser commitados.

## O que .gitignore faz

```text
# .gitignore — patterns of files Git should NOT track
node_modules/          # dependencies (reinstalled from package files, don't commit)
dist/                  # build output (generated, don't commit)
*.log                  # log files
.env                   # ⚠️ SECRETS / environment variables — NEVER commit!
.DS_Store              # OS-specific junk
.vscode/               # editor config (often personal)
build/
coverage/
*.tmp
```

Git ignora arquivos que correspondem a esses padrões — eles não aparecerão em `git status`, não serão stagados e não serão commitados.

## Sintaxe de padrões

```text
node_modules/    → ignore a directory (and everything in it)
*.log            → ignore all files with a .log extension
!important.log   → EXCEPTION: do NOT ignore this (negation)
/build           → ignore "build" only in the root (leading slash = root-relative)
doc/*.txt        → .txt files in doc/ but not subdirectories
**/temp          → "temp" anywhere in the tree
```

## O que ignorar (categorias comuns)

```text
✓ DEPENDENCIES — node_modules/, vendor/ (reinstalled from manifests; huge, don't commit)
✓ BUILD OUTPUT — dist/, build/, *.o (generated from source)
✓ SECRETS — .env, credentials, keys (⚠️ NEVER commit secrets — a serious security issue)
✓ ENVIRONMENT/OS/EDITOR files — .DS_Store, .idea/, .vscode/ (personal/machine-specific)
✓ LOGS, caches, temp files
```

```text
⚠️ Already-tracked files aren't ignored by adding them later — untrack first:
   git rm --cached <file>   (then commit; .gitignore prevents re-adding)
```

## Por que isso importa

Compreender `.gitignore` é importante para **manter repositórios limpos e seguros**, portanto é conhecimento Git prático essencial.

Um arquivo `.gitignore` exclui arquivos que **não devem estar no controle de versão**, atendendo a várias necessidades reais.

Mantém repositórios limpos excluindo **arquivos gerados/derivados** (saída de build, artefatos compilados) e **dependências** (`node_modules`, que são enormes e reinstaladas a partir de arquivos de manifesto — commitá-las incharia o repositório) — para que o repositório contenha apenas o código-fonte significativo.

Exclui **arquivos específicos do ambiente e pessoais** (lixo do SO como `.DS_Store`, configurações de editor) que poluiriam o repositório e causariam ruído.

Mais criticamente, é essencial para **segurança**: excluir **segredos** (arquivos `.env`, credenciais, chaves de API) é vital porque **commitar segredos é um erro de segurança grave** — uma vez commitados, os segredos estão no histórico do repositório (e potencialmente enviados para repositórios remotos/públicos onde podem ser explorados), portanto `.gitignore` é uma defesa importante contra commitar dados sensíveis acidentalmente.

Compreender a **sintaxe de padrões** (diretórios, curingas, negação, relativo à raiz) permite que você escreva regras de ignore eficazes, e saber a armadilha importante de que **arquivos já rastreados devem ser derastreados** (`git rm --cached`) antes que `.gitignore` entre em vigor evita uma confusão comum.

Como repositórios limpos (sem arquivos gerados, dependências ou desordem) e especialmente **não commitar segredos** importam para a qualidade e segurança do repositório, e como `.gitignore` é o mecanismo padrão para excluir arquivos que não devem ser rastreados, compreender `.gitignore` — o que ignorar (dependências, saída de build e criticamente segredos), a sintaxe de padrões e a armadilha de derastreamento — é conhecimento Git essencial, frequentemente aplicado para manter repositórios limpos e seguros, sendo o aspecto de segurança de manter segredos fora do controle de versão particularmente importante.