Os 20 principais comandos do Git com exemplos: Um guia prático

Trabalhando com repositórios remotos

O GitHub hospeda vários aplicativos em seus servidores remotos, permitindo que os desenvolvedores os rastreiem e gerenciem. Nesta seção, veremos como extrair, transferir e interagir com esses repositórios remotos usando comandos do Git. 

Você quer saber como o GitHub funciona? Comece com uma Introdução aos conceitos do GitHub para entender repositórios, solicitações pull e práticas recomendadas de colaboração.

git remote add

O comando git remote add cria uma conexão entre o repositório Git local e o repositório Git remoto, permitindo que você faça push e pull de alterações entre eles:

git remote add <repo_name> <remote_url>

• Nome de usuário: um apelido para o repositório remoto ("origem" por padrão).
• URL do repositório remoto.

git push

O comando git push sincroniza o repositório remoto com o repositório local. Quando você executar esse comando, o repositório remoto refletirá todas as alterações que você fez localmente.

git push <remote> <branch>

• Alias para o repositório remoto ("origem" por padrão).
• Nome do ramo para o qual você deseja fazer push.

Há algumas variações de git push, por exemplo:

git push ---all origin

O comando acima faz push de todas as ramificações locais para o repositório remoto.

git push --force origin main

O comando acima substitui a ramificação main no repositório remoto pela ramificação local main. Tenha cuidado ao usá-lo, pois a ramificação principal remota pode perder todo o seu histórico. 

git pull

O comando git pull busca e mescla as alterações no repositório remoto com as do repositório local. 

O comando git pull combina dois comandos: git fetch e git merge. 

Primeiro, o git fetch recupera todas as alterações do repositório remoto, incluindo novos commits, tags e branches. Em seguida, o site git merge é executado, integrando essas alterações ao branch local atual. 

Aqui está a sintaxe:

git pull origin feature-branch

O comando acima obtém dados do site feature_branch no repositório remoto e faz o commit no branch local atual. 

git fetch

O comando git fetch permite que você revise as alterações no repositório remoto antes de mesclá-las com o local. Ele faz o download das alterações e as atualiza nas ramificações de controle remoto. Para quem não conhece, as ramificações de controle remoto são cópias das ramificações do repositório remoto. 

Por exemplo, o comando a seguir faz o download das alterações no repositório remoto e as atualiza nas ramificações de rastreamento remoto em origin:

git fetch origin

Ramificação e mesclagem no Git

A ramificação do Git permite que os desenvolvedores trabalhem de forma independente em novos recursos ou correções de bugs sem afetar o repositório principal. Quando as alterações estiverem prontas, a mesclagem as integrará à base de código principal. Vamos explorar os principais comandos envolvidos nesse processo.

ramificação do git

O comando git branch lista, cria ou exclui ramificações. Uma ramificação é outra versão do seu repositório. 

Se estiver desenvolvendo um novo recurso para o seu aplicativo, você poderá criar e trabalhar em uma nova ramificação. Você pode mesclar tudo ao ramo principal quando tudo estiver pronto e testado. Isso permite que você trabalhe em novos recursos de forma independente, sem interferir diretamente na linha principal.  

• git branch: produz a lista de todas as ramificações no repositório.
• git branch Cria uma nova ramificação chamada "nome_da_ramificação".
• git branch -d : Exclui o ramo denominado "branch_name".

checkout do git

Ocomando git checkoutpode fazer duas coisas: alternar entre ramificações ou restaurar arquivos para um estado anterior.

• Trocar de ramo: Antes do git 2.23, o comando git checkout branch_name era usado para mudar do ramo atual para outro. Mas isso não era apenas para mudar de uma filial existente; você também pode criar e mudar para uma nova filial.

O comando a seguir cria uma nova ramificação chamada "feature_branch" e alterna para ela:

git checkout -b feature_branch

No entanto, na versão mais recente do Git, git checkout é substituído por git switch para restaurar arquivos. 

• Restaurar arquivos: Você pode descartar as alterações feitas em um arquivo e restaurá-lo para sua versão anterior com o seguinte comando.

git checkout -- <file-name>

Você também pode fazer isso com um arquivo de outra ramificação da seguinte forma:

git checkout <branch-name> -- <file-name>

git merge

Se você tiver feito algum trabalho em um novo ramo, poderá mesclá-lo ao ramo principal usando git merge para implementar as alterações. O Git realiza a mesclagem de duas maneiras:

