Jefferson Monteiro

Se você está começando na área de desenvolvimento, provavelmente já ouviu falar em Git. Talvez até tenha sentido aquele frio na barriga quando um colega mencionou "dá um push no repositório" ou "abre um pull request". Pode relaxar, neste guia você vai entender tudo isso do zero, com exemplos práticos e direto ao ponto.

O problema que o Git resolve

Imagine que você está desenvolvendo um sistema sozinho. No meio do caminho, você decide testar uma nova funcionalidade. Ela não funciona como esperado e agora o código está quebrado, mas você não lembra exatamente o que mudou.

Sem Git, você teria que:

Fazer backups manuais de pastas (projeto_v1, projeto_v2_final, projeto_v2_final_MESMO)
Torcer para não sobrescrever nada importante
Trabalhar em equipe se tornaria um caos de arquivos trocados por e-mail

O Git resolve tudo isso. Ele é um sistema de controle de versão que registra cada mudança no seu código, permite voltar a qualquer ponto anterior e viabiliza colaboração entre múltiplos desenvolvedores sem conflitos.

O que é Git, afinal?

Git é um sistema de controle de versão distribuído, criado em 2005 por Linus Torvalds, o mesmo criador do Linux. "Distribuído" significa que cada desenvolvedor tem uma cópia completa do histórico do projeto na própria máquina, não apenas no servidor.

Isso traz vantagens práticas:

Você pode trabalhar offline e sincronizar depois
Se o servidor cair, ninguém perde o histórico
Operações como visualizar histórico são instantâneas (sem precisar de internet)

Git ≠ GitHub. Git é a ferramenta que roda na sua máquina. GitHub, GitLab e Bitbucket são plataformas online que hospedam repositórios Git. É como a diferença entre o Word (programa) e o Google Drive (onde você salva o arquivo).

Instalação

Windows: Baixe em git-scm.com e siga o instalador. O "Git Bash" que vem junto vai te dar um terminal para rodar os comandos.

macOS:

brew install git

Linux (Ubuntu/Debian):

sudo apt update && sudo apt install git

Verifique a instalação:

git --version
# git version 2.43.0

Configure seu nome e e-mail (aparecerão nos seus commits):

git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"

Conceitos fundamentais

Antes de partir para os comandos, entenda os três conceitos centrais do Git:

Repositório (repo)

É a pasta do seu projeto com o histórico completo de alterações. Tecnicamente, é uma pasta normal com uma subpasta oculta .git onde o Git guarda tudo.

Commit

Um commit é um snapshot do seu código em um momento específico. Pense como uma fotografia: cada commit registra exatamente como todos os arquivos estavam naquele instante, junto com uma mensagem descrevendo o que foi feito.

Branch

Uma branch é uma linha independente de desenvolvimento. A branch principal geralmente se chama main (ou master em projetos mais antigos). Quando você quer desenvolver uma nova funcionalidade sem afetar o código estável, cria uma branch nova, trabalha nela, e depois une (merge) de volta.

Primeiros passos: o fluxo básico

1. Iniciando um repositório

Dentro da pasta do projeto:

git init

Isso cria a pasta .git e transforma o diretório em um repositório Git.

2. Verificando o estado

git status

Este é o comando que você vai usar mais. Ele mostra:

Arquivos modificados (ainda não rastreados)
Arquivos prontos para commit (staged)
Branch atual

3. Adicionando arquivos ao stage

O Git tem um conceito chamado staging area (área de preparação). Antes de criar um commit, você decide quais mudanças fazem parte dele:

# Adicionar um arquivo específico
git add src/index.js

# Adicionar todos os arquivos modificados
git add .

Pense no stage como uma mesa de embalagem: você coloca os itens que quer enviar antes de selar a caixa.

Criando um commit

git commit -m "feat(auth): adiciona autenticação JWT na rota de login"

Uma mensagem de commit bem escrita segue o padrão tipo(escopo): mensagem no imperativo.

Anatomia de um commit

feat(auth): adiciona autenticação JWT na rota de login
^^^^ ^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
│    │      └─ mensagem, imperativo, minúsculo, sem ponto final
│    └──────── escopo, onde a mudança acontece (opcional)
└───────────── tipo, o que foi feito

Tipos (Conventional Commits)

Tipo	Quando usar	Exemplo
`feat`	Nova funcionalidade para o usuário	`feat(cart): calcula frete por CEP`
`fix`	Corrige um bug existente	`fix(auth): trata token expirado`
`refactor`	Reestruturação sem nova feature ou correção	`refactor: extrai helper de formatação de datas`
`docs`	Apenas documentação	`docs: descreve variáveis de ambiente`
`test`	Adiciona ou corrige testes	`test(payment): cobre fluxo de estorno`
`chore`	Infraestrutura, dependências, configuração	`chore: atualiza node para v20`
`style`	Formatação, espaços, vírgulas (sem lógica)	`style: aplica prettier no módulo de pedidos`
`perf`	Melhoria de performance	`perf(query): adiciona índice na tabela users`
`ci`	Configuração de pipelines e CI/CD	`ci: adiciona step de lint no GitHub Actions`
`revert`	Reverte um commit anterior	`revert: feat(auth): adiciona OAuth2`

Ruim vs bom

