Skip to content

luiscruzcwb/Git

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

28 Commits
 
 
 
 
 
 
 
 

Repository files navigation

Git — Projetos e Estudos (versão revisada e com exemplos)

Objetivo: material didático, direto ao ponto, com comandos corrigidos, explicações e exemplos de uso.
Público-alvo: iniciantes e usuários intermediários.

GIT


O que é Git (e o que não é)

  • Sistema de Controle de Versão Distribuído (DVCS): salva o histórico de alterações do seu projeto localmente e permite colaboração.
  • Colaborativo: múltiplas pessoas podem contribuir de forma segura e auditável (commits, branches, merges).
  • Não é “armazenamento em nuvem”. Plataformas como GitHub, GitLab e Bitbucket hospedam repositórios remotos e oferecem recursos adicionais (issues, pull requests, pipelines etc.).

Objetos Internos (visão rápida)

  • Blob: conteúdo de um arquivo em um dado momento.
  • Tree: diretórios/estrutura de arquivos (aponta para blobs/trees).
  • Commit: metadados (autor, data, mensagem) + ponteiro para uma tree e para o commit pai.

Inspecionar na prática: git show <hash>, git ls-tree -r <hash>.


Pull Requests (PRs) — no GitHub/GitLab/Bitbucket

PR é um fluxo da plataforma (não um comando Git puro) para propor mudanças de uma branch para outra:

  • Merge (merge commit): preserva o histórico; cria um commit de mesclagem.
  • Squash and Merge: comprime vários commits da branch de feature em um commit na branch de destino.
  • Rebase and Merge: reescreve os commits da branch de feature “por cima” da base, deixando histórico linear.

Escolha depende da política do repositório (histórico linear vs histórico completo).


Instalação

Linux (Debian/Ubuntu)

sudo apt update
sudo apt install -y software-properties-common
sudo add-apt-repository ppa:git-core/ppa -y   # (opcional, para versões mais novas do Git)
sudo apt update
sudo apt install -y git
git --version

Outras plataformas (resumo)


Configuração inicial (identidade e editor)

git config --global user.name  "Seu Nome"
git config --global user.email "seu.email@exemplo.com"
git config --global core.editor "nano"          # ou "code --wait", "vim", etc.
git config --list
# Para remover/ajustar algo:
git config --global --unset <chave>

Autenticação via SSH (GitHub/GitLab)

1) Criar a chave

ssh-keygen -t ed25519 -C "seu.email@exemplo.com"
# Aceite o local padrão: ~/.ssh/id_ed25519 (recomendado)

2) Permissões e arquivos

# Permissões recomendadas (chave privada 600, chave pública 644):
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

3) Iniciar o agente e adicionar a chave

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

4) Copiar a chave pública e colar na plataforma

cat ~/.ssh/id_ed25519.pub
# Copie o conteúdo e cadastre em: GitHub/GitLab > Settings > SSH Keys

5) Teste com repositório privado (ajuste a URL)

git clone git@github.com:<usuario>/<repositorio>.git

Dica: Se precisar de ~/.ssh/config:

Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519
    IdentitiesOnly yes

Em ambientes Desktop Linux, instale o xdg-utils se o navegador não abrir links corretamente: sudo apt install -y xdg-utils.


Primeiros passos — criar repositório e 1º commit

mkdir meu-projeto && cd meu-projeto
git init
echo "# Meu Projeto" > README.md
git status
git add README.md          # ou: git add .   (tudo do diretório)
git commit -m "Commit inicial: adiciona README"

Principais comandos (com correções e exemplos)

Ajuda

git help               # abre visão geral
git help <comando>     # ex.: git help log

git add — preparar arquivos para commit (staging)

git add arquivo.txt            # adiciona específico
git add .                      # adiciona tudo a partir do diretório atual
# Evite: git add * (pode ignorar arquivos ocultos) e “git add.” (sem espaço)

Remover do staging (sem perder alterações):

git restore --staged arquivo.txt

git commit — criar um snapshot

git commit -m "Descrição clara do que mudou"
git commit --amend -m "Nova mensagem para o commit anterior"   # reescreve a mensagem

git status — estado do working dir e staging

git status
git status -v   # mostra diffs na saída (verboso)

Remotos e push

git remote add origin git@github.com:<usuario>/<repo>.git
git remote -v
git branch -M main                         # renomeia a branch atual para main
git push -u origin main                    # define upstream para 'main'
git push -v                                # saída verbosa
git push -4                                # força IPv4 (ambientes com rede limitada)
# Cuidado ao sobrescrever histórico remoto:
git push --force-with-lease                # preferível ao --force/-f