• Avanço rápido da fusão: Digamos que você tenha criado uma nova ramificação chamada "feature_x" a partir da ramificação principal e trabalhado nela. Se o ramo principal não teve nenhuma atualização desde que você criou "recurso_x", em vez de fazer o commit das alterações de "recurso_x" no ramo principal, o Git atualiza o ramo principal para apontar para a versão mais recente de "recurso_x". Nesse caso, nenhum novo commit de mesclagem é criado. 
• Mesclagem de três vias: Se tanto o "recurso_x" quanto o ramo principal tiverem edições, o Git combinará as alterações e criará um novo commit de mesclagem no ramo principal. 

Por exemplo: 

      C---D---F (feature-branch)
     /
A---B---E---G (main)

No commit B, o ramo de recursos C é criado. O ramo principal tem commits extras, E e G, mesmo depois de criar o ramo de recursos. Portanto, o recurso é mesclado ao principal, criando um novo commit de mesclagem M da seguinte forma:

      C---D---F (feature-branch)
     /         \         
A---B---E---G---M (main)

git rebase

git rebase é outra maneira de integrar as alterações entre as ramificações, mas funciona de forma diferente em comparação com git merge. A mesclagem mantém o histórico completo das ramificações principal e de recursos. O rebase, por outro lado, substitui o histórico do commit para torná-lo linear e limpo.

Além disso, a mesclagem requer um commit de mesclagem extra, enquanto o rebase não cria nenhum commit novo. O Git rebase executa duas etapas: 

1. Mudar para uma ramificação de recurso 
2. Refaça a base para o principal.

Por exemplo:

      C---D---F (feature-branch)
     /
A---B---E---G (main)

• Etapa 1: executa git checkout feature_branch.
• Etapa 2: Executa git rebase main: Mover toda a ramificação de recursos para a ramificação principal, reaplicando os commits C, D, F como C’, D’ e F’ em cima do último commit G na ramificação principal. Isso cria um histórico linear de commits da seguinte forma:

A---B---E---G---C'---D'---F' (main)

Como as operações de mesclagem e rebase são frequentementeconfundidas, aqui está um resumo das diferenças:

Você quer saber mais sobre como trabalhar com filiais remotas? Saiba como fazer check-out e rastrear filiais remotas usando git checkout neste tutorial passo a passo.

Histórico do Git e desfazimento de alterações

O Git fornece vários comandos para você visualizar o histórico e desfazer as alterações em diferentes estágios de desenvolvimento. Os comandos relevantes são discutidos aqui. 

Registro git

O comando git log exibe todo o histórico de commits do ramo atual. Ele inclui quatro campos principais: commit, autor, data e mensagem de commit. 

Histórico de commits do git

• Commit: um ID exclusivo.
• Autor: nome e e-mail da pessoa.
• Data: O registro de data e hora de quando a alteração foi confirmada.
• Mensagem do commit: descrição do commit. 

git diff

O site git diff exibe as diferenças entre vários estados do seu repositório, quer você esteja comparando o diretório atual com a área de preparação, a área de preparação com o último commit ou até mesmo dois arquivos ou ramificações, o que você especificar.

• git diff - mostra a diferença entre o diretório de trabalho atual e a área de preparação. 
• git diff -- cachedMostra as diferenças entre a área de preparação e o último commit.
• git diff commit1 commit2 - A diferença entre commit 1 e commit 2.
• git diff branch1..branch2 - Compara as diferenças entre branch 1 e branch 2.

git reset

O comando git reset permite que você desfaça as alterações, redefinindo o HEAD atual para um estado anterior específico. Para mover o HEAD para um commit anterior, você tem três variações: "soft", "mixed" e "hard" para você usar com o comando reset. 

• Suave: volta para um commit anterior, mas mantém as alterações atuais em estágios, permitindo que você faça um novo commit mais tarde, quando necessário. 

git reset --soft HEAD~1

• Misto: volta para um commit anterior e remove as alterações do commit atual da área do palco. No entanto, essas alterações não são afetadas em seu diretório de trabalho.

git reset --mixed HEAD~1

• Difícil: Isso apontará para um commit anterior e removerá as atualizações do commit atual do diretório de trabalho e da área de preparação. 

git reset --hard HEAD~1

Você precisa desfazer alterações no Git? Explore as diferenças entre git reset e git revert em teste guia detalhado.

Armazenamento e limpeza do Git

Ao trabalhar com o Git, você pode precisar deixar de lado temporariamente as alterações sem confirmá-las ou limpar arquivos desnecessários que estejam obstruindo o repositório. É nesse ponto que os comandos de armazenamento e limpeza do Git são úteis.

git stash

Suponha que você queira ir para um estado anterior, mas não queira confirmar o progresso atual; você pode usar git stash. Isso salva temporariamente as alterações não confirmadas e redefine o diretório de trabalho para o último estado confirmado. 

git stash pop