Ruim	Bom
`ajustes`	`fix(cadastro): corrige validação de CPF duplicado`
`WIP`	`feat(produtos): adiciona endpoint de listagem paginada`
`mais mudancas`	`refactor(email): extrai serviço de envio para módulo próprio`
`fix bug`	`fix(checkout): impede pedido sem endereço de entrega`
`update README`	`docs: documenta variáveis de ambiente necessárias`
`tests`	`test(auth): cobre cenário de login com senha incorreta`

Regras essenciais

Imperativo, escreva como uma ordem: adiciona, corrige, remove. Não adicionei nem adicionando.
Minúsculo após os dois pontos: feat: adiciona rota ✅, feat: Adiciona rota ❌
Sem ponto final na linha do título.
Máximo ~72 caracteres na linha de título. Se precisar de mais contexto, use o corpo do commit.
Um commit = uma intenção. Se o diff muda autenticação e estilos de botão, são dois commits. Use git add -p para separar hunks.

5. Vendo o histórico

git log --oneline

Saída:

a3f92c1 Adiciona autenticação JWT na rota de login
7b12e4d Cria estrutura inicial do projeto

Cada commit tem um hash único (aquele código alfanumérico). Com ele você pode voltar a qualquer versão:

# Ver como era um arquivo em um commit específico
git show a3f92c1:src/index.js

# Voltar o projeto inteiro para um commit anterior (cuidado: descarta alterações)
git checkout a3f92c1

Trabalhando com branches

Criando e alternando branches

# Criar e já entrar na branch
git checkout -b feature/sistema-de-pagamento

# Alternativa moderna (Git 2.23+)
git switch -c feature/sistema-de-pagamento

A convenção mais comum é tipo/descricao, como feature/cadastro-usuario, fix/bug-no-login, hotfix/erro-producao.

Fluxo completo com branches

# 1. Está na main, cria branch para nova feature
git switch -c feature/relatorio-pdf

# 2. Trabalha, faz commits normalmente
git add .
git commit -m "Adiciona geração de relatório em PDF"

# 3. Volta para main
git switch main

# 4. Une as alterações
git merge feature/relatorio-pdf

# 5. Branch não é mais necessária, pode deletar
git branch -d feature/relatorio-pdf

Entendendo merge

Quando você faz merge de uma branch na outra, o Git tenta combinar as alterações automaticamente. Na maioria dos casos funciona sem problemas. Quando dois desenvolvedores editam a mesma parte de um arquivo, ocorre um conflito de merge, o Git marca o arquivo e você resolve manualmente qual versão manter.

Repositórios remotos (GitHub)

Até agora tudo ficou na sua máquina. Para publicar o código e colaborar com outros, você precisa de um repositório remoto.

Conectando ao GitHub

Após criar um repositório no GitHub:

# Adicionar o endereço remoto com o apelido "origin"
git remote add origin https://github.com/seu-usuario/seu-repositorio.git

# Enviar sua branch main para o remoto pela primeira vez
git push -u origin main

Os três comandos mais usados com remotos

# Enviar commits locais para o remoto
git push

# Baixar as alterações do remoto e aplicar localmente
git pull

# Clonar um repositório existente para sua máquina
git clone https://github.com/usuario/repositorio.git

Fluxo de trabalho em equipe

# Sempre atualize sua main antes de criar uma branch nova
git switch main
git pull

# Crie sua branch de trabalho
git switch -c feature/nova-funcionalidade

# Desenvolva, faça commits...
git add .
git commit -m "Implementa busca por filtros na listagem"

# Envie sua branch para o remoto
git push -u origin feature/nova-funcionalidade

# Agora você pode abrir um Pull Request no GitHub

Pull Requests na prática

Um Pull Request (PR) é um pedido para integrar o código de uma branch na branch principal. É o mecanismo central de revisão de código em equipes.

Por que PRs existem

Antes de qualquer código ir para main (que normalmente está em produção), outros desenvolvedores têm a chance de:

Revisar a lógica implementada
Sugerir melhorias
Identificar bugs
Garantir que os padrões do projeto foram seguidos

Como criar um PR

Faça push da sua branch: git push -u origin feature/sua-branch
Acesse o repositório no GitHub
Clique em "Compare & pull request" (aparece automaticamente)
Preencha título e descrição explicando o que foi feito e por quê
Solicite revisores e clique em "Create pull request"

Boas práticas para PRs

PRs pequenos são melhores. Um PR com 200 linhas é revisado com atenção. Um com 2.000 linhas é aprovado por cansaço.
A descrição importa. Explique o problema que você está resolvendo, não só o que mudou.
Responda comentários. Um PR é uma conversa, não um monólogo.

Resumo: o fluxo do dia a dia

# Início do dia: atualiza main
git pull

# Cria branch para a tarefa do dia
git switch -c feature/minha-tarefa

# Trabalha... e commita com frequência
git add .
git commit -m "Descrição clara do que foi feito"

# Ao terminar: envia para o remoto
git push -u origin feature/minha-tarefa

# Abre PR no GitHub, aguarda revisão, recebe aprovação, merge feito
# Volta para main e repete
git switch main
git pull

Próximos passos

Dominar esses comandos já te coloca na frente de muitos desenvolvedores. Para aprofundar:

git rebase, alternativa ao merge, mantém histórico linear
git stash, guarda alterações temporariamente sem commitar
git cherry-pick, aplica um commit específico em outra branch
Conventional Commits, convenção para padronizar mensagens de commit

O Git é uma das ferramentas mais importantes da carreira de qualquer desenvolvedor. Quanto mais cedo você se sentir confortável com ele, mais produtivo e confiante você vai ser no dia a dia.