Branches — criar, listar, trocar

git branch "minha-feature"   # cria branch (não troca)
git branch --all             # lista todas (locais e remotas)

# Formas modernas de trocar/criar:
git switch "minha-feature"   # trocar para branch existente
git switch -c "nova-feature" # criar e trocar para a nova

# Formas clássicas (ainda comuns):
git checkout "minha-feature"     # trocar para branch existente
git checkout -b "nova-feature"   # criar e trocar para a nova

# Publicar a branch e definir upstream
git push --set-upstream origin "minha-feature"

Mesclar, rebase e apagar branch

# estando na branch de destino (ex.: main):
git merge minha-feature

# apagar branch (local):
git branch -d minha-feature   # seguro (recusa se houver commits não mesclados)
git branch -D minha-feature   # força

Buscar atualizações, comparar e guardar alterações temporárias

git fetch                      # atualiza refs remotas (sem mesclar)
git diff                       # wdir vs último commit
git diff --staged              # staging vs último commit
git diff HEAD~1 HEAD           # penúltimo vs último commit

# Guardar alterações temporariamente e voltar limpo
git stash                      # cria stash e limpa wdir
git stash list                 # lista stashes
git stash pop                  # aplica o último e remove do stash

Restaurar arquivo e desfazer mudanças

# Moderno: restaurar do último commit
git restore --source=HEAD -- caminho/arquivo.ext

# Clássico (ainda muito usado):
git checkout -- caminho/arquivo.ext

Reset (soft/mixed/hard) — use com cuidado

git reset --soft <hash>    # move HEAD; mantém staging e wdir (volta commits, preserva staging)
git reset --mixed <hash>   # (padrão) limpa staging; mantém wdir
git reset --hard <hash>    # descarta TUDO até o hash (perde mudanças não commitadas)

Reverter um commit (gera novo commit de reversão)

git revert HEAD
git revert --no-edit HEAD
git revert -n <hash>       # prepara reversão na staging (sem commitar)

Diagnóstico de autenticação (remoto HTTPS→SSH, GitHub/GitLab)

git remote -v
git remote set-url origin git@github.com:<usuario>/<repo>.git
git remote set-url origin git@gitlab.com:<usuario>/<repo>.git

Utilidades diversas

  • .gitkeep: arquivo “sentinela” para versionar pastas vazias.
  • .gitignore: ignora arquivos/padrões (ex.: node_modules/, *.log, .env).
    Criar rapidamente:
    curl -L -o .gitignore https://www.toptal.com/developers/gitignore/api/linux,macos,windows,python,node
  • git reflog: “caixa-preta” do HEAD — recuperar hashes perdidos após resets/rebases acidentais.

Fluxos completos (copiar/colar)

1) Clone via SSH e primeiro push

git clone git@github.com:<usuario>/<repo>.git
cd <repo>
git switch -c feature/docs-git
echo "Guia de Git" > guia.md
git add guia.md
git commit -m "Add guia.md com conceitos básicos"
git push --set-upstream origin feature/docs-git

2) Atualizar branch local com remoto sem mesclar automaticamente

git fetch
git switch main
git merge origin/main

3) Resolver conflito simples

# editar arquivos marcados com <<<<<<<, =======, >>>>>>>
git add arquivo-com-conflito.ext
git commit -m "Resolve conflito em arquivo-com-conflito.ext"

4) Desfazer último commit mantendo alterações no staging

git reset --soft HEAD~1
# ajuste arquivos/mensagem e faça novo commit
git commit -m "Mensagem corrigida"

5) Recuperar arquivo apagado por engano

git reflog               # encontre o hash anterior
git checkout <hash> -- caminho/arquivo.ext
# ou moderno:
git restore --source=<hash> -- caminho/arquivo.ext

Correções mais comuns deste material

  • git add * → pode ignorar ocultos; prefira git add . ou nomes explícitos.
  • git add/rmnão existe; use git add <arquivo> e git rm <arquivo>.
  • git push --force → prefira --force-with-lease (mais seguro).
  • git checkout -- para restaurar arquivos é legado; prefira git restore quando possível.
  • chmod 600 ~/.ssh/id_ed25519 e não no .pub; a pública pode ser 644.

Links úteis

About

Git - Sistema open-source de controle de versão

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

 
 
 

Contributors

Languages