Git do zero

Um histórico do projeto que você pode consultar e desfazer: commits, staging, branches e o pull request.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Explicar a diferença entre pasta de trabalho, staging e histórico
  • Fazer commits pequenos com mensagens úteis
  • Criar uma branch, juntar mudanças e resolver um conflito simples
  • Publicar o repositório no GitHub e abrir um pull request

Se você já salvou um trabalho como projeto-final.html, depois projeto-final-2.html e por fim projeto-final-AGORA-VAI.html, você já sentiu o problema que o Git resolve. Com ele, cada versão do projeto fica guardada com data, autoria e uma explicação, e você volta a qualquer uma quando quiser. Praticamente toda empresa de tecnologia usa Git, e saber usá-lo é uma das primeiras coisas que perguntam numa vaga.

Chega de projeto-final-AGORA-VAI

Copiar arquivos com nomes diferentes até funciona, mas logo ninguém sabe qual é o certo nem o que mudou entre um e outro. O Git guarda todas as versões numa pasta escondida, sem bagunçar a sua, e responde perguntas como “o que mudou desde ontem?” e “quem escreveu esta linha?”.

Git
Um programa gratuito que roda no seu computador e registra a história do projeto. Funciona sem internet.
Repositório
Uma pasta de projeto que o Git está acompanhando, junto com todo o histórico dela. O apelido é repo.
Commit
Um ponto de salvamento: uma foto do projeto num momento, com uma mensagem explicando o que mudou.
GitHub
Um site que guarda cópias de repositórios na internet, para fazer backup, mostrar seu trabalho e colaborar. Existem alternativas, como GitLab e Bitbucket.

Uma colega diz: “Não consigo usar Git porque estou sem internet hoje”. Ela tem razão?

  • Não. O Git roda no computador dela; só enviar para o GitHub precisa de internet
  • Sim. Git é um site e precisa de conexão
  • Sim. Cada commit é enviado na hora para a nuvem

As três áreas do Git

Cada parte da encomenda tem um nome no Git
Na encomendaNo GitO que é
A mesaPasta de trabalhoOs arquivos como estão agora, que você edita no VS Code
A caixa abertaStagingA área de preparação: as mudanças escolhidas para o próximo commit
Caixas lacradas na prateleiraHistóricoOs commits guardados no repositório, no seu computador
O depósito em outra cidadeGitHubUma cópia do repositório na internet, chamada de remoto

Uma mudança viajando pelas áreas do Git

  1. Pasta → Pasta: Edita index.html. Você muda o título da página e salva. O Git percebe que o arquivo está diferente do último commit, mas ainda não guarda nada.
  2. Pasta → Staging: git add index.html. Você coloca essa mudança na caixa. Só o que passa pelo staging entra no próximo commit, então dá para escolher o que vai junto.
  3. Staging → Histórico: git commit -m "...". A caixa é lacrada com uma mensagem. Agora existe um ponto de salvamento no histórico, no seu computador.
  4. Histórico → GitHub: git push. Você envia os commits novos para o GitHub. Agora existe uma cópia na internet, que outras pessoas podem ver.
  5. GitHub → Histórico: git pull. Uma colega enviou commits dela para o GitHub. Com git pull, você traz esses commits para o seu histórico.
  6. Histórico → Pasta: Arquivos atualizados. Junto com o pull, sua pasta de trabalho é atualizada com as mudanças dela. Você continua trabalhando a partir daí.

Você editou index.html, salvou e rodou git commit -m "Muda título", sem usar git add. O que acontece?

  • O Git avisa que não há nada preparado para o commit
  • O commit é feito com todas as mudanças
  • A mudança vai direto para o GitHub
  • O arquivo é apagado

Seu primeiro repositório

