Tutorial 3 de 10

30% concluído

Comandos essenciais do Git

Domine os comandos básicos para acompanhar modificações, criar commits e gerenciar seus arquivos.

Comandos essenciais do Git

Agora que o Git está instalado e configurado, vamos conhecer os comandos que você usará no dia a dia. Este tutorial aborda as operações fundamentais para gerenciar seus arquivos e criar um histórico coerente do seu projeto.

Visão geral do workflow do Git

Comandos de status e informação

git status

O comando mais utilizado para saber o estado do seu repositório:

# Ver o estado completo
git status

# Versão curta
git status -s
git status --short

Exemplo de saída:

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   index.html

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

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

git log

Consultar o histórico de commits:

# Histórico completo
git log

# Versão condensada
git log --oneline

# Com gráfico das branches
git log --oneline --graph --all

# Limitar o número de commits
git log -5

# A partir de uma data
git log --since="2024-01-01"

# Por autor
git log --author="Nom Auteur"

git show

Exibir os detalhes de um commit:

# Último commit
git show

# Commit específico
git show abc1234

# Arquivo específico em um commit
git show abc1234:fichier.txt

Gerenciamento de arquivos

git add

Adicionar arquivos à staging area:

# Adicionar um arquivo específico
git add fichier.txt

# Adicionar vários arquivos
git add fichier1.txt fichier2.txt

# Adicionar todos os arquivos modificados
git add .

# Adicionar todos os arquivos (inclusive removidos)
git add -A
git add --all

# Adicionar de forma interativa
git add -i

# Adicionar por partes (patch)
git add -p

git commit

Criar um instantâneo das suas modificações:

# Commit com mensagem
git commit -m "Message de commit"

# Commit com mensagem detalhada
git commit -m "Titre du commit" -m "Description détaillée"

# Commit adicionando automaticamente os arquivos modificados
git commit -am "Message de commit"

# Modificar o último commit
git commit --amend

# Commit com assinatura GPG
git commit -S -m "Message signé"

Boas práticas para mensagens de commit

# Formato recomendado
git commit -m "type: description courte

Description plus détaillée si nécessaire.

- Point important 1
- Point important 2

Fixes #123"

Tipos comuns:

feat: nova funcionalidade
fix: correção de bug
docs: documentação
style: formatação, ponto e vírgula faltando etc.
refactor: refatoração do código
test: adição de testes
chore: manutenção

Gerenciamento de modificações

git diff

Comparar modificações:

# Diferenças no working directory
git diff

# Diferenças na staging area
git diff --staged
git diff --cached

# Diferenças entre dois commits
git diff abc1234 def5678

# Diferenças de um arquivo específico
git diff fichier.txt

# Estatísticas das modificações
git diff --stat

git restore

Desfazer modificações (Git 2.23+):

# Restaurar um arquivo modificado
git restore fichier.txt

# Restaurar todos os arquivos modificados
git restore .

# Remover um arquivo da staging area
git restore --staged fichier.txt

# Restaurar a partir de um commit específico
git restore --source=abc1234 fichier.txt

git reset

Redefinir o estado do repositório:

# Remover um arquivo da staging area
git reset fichier.txt

# Redefinir a staging area
git reset

# Voltar ao commit anterior (mantém as modificações)
git reset HEAD~1

# Redefinir completamente (ATENÇÃO: perda de dados)
git reset --hard HEAD~1

Gerenciamento de arquivos e pastas

git rm

Remover arquivos:

# Remover um arquivo do repositório e do sistema
git rm fichier.txt

# Remover apenas do repositório (manter localmente)
git rm --cached fichier.txt

# Remover uma pasta recursivamente
git rm -r dossier/

git mv

Mover ou renomear arquivos:

# Renomear um arquivo
git mv ancien-nom.txt nouveau-nom.txt

# Mover um arquivo
git mv fichier.txt dossier/fichier.txt

Arquivo .gitignore

Ignorar arquivos e pastas:

# Fichiers de log
*.log

# Dossiers de build
build/
dist/

# Fichiers de configuration locale
.env
config.local.js

# Dépendances
node_modules/
vendor/

# Fichiers système
.DS_Store
Thumbs.db

# IDE
.vscode/
.idea/
*.swp
*.swo

# Fichiers temporaires
*.tmp
*.temp

Comandos relacionados ao .gitignore

# Verificar se um arquivo está sendo ignorado
git check-ignore fichier.txt

# Forçar a adição de um arquivo ignorado
git add -f fichier.txt