Se você tiver armazenado algumas alterações no passado e quiser incluí-las em seu diretório de trabalho, use o comando git stash pop. Isso aplicará as últimas alterações armazenadas ao diretório atual e as removerá da lista de armazenamento. 

git clean

O comando git clean exclui arquivos não rastreados do repositório Git. Use o comando git clean -n para visualizar o que será excluído antes de executar o comando clear!

Você quer limpar seu histórico do Git? Saiba como combinar vários commits emem um só com este tutorial de squash do Git.

Configuração do Git e definições do usuário

O Git permite que você defina as configurações do usuário em diferentes níveis. Vamos explorá-los aqui.

git config

O comando git config permite que você personalize as configurações do Git de acordo com suas necessidades. Você pode definir as configurações em três níveis: local, sistema e global. 

• Nível do sistema: É o nível de configuração mais amplo com acesso em nível de raiz.
• Nível global: As configurações nesse nível são aplicadas a todos os repositórios do usuário atual.
• Nível local: As configurações relevantes para o repositório Git atual podem ser personalizadas nesse nível. 

Esses são alguns comandos comuns do site git config:

• git config -list: Exibe as configurações do Git de todos os níveis.
• git config --global user.name "Your_name": Define o nome de usuário do Git para todos os repositórios no seu sistema como "Your_name".
• git config --global user.email "your.email@example.com": Define o endereço de e-mail para todos os repositórios em seu sistema.

Sabemos que master é o branch principal padrão ao inicializar um repositório Git. Mas você pode renomeá-lo para o que quiser usando o seguinte comando:

git config --global init.defaultBranch "srujana_master"

No comando acima, substituímos o ramo mestre padrão por "srujana_master" no nível global (para todos os repositórios no sistema).

Você pode aplicar outras configurações de nível global. Por exemplo, para alterar seu editor de texto padrão para o VS code, execute o seguinte comando:

git config -global core.editor "code-w"

Você também pode criar seus próprios comandos Git. Por exemplo:

git config --global alias.slice branch

O comando acima cria um novo alias slice para branch. Portanto, se você quiser criar um novo ramo, poderá executar git slice branch_name em vez de git branch branch_name.

Resumo dos comandos do Git

Aqui está um resumo dos comandos do Git que exploramos para você ter sempre à mão:

Práticas recomendadas para usar o Git

Ao usar o Git de forma eficaz, você vai além do rastreamento de alterações - trata-se de manter um fluxo de trabalho limpo, estruturado e colaborativo. Seguir as práticas recomendadas ajuda a garantir que o repositório permaneça organizado, que o histórico de confirmações seja significativo e que o processo de desenvolvimento ocorra sem problemas.

Aqui estão alguns hábitos importantes que você deve adotar ao trabalhar com o Git:

• Comprometa-se com frequência: Um dos principais objetivos do uso de um controle de versão como o Git é rastrear as alterações de forma eficaz ao longo do tempo. Quando você faz o commit de cada alteração separadamente, em vez de atualizar várias alterações juntas, é mais fácil entender o que foi modificado em cada commit posteriormente. 
• Comprometa-se com mensagens claras: Toda vez que você fizer um compromisso, combine-o com uma mensagem clara que descreva o motivo desse compromisso. Na próxima vez que você rastrear os commits, será muito mais simples saber quais alterações cada commit fez no código. 
• Use ramos: Para qualquer novo recurso ou correção de bug, crie uma ramificação, trabalhe nela e faça a mesclagem. Essa é a prática recomendada para separar o novo trabalho de desenvolvimento do projeto principal. 
• Utilize o .gitignore: Um arquivo .gitignorecontém arquivos e diretórios relacionados ao projeto que você não precisa controlar. Normalmente, eles incluem artefatos de compilação gerados automaticamente, arquivos de registro, temporários e específicos da plataforma. Ignorando-os, você evitará logs desnecessários e versões de rastreamento, mantendo seu histórico limpo.

Conclusão

O Git é uma ferramenta poderosa para que você possa acompanhar as alterações, colaborar com outras pessoas e manter um fluxo de trabalho de desenvolvimento bem estruturado. Neste artigo, abordei os comandos essenciais do Git e as práticas recomendadas para ajudar você a gerenciar seus projetos com mais eficiência.

É claro que sempre há mais para aprender! Se você está apenas começando, confira Introdução ao Git para criar uma base sólida. Para aqueles que desejam aprimorar ainda mais suas habilidades, o Git Intermediário se aprofunda em técnicas e fluxos de trabalho avançados.

Você precisa de uma referência rápida do Git para projetos futuros? Mantenha os comandos essenciais à mão com esta folha de dicas do Git!