Garanta sua assinatura com até 30%OFF antes do reajuste. Quero aproveitar
Git na prática: principais comandos para desenvolvedores de todos os níveis

Rocketseat

Navegação Rápida:
O que é Git e por que usá-lo?
1Configuração inicial
2Comandos para repositórios
3Trabalhando com alterações
4Gerenciamento de branches (ramificações)
5Colaboração e repositórios remotos
6Desfazendo alterações
7Trabalhando com stash
8Resolvendo conflitos
9Dicas avançadas
10Boas práticas
11Resumo dos principais comandos
12Conclusão: quer se aprofundar ainda mais?
13
Se você está dando seus primeiros passos no universo do desenvolvimento de software ou já trabalha na área há um tempo, certamente já ouviu falar sobre Git e a importância do versionamento de código. E não é à toa: o Git revolucionou a forma como colaboramos em projetos, controlamos alterações e mantemos um registro histórico do que acontece em cada linha do nosso código.
Neste artigo, vamos abordar os principais comandos do Git – desde os mais básicos até os mais avançados –, servindo como um guia para você consultar sempre que precisar. Nosso objetivo é fornecer um guia prático, que vai te ajudar a solidificar seus conhecimentos em Git e se tornar uma referência confiável para o seu dia a dia como desenvolvedor.
Se preferir, já salve este artigo nos favoritos, pois ele será útil para consultar quando as dúvidas aparecerem!
O que é Git e por que usá-lo?
O Git é um sistema de controle de versão distribuído (DVCS) criado para facilitar a colaboração e o rastreamento de modificações em projetos de software. Com o Git, cada desenvolvedor tem uma cópia completa do histórico de commits, garantindo segurança, independência e desempenho superior em comparação a outras ferramentas de versionamento.
- Versionamento de código: possibilita revisar versões anteriores do projeto, identificar responsáveis por determinadas alterações e até mesmo reverter mudanças, se necessário.
- Colaboração eficiente: cada integrante da equipe (ou colaborador open source) pode trabalhar em paralelo, criando suas próprias ramificações (branches) e enviando suas contribuições para o repositório remoto (GitHub, GitLab, Bitbucket etc.).
- Organização e escalabilidade: desde pequenos projetos pessoais até grandes sistemas em produção, o Git se adapta perfeitamente.
Na Rocketseat, por exemplo, o Git é amplamente usado em nossos treinamentos para incentivar a colaboração entre membros, seja em projetos de estudo, hackathons ou eventos internos.
Se você ainda tem dúvida ou precisa aprofundar mais seus conhecimentos sobre a ferramenta, fique tranquilo! Nós temos um artigo que pode te ajudar com isso. Confira em: Primeiros passos com Git.
Configuração inicial
Antes de começar a trabalhar com comandos do Git, é preciso realizar algumas configurações fundamentais. Elas permitem que o Git associe cada alteração que você fizer ao seu usuário.
Configurando o nome de usuário e e-mail
Configure seu nome de usuário:
git config --global user.name "Diego Fernandes"
Configure seu e-mail:
git config --global user.email "diego@exemplo.com.br"
--global
: significa que essas configurações serão aplicadas em todos os repositórios do seu usuário no computador.
--local
: as configurações valem apenas para o repositório atual.
--system
: configurações para todos os usuários e todos os repositórios da máquina (geralmente requer privilégios de administrador).
Por que isso importa?
Porque cada commit fica registrado com o autor que o realizou. Assim, quando você fizer alterações, terá seus commits identificados corretamente.
Comandos para repositórios
Uma das primeiras etapas para trabalhar com Git é entender como inicializar ou clonar um repositório. É nesse momento que você vai preparar o ambiente para controlar as versões do seu código de forma simples, organizada e segura.
1. Inicializando um repositório
Para transformar qualquer pasta em um repositório Git, basta usar o comando:
git init
- Esse comando cria uma pasta oculta chamada
.git/
, onde o Git armazenará todo o histórico, metadados e configurações internas do projeto.
- Após executar
git init
, você pode conferir a nova pasta.git/
rodandols -a
no terminal (ou exibindo arquivos ocultos na sua IDE).
Utilize git status logo após o git init para verificar o estado do novo repositório e entender quais arquivos já estão sendo rastreados.
Cenário prático:
Imagine que você está iniciando um projeto para um desafio interno da Rocketseat. Você criou uma pasta chamada
desafio-rocket
no seu computador. Então, basta navegar até ela via terminal e digitar:cd desafio-rocket git init
A pasta
desafio-rocket
agora é um repositório Git e está pronta para versionar seu código!2. Clonando um repositório existente
Se você quer contribuir para um projeto que já existe em um servidor remoto (por exemplo, no GitHub, GitLab ou Bitbucket), use o comando:
git clone <URL-do-repositório>
Por exemplo:
git clone https://github.com/rocketseat-education/awesome-project.git
- O Git baixará o repositório completo, incluindo todo o histórico de commits, branches, tags e demais metadados.
- Esse é o ponto de partida quando você deseja colaborar em um projeto open source ou em um repositório da sua equipe.
Caso o repositório seja privado, será necessário ter permissão de acesso ou usar tokens/chaves SSH conforme a plataforma em questão.
3. Criando o arquivo .gitignore
Em muitos projetos, há arquivos ou pastas que não devem ser versionados. Geralmente, esses arquivos são:
- Diretórios de dependências (ex:.
node_modules/
).
- Arquivos de configuração local (ex.:
.env
).
- Pastas de build ou distribuição (ex.:
dist/
,build/
).
Para instruir o Git a ignorar esses itens, crie um arquivo chamado
.gitignore
na raiz do projeto, com o conteúdo:node_modules/ .env dist/
Qualquer arquivo ou pasta listada aqui será ignorada pelo Git no processo de versionamento.
É importante manter informações sensíveis fora do repositório. Se por acaso você versionou algo que não deveria (como senhas ou chaves de API), revise seu histórico e remova esses dados o quanto antes para evitar problemas de segurança.
Sempre que for começar um projeto ou integrar-se a um projeto novo, lembre-se desses passos iniciais. Eles garantem que você terá uma estrutura de versionamento organizada e confiável para trabalhar, testar novas ideias e colaborar com outras pessoas.
Trabalhando com alterações
Uma vez que seu repositório está configurado, chegou a hora de entender como o Git rastreia e registra as mudanças feitas no seu projeto. Conhecer esse fluxo é essencial para organizar suas entregas e colaborar com facilidade.
1. Verificando o status do repositório
git status
- Exibe quais arquivos foram criados, modificados, removidos ou ainda não rastreados (untracked) desde o último commit.
- É o comando principal para verificar o que está acontecendo no seu repositório a qualquer momento.
Rodar git status frequentemente ajuda a manter o controle do que foi alterado e do que ainda precisa ser adicionado ou commitado.
2. Adicionando alterações à área de staging
# Adiciona todas as alterações git add . # Adiciona um arquivo específico git add index.html # Adiciona todos os arquivos .js git add *.js
- Após o
git add
, as alterações ficam prontas para serem incluídas no próximo commit.
- Área de staging (também chamada de index): é como uma “sala de preparação”, onde você coloca apenas as mudanças que deseja enviar ao histórico.
Suponha que você alterou vários arquivos, mas quer fazer um commit específico apenas noindex.html
. Basta fazergit add index.html
para que apenas esse arquivo seja colocado na área de staging.
3. Criando um commit
git commit -m "Adiciona funcionalidade de login"
- Ao criar um commit, você “tira uma foto” do estado do seu projeto naquele momento.
- A mensagem de commit deve ser clara e concisa, descrevendo o que foi feito e, preferencialmente, por que foi feito.
Exemplo:
git commit -m "Corrige validação de email no formulário de cadastro"
Gostou do conteúdo? Confira esse video onde o Diego Fernandes explica como ele faz para criar os commits:

4. Visualizando as diferenças
# Alterações no diretório de trabalho em relação à área de staging git diff # Alterações já adicionadas em relação ao último commit git diff --staged
git diff
exibe as mudanças linha a linha, permitindo que você revise tudo antes de confirmar o commit.
- Excelente recurso para verificar pequenas alterações ou certificar-se de que não está enviando algo indevido ao repositório.
Se você editou um arquivo CSS e quer ter certeza de que as alterações estão corretas, use git diff style.css para ver a comparação exata do que foi modificado.
5. Visualizando o histórico de commits
# Histórico completo e detalhado git log # Histórico resumido (um commit por linha) git log --oneline # Exibe o histórico em formato de grafo (ótimo para ver branches) git log --graph --oneline
git log
permite navegar pelo histórico de commits, visualizar mensagens, autores, datas e até mesmo merges.
- Você pode combinar opções como
-oneline
e-graph
para enxergar melhor as ramificações do seu projeto.
Se o histórico estiver muito longo, usegit log --oneline --graph --decorate
para ver commits em apenas uma linha, com visualização das branches e tags.
Gerenciamento de branches (ramificações)
Branches são um dos recursos mais poderosos do Git. Elas permitem que você trabalhe em novas funcionalidades de forma isolada, sem afetar o que já está pronto na branch principal.
1. Listando, criando e removendo branches
# Lista todas as branches git branch # Cria uma nova branch git branch feature/login # Deleta uma branch git branch -d feature/login # Força a deleção de uma branch (caso não tenha sido mesclada) git branch -D feature/login
- Use
git branch
para ver em qual branch você está e quais outras existem no repositório.
- É comum usar nomes que descrevam a funcionalidade ou correção sendo desenvolvida, como
feature/login
oufix/navbar-bug
.
Quando iniciar uma nova funcionalidade, crie uma branch com git branch feature/nome-da-feature. Assim, mantém o trabalho organizado e independente das outras partes do projeto.
2. Mudando entre branches
# Muda para uma branch existente git checkout feature/login # Cria e já muda para a nova branch git checkout -b feature/dashboard
git checkout <nome-da-branch>
permite alternar entre diferentes linhas de desenvolvimento.
- A flag
b
cria a branch e já realiza o checkout em uma única etapa.
No Git mais recente, você também pode usargit switch <branch>
ougit switch -c <branch>
para se mover entre branches, dependendo da sua versão do Git.
3. Juntando branches
git checkout main git merge feature/login
- Depois que você concluir o desenvolvimento na branch
feature/login
, pode mesclar as alterações na branch principal (geralmente chamada demain
oumaster
).
- Se houver conflitos, resolva-os manualmente ou usando ferramentas de merge e finalize com um
git commit
.
Exemplo:
- Mayk terminou de implementar uma nova tela de cadastro na branch
feature/cadastro
.
- Para integrar essa mudança ao projeto principal, ele fará:
git checkout main git merge feature/cadastro
4. Reorganizando o histórico (rebase)
git checkout feature/dashboard git rebase main
- O rebase move os commits da branch atual para o topo de outra, criando um histórico mais linear.
- Use com cautela: reescreve o histórico, podendo causar problemas em branches compartilhadas por muitas pessoas.
Você quer que suafeature/dashboard
seja baseada na versão mais recente de main. Usargit rebase main
“cola” os seus commits da feature no topo do branch main, resultando em um histórico sem merges adicionais.
Colaboração e repositórios remotos
O Git foi criado para facilitar o trabalho em equipe. É hora de aprender como enviar e receber commits de repositórios em serviços como GitHub, GitLab ou Bitbucket.
1. Adicionando e visualizando remotos
# Adiciona um repositório remoto git remote add origin https://github.com/rocketseat-education/awesome-project.git # Lista os repositórios remotos configurados git remote -v
origin
é o nome padrão que indica o repositório remoto principal, mas você pode usar outros nomes se quiser.
- Use
git remote -v
para confirmar se o repositório foi configurado corretamente.
Em um hackathon interno na Rocketseat, a Laís cria um repositório no GitHub e compartilha o link com o time. Cada membro utiliza git remote add origin <link> para associar o projeto local ao repositório remoto.
2. Enviando commits para o repositório remoto
git push origin main
- Publica as alterações locais na branch
main
do repositório remoto.
- Se estiver em outra branch, substitua
main
porfeature/login
,hotfix/bug-123
ou qualquer outro nome de branch.
Se for a primeira vez que está enviando uma nova branch, usegit push -u origin <nome-da-branch>
para criar a branch no servidor remoto e associar a branch local à remota.
3. Baixando alterações do repositório remoto
# Faz o fetch e o merge em seguida git pull origin main
- Combina
git fetch
(baixa alterações) egit merge
(mescla alterações) em um único passo.
- Mantém seu repositório local sincronizado com as atualizações do time.
Se a Fernanda fez commits na branch main e você quer ter essas modificações, basta rodargit pull origin main
para receber tudo.
4. Obtendo somente os metadados (fetch)
git fetch origin
- Atualiza as referências locais das branches remotas, mas não mescla automaticamente as mudanças no seu código.
- Útil para conferir o que mudou no repositório remoto antes de tomar decisões de merge ou rebase.
Você quer saber se há atualizações em develop, mas ainda não quer incorporá-las ao seu trabalho. Basta dar umgit fetch
e depois olhar com calma as diferenças.
Desfazendo alterações
Por vezes, você pode precisar reverter ou descartar mudanças feitas por engano. O Git oferece diversas formas de lidar com isso, dependendo do seu cenário específico.
1. Descartando alterações não adicionadas
git checkout -- index.html
- Restaura o arquivo
index.html
para o estado do último commit.
- Útil quando você alterou um arquivo, mas mudou de ideia antes de adicioná-lo ao staging com
git add
.
Essa ação é irreversível. Tudo que estiver no arquivo (e não estiver em algum commit) será perdido.
2. Removendo arquivo da área de staging
git reset style.css
- Remove o arquivo
style.css
da área de staging, mas mantém as alterações no seu diretório local.
- É ideal quando você adicionou algo por engano, mas não quer perder as alterações que fez.
Você fez várias modificações e usougit add .
, mas depois percebeu que style.css não deveria estar no próximo commit. Bastagit reset style.css
para tirá-lo da área de staging.
3. Retornando a commits anteriores
O comando
git reset
permite que você ande para trás no histórico de commits em diferentes níveis:# Desfaz o último commit, mas mantém as alterações na área de staging git reset --soft HEAD~1 # Desfaz o último commit, remove as alterações da área de staging, mas mantém no diretório de trabalho git reset --mixed HEAD~1 # Desfaz o último commit e descarta todas as alterações (cuidado!) git reset --hard HEAD~1
- -soft: “desfaz” o commit, mas preserva todas as modificações na área de staging.
- -mixed (padrão): remove as alterações do staging, porém ainda deixa as modificações no seu diretório de trabalho.
- -hard: desfaz o commit e descarta todas as alterações. Use apenas se tiver certeza de que não precisa delas.
HEAD~1 representa “um commit antes do atual”. Você pode usar HEAD~2 para voltar dois commits, e assim por diante.
4. Revertendo um commit específico (criando um novo commit)
git revert a1b2c3d4
- Em vez de remover o commit do histórico, o
git revert
cria um novo commit que “desfaz” as mudanças do commit original.
- É a forma mais segura de lidar com alterações indesejadas em projetos colaborativos, pois mantém o histórico intacto.
Quando usar? Se você já fez push do commit para um repositório remoto e outras pessoas trabalharam em cima dele, git revert é a melhor opção para evitar complicações no histórico.
Trabalhando com stash
O
git stash
é um recurso que permite guardar temporariamente suas alterações não commitadas, sem precisar criar um commit “parcial” ou “sujo” no histórico.# Salva as alterações e limpa o diretório de trabalho git stash # Salva as alterações com uma mensagem de identificação git stash push -m "WIP: Ajustando layout da página inicial" # Lista todos os stashes salvos git stash list # Aplica o stash mais recente (sem removê-lo da lista) git stash apply # Aplica e já remove o stash do topo da lista git stash pop # Remove um stash específico git stash drop stash@{2} # Limpa todos os stashes git stash clear
Como funciona na prática?
- Você está trabalhando em uma nova tela de cadastro e precisa mudar rapidamente de branch para corrigir um bug crítico.
- Em vez de fazer um commit incompleto, use
git stash
para “guardar” suas alterações.
- Mude de branch, faça as correções e volte para a branch anterior.
- Use
git stash pop
para recuperar as mudanças e continuar de onde parou.
Adicionar uma breve descrição com git stash push -m "Mensagem" ajuda a identificar facilmente cada stash na lista.
Resolvendo conflitos
Conflitos acontecem quando duas ou mais pessoas (ou você, em branches diferentes) alteram a mesma parte de um arquivo. Nessa situação, o Git não sabe qual versão do código deve ser mantida, gerando um conflito.
- Identifique o conflito
Use o comando:
git status
O Git listará os arquivos em que há conflito.
- Edite manualmente o arquivo em conflito
- HEAD representa o seu código local.
- branch-remota representa o código que está vindo de outra branch. Combine manualmente as duas versões ou escolha apenas uma delas, removendo as linhas de marcação.
Ao abrir o arquivo, você verá algo assim:
<<<<<<< HEAD (Seu código) ======= (O código que veio da branch que está sendo mesclada) >>>>>>> branch-remota
- Marque o conflito como resolvido
Depois de ajustar o arquivo, adicione-o ao staging:
git add <arquivo>
- Finalize a mesclagem
Confirme as mudanças com:
git commit -m "conflito"
Esse commit completará a mesclagem, registrando a resolução do conflito no histórico.
- Ferramentas de merge (opcional)
O Git pode ser configurado para usar softwares visuais que auxiliam na resolução de conflitos:
git mergetool
Ferramentas como o VSCode oferecem uma experiência interativa para resolver conflitos, permitindo que você escolha qual bloco de código manter ou mesclar sem precisar editar manualmente todas as marcações.
Dicas avançadas
Esses comandos tornam o Git ainda mais poderoso e flexível, ajudando você a lidar com cenários complexos ou agilizar tarefas rotineiras.
1. git cherry-pick
git cherry-pick <hash-do-commit>
- “Pega” um commit específico de outra branch e o aplica na branch atual.
- Muito útil se você precisa de uma correção rápida que já foi feita em outro lugar, sem precisar mesclar toda a branch.
2. git bisect
- Permite encontrar o commit exato que introduziu um bug via busca binária.
git bisect start git bisect bad # Marca o commit atual como "ruim" git bisect good <hash-bom> # Marca um commit anterior, onde o bug não existia # Teste o código a cada passo e marque como good/bad git bisect reset
- O Git vai dividir a linha do tempo em vários passos até descobrir o commit que causou o problema.
3. Aliases
git config --global alias.co checkout git config --global alias.st status
- Permite criar atalhos para comandos frequentes, economizando tempo no dia a dia.
Agora você pode digitargit co <branch>
ougit st
em vez de escrever o comando completo.
4. git shortlog
e git blame
- git shortlog: mostra um resumo dos commits agrupados por autor.
- git blame
<arquivo>
: exibe quem modificou cada linha de um arquivo e em qual commit.
Por que usar?
git shortlog
é excelente para entender a participação de cada membro do time.
git blame
é útil para descobrir rapidamente em que momento (e por quem) uma linha de código foi alterada.
Boas práticas
- Commits frequentes e descritivos: ajuda a manter um histórico claro e facilita o rastreio de alterações.
- Uso de branches para features: cada nova funcionalidade ou correção de bug deve ser desenvolvida numa branch própria (ex.:
feature/login
,fix/typo-header
).
- Sempre fazer pull antes do push: evita conflitos e problemas de sincronização entre o seu repositório local e o repositório remoto.
- Nunca commitar informações sensíveis: utilize o
.gitignore
para credenciais, chaves de API e outros dados privados.
- Revisar suas alterações: comandos como
git diff
egit log
podem te poupar de erros e commits desnecessários.
Resumo dos principais comandos
Depois de explorar os principais conceitos de Git — desde a criação de repositórios até a resolução de conflitos — você já tem uma visão ampla das operações essenciais para versionar seu código de forma organizada e colaborativa.
Abaixo, segue uma tabela-resumo das ações mais comuns no Git. Este guia rápido pode te ajudar quando bater aquela dúvida momentânea:
Ação | Comando |
Iniciar um repositório | git init |
Clonar um repositório | git clone <URL> |
Ignorar arquivos | .gitignore |
Verificar status do repositório | git status |
Adicionar um arquivo específico | git add <arquivo> |
Adicionar todas as alterações | git add . |
Criar um commit | git commit -m "<mensagem>" |
Visualizar diferenças | git diff |
Visualizar diferenças no staging | git diff --staged |
Criar uma nova branch | git branch <nome> |
Listar branches | git branch |
Deletar uma branch | git branch -d <nome> |
Forçar a deleção de uma branch | git branch -D <nome> |
Mudar para branch existente | git checkout <branch> |
Criar e mudar para nova branch | git checkout -b <branch> |
Mesclar branches | git merge <branch> |
Reorganizar histórico (rebase) | git rebase <branch> |
Continuar rebase | git rebase --continue |
Abortar rebase | git rebase --abort |
Adicionar repositório remoto | git remote add origin <URL> |
Listar repositórios remotos | git remote -v |
Renomear repositório remoto | git remote rename <old> <new> |
Remover repositório remoto | git remote remove <nome> |
Enviar commits para o remoto | git push origin <branch> |
Receber commits e mesclar (pull) | git pull origin <branch> |
Baixar apenas metadados (fetch) | git fetch origin |
Descartar alterações não adicionadas | git checkout -- <arquivo> |
Remover arquivo da área de staging | git reset <arquivo> |
Retornar a commits anteriores | git reset [--soft|--mixed|--hard] HEAD~1 |
Reverter um commit específico | git revert <hash> |
Criar stash | git stash |
Criar stash com mensagem | git stash push -m "<mensagem>" |
Listar stashes | git stash list |
Aplicar stash mais recente | git stash apply |
Aplicar e remover stash mais recente | git stash pop |
Limpar todos os stashes | git stash clear |
Esses comandos formam um fluxo de trabalho essencial para praticamente qualquer desenvolvedor.
Conclusão: quer se aprofundar ainda mais?
- Inscreva-se na nossa newsletter para receber conteúdos exclusivos sobre programação e ficar por dentro das novidades da Rocketseat.
- Faça parte da nossa comunidade: Junte-se a milhares de devs que trocam experiências, dúvidas e oportunidades diariamente em nossas redes e fóruns.
- Explore outros artigos do blog da Rocketseat, onde abordamos desenvolvimento web, mobile, back-end e várias tecnologias para impulsionar seu aprendizado.
Salve este guia nos favoritos para consultá-lo sempre que precisar — mesmo profissionais mais experientes podem precisar refrescar a memória de vez em quando!