# Remover um arquivo já rastreado mas agora ignorado
git rm --cached fichier.txt

Navegação no histórico

git checkout

Navegar entre commits e branches:

# Ir para um commit específico (modo detached)
git checkout abc1234

# Voltar para a branch principal
git checkout main

# Criar e mudar para uma nova branch
git checkout -b nouvelle-branche

git switch (Git 2.23+)

Alternativa moderna ao checkout:

# Mudar para uma branch
git switch main

# Criar e mudar para uma nova branch
git switch -c nouvelle-branche

# Voltar para a branch anterior
git switch -

Comandos de ajuda e informação

git help

Obter ajuda:

# Ajuda geral
git help

# Ajuda para um comando específico
git help commit
git commit --help

# Lista dos comandos comuns
git help -a

git config

Gerenciar a configuração:

# Ver toda a configuração
git config --list

# Ver um valor específico
git config user.name

# Modificar um valor
git config --global user.email "nouveau@email.com"

Exercícios práticos

Exercício 1: Workflow básico

# 1. Criar um novo projeto
mkdir exercice-git
cd exercice-git
git init

# 2. Criar arquivos
echo "# Mon Projet" > README.md
echo "console.log('Hello World');" > app.js
echo "body { margin: 0; }" > style.css

# 3. Verificar o status
git status

# 4. Adicionar os arquivos
git add README.md app.js
git status

# 5. Fazer um commit
git commit -m "feat: ajout des fichiers de base"

# 6. Adicionar o CSS
git add style.css
git commit -m "style: ajout du CSS de base"

# 7. Ver o histórico
git log --oneline

Exercício 2: Modificações e correções

# 1. Modificar um arquivo
echo "// Commentaire ajouté" >> app.js

# 2. Ver as diferenças
git diff

# 3. Adicionar à staging area
git add app.js

# 4. Ver as diferenças staged
git diff --staged

# 5. Commit
git commit -m "docs: ajout de commentaire"

# 6. Modificar o último commit
git commit --amend -m "docs: ajout de commentaire dans app.js"

Exercício 3: Tratamento de erros

# 1. Criar um arquivo por engano
echo "Fichier temporaire" > temp.txt
git add temp.txt

# 2. Remover da staging area
git restore --staged temp.txt

# 3. Excluir o arquivo
rm temp.txt

# 4. Modificar um arquivo e depois desfazer
echo "Modification non désirée" >> README.md
git restore README.md

Comandos avançados úteis

git stash

Salvar modificações temporariamente:

# Salvar as modificações
git stash

# Salvar com uma mensagem
git stash push -m "Travail en cours sur la feature X"

# Ver a lista de stashes
git stash list

# Aplicar o último stash
git stash pop

# Aplicar um stash específico
git stash apply stash@{1}

git clean

Limpar arquivos não rastreados:

# Ver o que seria removido
git clean -n

# Remover os arquivos não rastreados
git clean -f

# Remover também as pastas
git clean -fd

Aliases úteis

Configure estes aliases para ganhar tempo:

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.unstage 'restore --staged'
git config --global alias.last 'log -1 HEAD'
git config --global alias.lg 'log --oneline --graph --decorate --all'
git config --global alias.amend 'commit --amend --no-edit'

Solução de problemas comuns

Desfazer o último commit (mantendo as modificações)

git reset HEAD~1

Desfazer completamente o último commit

git reset --hard HEAD~1

Recuperar um arquivo excluído

git restore fichier.txt
# ou a partir de um commit específico
git restore --source=HEAD~1 fichier.txt

Ver quem modificou uma linha

git blame fichier.txt

Boas práticas

Faça commits com frequência: commits pequenos e frequentes
Mensagens claras: descreva o que o commit faz
Verifique antes de commitar: git status e git diff
Use o .gitignore: evite arquivos desnecessários
Teste antes de commitar: certifique-se de que o código funciona

Recursos adicionais

Cheat sheets

Ferramentas visuais

gitk: interface gráfica integrada
git gui: interface para commits

Conclusão

Esses comandos formam a base do seu uso diário do Git. Dominar essas operações permitirá que você gerencie seus projetos com eficiência e mantenha um histórico limpo e coerente.

No próximo tutorial, vamos explorar as branches e o merge, conceitos essenciais para o trabalho colaborativo e para o gerenciamento de funcionalidades paralelas.

Tempo de leitura estimado: 25 minutos
Nível: Iniciante
Etapa anterior: Configuração e primeiros passos
Próxima etapa: Branches e merge