Tudo isso acontece no terminal que você conheceu na aula anterior. Primeiro, instale o Git pelo site git-scm.com. No Windows, ele vem com um terminal próprio, o Git Bash. Depois, entre na pasta do projeto com cd e siga os passos.

  1. Apresente-se ao Git (só uma vez por computador)

    Cada commit leva nome e e-mail de quem fez. Use o mesmo e-mail da sua conta no GitHub.

    git config --global user.name "Ana Souza"
    git config --global user.email "ana@exemplo.com"
  2. Transforme a pasta num repositório

    Rode dentro da pasta do projeto. O Git cria uma pasta escondida chamada .git, onde guarda o histórico. Não mexa nela.

    git init -b main
  3. Pergunte como estão as coisas

    git status mostra o que mudou e o que está no staging. Use sempre que estiver em dúvida: ele nunca altera nada.

    git status
  4. Coloque as mudanças no staging

    Escolha um arquivo pelo nome, ou use o ponto para incluir tudo o que mudou na pasta.

    git add index.html
    # ou, para tudo:
    git add .
  5. Faça o commit

    O -m vem de mensagem. Escreva entre aspas o que esse commit faz.

    git commit -m "Cria página inicial com título e parágrafo"
  6. Veja o histórico

    Cada linha é um commit, com um código de identificação e a mensagem. O mais recente aparece primeiro.

    git log --oneline

O que o git status mostra depois de editar um arquivo

git status
On branch main
Changes not staged for commit:
  modified:   index.html

no changes added to commit (use "git add")

Complete a sequência: criar o repositório, conferir o estado, preparar todos os arquivos, fazer o commit e ver o histórico.

git ____ -b main
git ____
git ____ .
git ____ -m "Primeira versão da página"
git ____ --oneline

Commits pequenos, mensagens úteis

Um bom commit faz uma coisa só e diz qual coisa é. Daqui a três meses, você ou outra pessoa vai ler o histórico procurando quando algo quebrou. Mensagens como “ajustes” não ajudam ninguém.

Uma regra prática: a mensagem completa a frase “Este commit vai...”. “Adiciona formulário de contato” funciona. “Mexi em umas coisas” não funciona.

Quais mensagens de commit ajudam quem lê o histórico depois?

Mensagem útil · Mensagem ruim

  • Adiciona formulário de contato na página inicial
  • Corrige link quebrado do cardápio
  • Aumenta contraste do texto do rodapé
  • Remove imagem duplicada da galeria
  • ajustes
  • agora vai
  • asdfgh
  • Muda cores, cria página sobre, corrige formulário e troca fonte

Um .gitignore simples, na raiz do projeto

# Segredos: nunca vão para o repositório
.env

# Pastas geradas por ferramentas
node_modules/
dist/

# Arquivos do sistema
.DS_Store
Você fez commit de uma senha, percebeu e apagou o arquivo num commit seguinte. Está resolvido?

Não. A senha continua visível em qualquer commit antigo, e se já houve push, pode ter sido copiada. O certo é trocar a senha imediatamente e considerar a antiga perdida. Por isso o .gitignore vem antes do primeiro commit.

Branches, merge e conflitos

A branch principal se chama main. Para cada tarefa nova você cria uma branch, faz seus commits nela e, no fim, junta tudo de volta na main. Juntar uma branch na outra se chama merge (mesclar).

Criar uma branch, trabalhar nela e juntar na main

# cria a branch e já entra nela
git switch -c titulo-novo

# edita, depois:
git add index.html
git commit -m "Troca título da página inicial"

# volta para a main e junta as mudanças
git switch main
git merge titulo-novo

Na maioria das vezes o Git junta tudo sozinho. Mas se as duas branches mudaram a mesma linha de jeitos diferentes, ele não sabe qual escolher e para tudo para perguntar a você. Isso é um conflito. Não é um erro grave: é o Git sendo cuidadoso.

Como um conflito aparece dentro do arquivo

<h1>
<<<<<<< HEAD
Padaria Pão Quente
=======
Padaria Pão Quente: desde 1998
>>>>>>> titulo-novo
</h1>
  • Início do conflito: Daqui até a divisória está a versão da branch onde você está agora. HEAD é o nome que o Git dá para “onde você está”, nesse caso a main.
  • A sua versão: O conteúdo que já estava na main.
  • Divisória: Separa as duas versões. Acima, a sua; abaixo, a que está chegando.
  • A versão que está chegando: O conteúdo da branch que você pediu para juntar.
  • Fim do conflito: Marca o fim do trecho em disputa, com o nome da branch de onde veio a outra versão.

Para resolver, você edita o arquivo e deixa o texto do jeito final: pode ficar com uma versão, com a outra ou misturar as duas. Depois apaga as três linhas de marcação, salva, roda git add no arquivo e faz um commit. O VS Code mostra botões para ajudar nessa escolha.

