Domine as Operações Básicas do Git | Tutoriais

O que você aprenderá neste tutorial

Inicialização do repositório Git (init)
Staging de alterações (add)
Criação de commits (commit)
Push para o remoto (push)

Pré-requisitos: Git deve estar instalado. Se git --version exibir a versão, está tudo certo.

O que é o Git? Por que foi criado?

Contexto de Criação do Git

O Git foi desenvolvido em 2005 por Linus Torvalds (criador do kernel Linux).

Na época, o desenvolvimento do kernel Linux usava um sistema de controle de versão comercial chamado “BitKeeper”. No entanto, devido a problemas de licenciamento, o BitKeeper não pôde mais ser usado, e Linus criou um novo sistema de controle de versão em apenas 2 semanas. Esse sistema é o Git.

“O nome Git vem de uma gíria britânica que significa ‘pessoa desagradável’. Linus tende a dar nomes autodepreciativos aos seus projetos”

Problemas que o Git Resolveu

Controle de versão distribuído: Cada desenvolvedor tem o histórico completo sem depender de um servidor central
Operações rápidas: A maioria das operações são locais, portanto muito rápidas
Branches leves: Criação e troca de branches são instantâneas
Integridade dos dados: Todas as alterações são protegidas criptograficamente com hashes SHA-1

Git Hoje

Atualmente, o Git é o sistema de controle de versão mais usado no mundo. De acordo com a pesquisa do Stack Overflow de 2022, mais de 93% dos desenvolvedores usam Git.

Entendendo a Estrutura Interna do Git

Para usar o Git de forma eficaz, é importante entender seu funcionamento interno.

As 3 Áreas

O Git tem 3 áreas principais:

flowchart LR
    WD["Diretório de Trabalho<br/>(Working Dir)"] -->|git add| SA["Área de Staging<br/>(Staging Area)"]
    SA -->|git commit| Repo["Repositório<br/>(.git)"]

Diretório de Trabalho (Working Directory): Onde você edita os arquivos
Área de Staging (Staging Area / Index): Onde você prepara as alterações para o próximo commit
Repositório (.git): Onde o histórico de commits é armazenado

Modelo de Objetos do Git

O Git gerencia dados com 4 tipos de objetos:

blob: Conteúdo do arquivo
tree: Estrutura de diretórios
commit: Snapshot + metadados
tag: Referência a um commit específico

Todos os objetos são identificados por hashes SHA-1 (40 caracteres hexadecimais).

Step 1: Inicialização do Repositório

Primeiro, crie um diretório para o projeto e inicialize-o como repositório Git.

# Criar diretório do projeto
mkdir my-first-repo
cd my-first-repo

# Inicializar como repositório Git
git init

Ao executar git init, uma pasta oculta chamada .git é criada. É onde o Git armazena as informações de gerenciamento.

Conteúdo do diretório .git

$ ls -la .git/
├── HEAD          # Referência ao branch atual
├── config        # Configurações específicas do repositório
├── hooks/        # Scripts de Git hooks
├── objects/      # Todos os objetos Git
└── refs/         # Referências a branches e tags

Documentação oficial: git-init

Step 2: Criação e Staging de Arquivos

Vamos criar um novo arquivo e adicioná-lo ao controle do Git.

# Criar arquivo README
echo "# My First Repository" > README.md

# Verificar status
git status

# Fazer staging do arquivo
git add README.md

# Verificar status novamente
git status

git add adiciona alterações à área de staging. Esta é a operação de “selecionar as alterações a incluir no próximo commit”.

Por que a Área de Staging é Necessária?

“A área de staging é um buffer para organizar commits em unidades lógicas. Não é necessário commitar tudo de uma vez” — Pro Git Book

Com a área de staging:

Commits parciais: Você pode selecionar apenas algumas alterações de várias para commitar
Revisão: Você pode confirmar o que incluir antes de commitar
Commits atômicos: Você pode agrupar apenas alterações relacionadas

Padrões comuns de add

# Adicionar arquivo específico
git add filename.txt

# Adicionar todas as alterações
git add .

# Adicionar extensão específica
git add *.js

# Adicionar interativamente (selecionar alterações parciais)
git add -p

Documentação oficial: git-add

Step 3: Criação de Commits

Registre as alterações em staging como um commit.

# Criar commit
git commit -m "Initial commit: Add README"

# Verificar histórico de commits
git log

Como Escrever Boas Mensagens de Commit

A convenção Conventional Commits é amplamente adotada:

<type>(<scope>): <subject>

<body>

<footer>

Exemplos de type:

