Git do zero ao deploy: o guia sem frescura para…

💡 TL;DR (Resumo)

Git é uma máquina do tempo para seu código. Neste guia prático você aprende: criar seu primeiro repositório, fazer commits com propósito, usar branches com segurança, desfazer erros sem pânico, e finalmente preparar tudo para o seu primeiro deploy. Sem teoria acadêmica, sem interface gráfica, só o que funciona de verdade.

Se você ainda tem medo de git, não é porque você é "ruim". É porque provavelmente te ensinaram do jeito errado.

Neste artigo, você vai aprender Git do zero até o primeiro deploy, do jeito que dev usa no dia a dia — sem frescura, sem teoria vazia e com exemplos que você pode copiar e colar.

Vamos passar por:

O que é Git (sem blablablá acadêmico)
Seus primeiros commits
Branches do jeito certo
Voltando no tempo sem perder tudo
Preparando o terreno para um fluxo de deploy decente

1. O que é Git de verdade (e por que você deveria ligar pra isso)

Esquece a frase "Git é um sistema de controle de versão distribuído".

Na prática, Git é:

Uma máquina do tempo para o seu código, que permite você e seu time trabalharem juntos sem pisar um no pé do outro (pelo menos não o tempo todo).

Com Git você pode:

Ver o que mudou, quando e por quem
Voltar versões de arquivo ou do projeto inteiro
Trabalhar em várias features ao mesmo tempo com branches
Testar ideias arriscadas sem destruir o código estável

Quem domina Git:

Resolve problemas que travam o time
Salva código "perdido"
Evita apagar trabalho dos outros

Ou seja: parece detalhe técnico, mas Git impacta diretamente sua imagem de dev.

2. Começando de verdade: seu primeiro repositório

Vamos criar um repositório local e fazer seu primeiro commit.

bash

mkdir meu-projeto-git
cd meu-projeto-git

git init

Isso cria uma pasta .git que é onde a mágica acontece.

Agora crie um arquivo simples:

bash

echo "console.log('Olá Git!')" > index.js

Veja o status do repo:

bash

git status

Você verá algo como:

text

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        index.js

Adicionando arquivos e fazendo o primeiro commit

Adicionar o arquivo à "área de stage":

bash

git add index.js

Registrar o commit:

bash

git commit -m "feat: primeiro commit do projeto"

Conferir o histórico:

bash

git log --oneline

Parabéns, você acabou de criar o primeiro ponto da sua máquina do tempo.

3. Commits pequenos, você grande

Se você guardar tudo num commit só, você está usando Git como se fosse um pendrive glorificado.

Boas práticas:

Commits pequenos e focados
Cada commit responde: "o que foi feito?" e, quando necessário, "por quê?"
Nada de "ajustes", "teste", "agora vai"

Exemplo ruim:

bash

git commit -m "ajustes finais"

Exemplo bom:

bash

git commit -m "fix: corrige cálculo do desconto na tela de checkout"

Lembrete importante:

Git não é backup. Git é histórico de decisão.

4. Usando `.gitignore` pra não virar meme no time

Todo dev já comitou algo que não devia: node_modules, .env, arquivo de log enorme…

Use um arquivo .gitignore na raiz do projeto pra dizer ao Git o que deve ser ignorado:

gitignore

node_modules/
dist/
.env
*.log
.idea/
.vscode/

Depois disso, o Git vai fingir que esses arquivos nem existem.

Dica: gere .gitignore pronto para sua stack em sites como gitignore.io ou presets do GitHub.

5. Branches: pare de viver perigosamente na `main`

Se você faz tudo direto na main, você não é rápido, você é corajoso demais.

Fluxo saudável:

main (ou master) sempre estável
Nada de testar coisa louca direto em main
Cada feature/bugfix em uma branch separada

Criando uma branch:

bash

git checkout -b feature/tela-login

Voltando pra main:

bash

git checkout main

Mesclando sua feature na main (merge simples):

bash

git checkout main
git pull origin main   # atualiza

# depois que sua feature estiver revisada e aprovada

git merge feature/tela-login

Branches são baratas. Deploy quebrado é caro.

6. Voltando no tempo sem quebrar tudo

Ver o que mudou antes de commitar

Sempre revise antes de registrar o commit:

bash

git diff          # tudo que mudou

git diff --staged # só o que foi adicionado com git add

Isso evita:

Commitar console.log perdido
Mandar .env pra produção
Subir arquivo temporário no repo

Desfazendo mudanças em um arquivo específico

Git mais novo:

bash

git restore caminho/do/arquivo

Git mais antigo:

bash

git checkout HEAD -- caminho/do/arquivo

Isso volta só aquele arquivo para o último commit.

7. Trabalhando com remoto (GitHub, GitLab, etc.)

Vamos conectar seu repo local a um remoto (por exemplo, no GitHub):

Crie um repositório vazio no GitHub
Copie a URL (HTTPS ou SSH)
No seu projeto local, rode:

bash

git remote add origin [email protected]:usuario/meu-projeto-git.git

git branch -M main

git push -u origin main

Agora sua main está sincronizada com o remoto.

Sempre que fizer novas alterações:

bash

git add .
git commit -m "feat: adiciona tela de perfil"
git push

8. Stash: pausa rápida sem bagunça

Está no meio de uma coisa e alguém pede pra corrigir um bug urgente?

Em vez de sair committando qualquer coisa:

bash

git stash        # guarda suas mudanças locais
# resolve o bug

git stash pop    # traz suas mudanças de volta

É tipo um CTRL+Z organizado.

9. Checklist de Git para o seu dia a dia

Se você fizer só isso, já estará acima da média:

Usar git status e git diff antes de cada commit
Ter um .gitignore decente desde o início
Nunca trabalhar direto na main em projeto sério
Usar branches por feature/bugfix
Escrever mensagens de commit que façam sentido
Revisar antes de dar git push

10. Próximos passos: ficando realmente perigoso (no bom sentido)

Pra sair do básico e começar a virar "o(a) dev do Git" no seu time, estude:

git rebase (para histórico mais limpo)
git revert (pra desfazer sem esconder)
git reflog (pra recuperar coisa "perdida")
git bisect (pra descobrir qual commit quebrou tudo)
Hooks e aliases (pra automatizar boas práticas)

Nos próximos artigos, vamos aprofundar nesses temas.

Enquanto isso, se este artigo te ajudou:

Salva pra revisar depois
Compartilha com aquele(a) amigo(a) que ainda tem medo de Git
E continua acompanhando as #gittips ;)

Git do zero ao deploy: o guia sem frescura para devs modernos

✨TL;DR / Sumário Executivo

💡 TL;DR (Resumo)

1. O que é Git de verdade (e por que você deveria ligar pra isso)

2. Começando de verdade: seu primeiro repositório

Adicionando arquivos e fazendo o primeiro commit

3. Commits pequenos, você grande

4. Usando `.gitignore` pra não virar meme no time

5. Branches: pare de viver perigosamente na `main`

6. Voltando no tempo sem quebrar tudo

Ver o que mudou antes de commitar

Desfazendo mudanças em um arquivo específico

7. Trabalhando com remoto (GitHub, GitLab, etc.)

8. Stash: pausa rápida sem bagunça

9. Checklist de Git para o seu dia a dia

10. Próximos passos: ficando realmente perigoso (no bom sentido)

Receba novos artigos