Você resolveu o conflito escolhendo o título “Padaria Pão Quente: desde 1998”. Como o trecho deve ficar antes do commit?

  • Só <h1>Padaria Pão Quente: desde 1998</h1>, sem nenhuma linha de marcação
  • As duas versões, mantendo ======= entre elas
  • Basta rodar git commit; o Git escolhe a versão mais nova
  • É preciso apagar a branch titulo-novo e começar de novo

GitHub e o pull request

Até aqui tudo ficou no seu computador. Para ter um backup, mostrar seu trabalho em entrevistas e colaborar, você envia o repositório para o GitHub. Crie uma conta gratuita em github.com e um repositório novo e vazio por lá.

  1. Ligue seu repositório ao GitHub

    O GitHub mostra esse endereço quando você cria o repositório. origin é o apelido padrão do remoto.

    git remote add origin https://github.com/seu-usuario/meu-site.git
  2. Envie a branch main

    O -u faz o Git lembrar desse caminho; das próximas vezes, basta git push. Na primeira vez, o GitHub vai pedir para você entrar na sua conta.

    git push -u origin main
  3. Escreva um README

    Um arquivo README.md na raiz aparece como a capa do repositório. Explique o que é o projeto e como abrir.

Em equipes, ninguém faz merge direto na main. Você envia sua branch e abre um pull request (PR): um pedido para juntar suas mudanças, com uma página onde outras pessoas veem cada linha alterada e comentam antes de aprovar.

Coloque em ordem o caminho de uma mudança até a main, usando pull request.

  • Criar uma branch com git switch -c
  • Fazer commits pequenos na branch
  • Enviar a branch com git push -u origin nome-da-branch
  • Abrir o pull request no GitHub, explicando o que mudou e por quê
  • Receber a revisão e ajustar com novos commits
  • Fazer o merge do pull request na main

Quem pede revisão

Facilite a vida de quem lê

PRs pequenos são revisados mais rápido e com mais atenção.

  • Explique o que mudou e por quê
  • Inclua prints quando a mudança é visual
  • Releia o próprio diff antes de pedir revisão

Quem revisa

Comente o código, não a pessoa

Revisão é colaboração, não prova. Todo mundo, inclusive gente experiente, recebe sugestões.

  • Faça perguntas em vez de ordens
  • Diga o motivo de cada sugestão
  • Elogie o que ficou bom

Num pull request, alguém comenta: “Essa função ficou difícil de ler, que tal dividir em duas?”. Qual a melhor reação?

  • Avaliar a sugestão, responder e, se fizer sentido, ajustar com um novo commit na mesma branch
  • Fechar o PR e abrir outro do zero
  • Entender o comentário como crítica pessoal e ignorar

Fechamento

  • O Git guarda o histórico do projeto em commits, pontos de salvamento com mensagem; o GitHub guarda uma cópia na internet.
  • Uma mudança passa pela pasta de trabalho, vai para o staging com git add e entra no histórico com git commit.
  • Bons commits são pequenos e têm mensagens que dizem o que fazem; senhas e o arquivo .env ficam no .gitignore.
  • Branches são linhas de trabalho paralelas; um conflito acontece quando duas mudam a mesma linha e se resolve editando o arquivo e apagando as marcações.
  • Com git push você envia commits ao GitHub e, num pull request, pede revisão antes de juntar na main.

Seu primeiro repositório público

Coloque a pasta meu-site da aula anterior no Git e no GitHub, e pratique o fluxo completo de uma equipe, incluindo um conflito de propósito. Se algo der errado, git status é sempre o primeiro passo.

  1. Transforme a pasta num repositório, crie um .gitignore com .env e um README.md explicando o projeto, e faça o primeiro commit
  2. Crie o repositório no GitHub e envie a main com git push -u origin main
  3. Crie uma branch, faça dois commits pequenos com mensagens claras, envie e abra um pull request
  4. Crie uma branch de exercício que mude o título da página e, na main, mude o mesmo título de outro jeito; faça o merge e resolva o conflito
  5. Peça a uma IA para explicar o diff do seu pull request e confira a explicação comparando com git log e com a aba de arquivos alterados do PR

Referências

Cursos relacionados