feat: Nova funcionalidade
fix: Correção de bug
docs: Documentação
style: Mudança de formatação
refactor: Refatoração
test: Adição/modificação de testes
chore: Configuração de build, etc.

Exemplos de boas mensagens de commit:

# Bons exemplos
git commit -m "feat: Add user authentication"
git commit -m "fix: Resolve login button not working on mobile"
git commit -m "docs: Update API documentation"

# Maus exemplos
git commit -m "fix"
git commit -m "Update"
git commit -m "alteração"

Melhor prática: Escreva no formato “Este commit irá [ação]”. Use o imperativo e tempo presente.

Documentação oficial: git-commit

Step 4: Push para o Repositório Remoto

Crie um repositório remoto no GitHub ou similar e faça push das alterações locais.

# Adicionar repositório remoto
git remote add origin https://github.com/username/my-first-repo.git

# Fazer push do branch main
git push -u origin main

A opção -u configura o upstream para que você possa simplesmente usar git push na próxima vez.

Verificando Remotos

# Verificar remotos configurados
git remote -v

# Exemplo de saída:
# origin  https://github.com/username/my-first-repo.git (fetch)
# origin  https://github.com/username/my-first-repo.git (push)

Documentação oficial: git-push

Resumo do Fluxo de Trabalho Básico

# Fluxo de trabalho diário
git status              # Verificar estado atual
git add .               # Fazer staging das alterações
git commit -m "message" # Criar commit
git push                # Enviar para o remoto

Visualização das Operações Git

flowchart LR
    subgraph WD["Working Directory"]
    end
    subgraph SA["Staging Area"]
    end
    subgraph Repo["Repository"]
    end
    WD -->|git add| SA
    SA -->|git commit| Repo
    Repo -->|git checkout| WD
    Repo -->|git reset --soft| SA

Erros Comuns e Antipadrões

1. Commits Gigantes

# Mau exemplo: Commitar tudo de uma vez
git add .
git commit -m "Add all features"

# Bom exemplo: Dividir em unidades lógicas
git add src/auth/
git commit -m "feat: Add authentication module"

git add src/api/
git commit -m "feat: Add API endpoints"

2. Commitar Informações Sensíveis

# Arquivos que devem estar no .gitignore
.env
*.pem
config/secrets.yml
node_modules/

3. Omitir Mensagens de Commit

Mensagens de commit são documentação para você no futuro e outros desenvolvedores. Escreva mensagens significativas.

Problemas Comuns e Soluções

Errei a mensagem do commit

# Corrigir mensagem do último commit
git commit --amend -m "Nova mensagem"

Atenção: Evite corrigir commits que já foram enviados por push. Reescrever histórico afeta outros desenvolvedores.

Quero desfazer o add

# Desfazer staging (mantém alterações no arquivo)
git reset HEAD filename.txt

# Novo comando a partir do Git 2.23
git restore --staged filename.txt

Quero desfazer o último commit

# Desfazer commit, manter alterações no staging
git reset --soft HEAD~1

# Desfazer commit, manter alterações no diretório de trabalho
git reset HEAD~1

# Deletar commit e alterações completamente (perigoso)
git reset --hard HEAD~1

Quero restaurar um arquivo para um estado anterior

# Restaurar arquivo de um commit específico
git checkout <commit-hash> -- filename.txt

# A partir do Git 2.23
git restore --source=<commit-hash> filename.txt

Melhores Práticas de Configuração

Se você está usando o Git pela primeira vez, faça as seguintes configurações:

# Configurar nome de usuário e email (obrigatório)
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

# Definir nome do branch padrão como main
git config --global init.defaultBranch main

# Conversão automática de quebra de linha (macOS/Linux)
git config --global core.autocrlf input

# Configuração do editor
git config --global core.editor "code --wait"

# Habilitar saída colorida
git config --global color.ui auto

Próximos Passos

Após dominar as operações básicas, aprenda a usar branches. É uma habilidade essencial para desenvolvimento em equipe.

Recursos para continuar aprendendo:

Aprender estratégias de branch → Pratique Estratégias de Branch Git
Aprender interativamente → Learn Git Branching

Links de Referência

Documentação Oficial

Documentação Oficial do Git - Referência oficial
Pro Git Book (Português) - Livro abrangente gratuito sobre Git

Artigos e Tutoriais Recomendados

Conventional Commits - Convenção de mensagens de commit
GitHub Git Cheat Sheet - Lista de comandos mais usados
Atlassian Git Tutorial - Aprenda Git visualmente

Ferramentas

GitHub Desktop - Opere Git com GUI
GitLens (Extensão VS Code) - Visualize histórico Git no VS Code
Learn Git Branching - Site interativo de aprendizado de Git

← Voltar para a lista