Git: comandos essenciais para desenvolvedores

Preparado para dar um boost seu conhecimento em Git? Então vamos lá!

Benefícios do Git

• Histórico completo e rastreabilidade: o Git registra cada alteração no código, permitindo que você volte a qualquer versão anterior quando preciso. Isso significa que é possível rastrear quem alterou o quê e quando, facilitando identificar a origem de bugs ou revertendo mudanças problemáticas.

• Segurança e integridade: o sistema de versionamento do Git foi construído com foco na segurança do histórico. Cada commit é identificado por um hash criptográfico (SHA-1), garantindo que o histórico de mudanças não seja adulterado sem detecção. Em outras palavras, você pode confiar que o código e seu histórico estão íntegros e protegidos contra alterações inesperadas.

• Colaboração eficiente: com o Git, múltiplos desenvolvedores podem trabalhar em paralelo no mesmo projeto sem pisar no código um do outro. Por meio de branches e merges, cada um desenvolve suas funcionalidades isoladamente e depois integra as contribuições ao projeto principal. O Git facilita a colaboração em equipe, evitando conflitos e consolidando as contribuições de forma organizada.

• Padrão do mercado: Git não é apenas mais uma ferramenta – é o padrão de fato em controle de versão hoje. Plataformas como GitHub, GitLab e Bitbucket adotaram o Git, e praticamente qualquer projeto profissional ou open source utiliza Git para versionamento de código. Ou seja, dominar o Git é praticamente obrigatório para desenvolvedores que querem atuar no mercado atual.

Configuração inicial com git config

# Configurar o nome de usuário
git config --global user.name "Seu Nome"

# Configurar o e-mail do usuário
git config --global user.email "seu-email@exemplo.com"

# Verificar configurações (opcional)
git config --list

# Define 'main' como branch padrão ao iniciar um novo repositório
git config --global init.defaultBranch main

Ciclo de versionamento: do git init ao git log

git init

git add index.html

git commit -m "Adicionar página inicial"

Branches: criação, navegação e merge

git branch minha-feature

git checkout -b minha-feature

git switch minha-feature

git checkout main

git merge minha-feature

• Se a main não teve novos commits desde que a minha-feature foi criada, o Git simplesmente moverá o ponteiro da main (fast-forward), incorporando todos os commits da feature.

• Se houver commits na main no meio do caminho, o Git criará um commit de merge, combinando o histórico das duas branches.

git branch -d minha-feature

Colaboração remota: git remote, git push, git pull, git fetch e pull requests

git clone https://github.com/usuario/nome-do-repo.git

git remote add origin https://github.com/usuario/meu-projeto.git

git push -u origin main

git pull origin main

git push origin minha-feature

Reversão de mudanças: git checkout (restore), git reset e git revert

git restore App.js

git reset HEAD~1

git revert 1a2b3c4

Resolução de conflitos de merge: passo a passo

<<<<<<< HEAD
let mensagem = "Olá do Main";
=======
let mensagem = "Olá do Feature";
>>>>>>> feature

let mensagem = "Olá do Main e Feature"; // combinação das mudanças

git add script.js

git commit -m "Resolve merge conflict entre main e feature"

Dicas extras: git stash, .gitignore e aliases

# Arquivos e pastas a serem ignorados
node_modules/
*.log
.env
.DS_Store

git config --global alias.st status

Boas práticas de versionamento com Git

• Commits atômicos e mensagens descritivas: procure organizar seu trabalho em commits atômicos, ou seja, cada commit deve idealmente conter apenas uma mudança lógica do projeto (uma funcionalidade, uma correção, etc.). Isso facilita rastrear problemas e, se preciso, reverter um commit sem impactar outras partes. Além disso, escreva mensagens de commit claras e concisas, explicando o que aquele commit introduz. Muitos times adotam convenções de mensagem como Commits semânticos (prefixos tipo feat:, fix: antes da descrição) para padronizar o histórico. Ex: feat: adicionar validação de email no cadastro já indica que o commit adiciona uma feature.

• Convenções de branches: mantenha um padrão para nomear e usar branches. Por exemplo, use uma branch principal chamada main (ou develop em certos fluxos) e crie branches de feature com nomes descritivos, como feature/login-page ou branches de correção como bugfix/corrigir-logout. Essa consistência ajuda o time a entender o propósito de cada branch facilmente. Defina também a estratégia de branching do projeto (Git Flow, trunk-based, etc.) de acordo com o contexto, mas evite misturar estilos – siga um modelo para não virar bagunça.

• Integre e sincronize com frequência: não deixe sua branch ficar muito tempo afastada da main. Faça pulls frequentes da branch principal para a sua, ou rebase das alterações principais, de modo a resolver conflitos em doses homeopáticas em vez de tudo de uma vez no final. Da mesma forma, commite e envie suas mudanças regularmente – isso facilita integração contínua e diminui a chance de grandes conflitos ou retrabalho. Lembre: versionamento de código é um esforço coletivo, então mantenha seu código o mais atualizado possível em relação ao do time.

• Cuidado com git push --force: evite forçar push em repositórios compartilhados. O git push --force sobrescreve o histórico remoto com o seu local, o que pode excluir commits que seus colegas fizeram (ou que você fez em outro computador) caso não estejam no seu histórico atual. Essa prática pode causar perda de trabalho e confusão. Se realmente precisar reescrever o histórico (por exemplo, para apagar um segredo exposto ou para arrumar commits bagunçados num projeto pessoal), prefira usar -force-with-lease, que adiciona uma camada de segurança verificando se ninguém mais adicionou commits naquela branch. E sempre avise o time ao forçar um push, para que todos possam se alinhar. Em resumo: não use push forçado na branch principal e só use em branches de feature isoladas se souber exatamente o que está fazendo.

Tabela rápida: resumo dos comandos Git

Conclusão