Git Cherry-Pick: Como selecionar e aplicar commits específicos

Sintaxe do Git Cherry-Pick

Entender a sintaxe do git cherry-pick é fundamental para que você possa usar esse comando com eficiência. Não se trata apenas de selecionar commits, mas de aplicá-los com precisão para alcançar o resultado desejado.

A sintaxe básica para selecionar um único commit é:

git cherry-pick <commit-hash>

• git cherry-pick: O comando que inicia a operação.
• : O identificador exclusivo (hash SHA-1) do commit que você deseja selecionar. Você pode encontrar esse hash executando git log para listar o histórico de commits.

Ao executar o comando acima, o Git aplica as alterações do commit especificado ao branch atual, criando um novo commit com as mesmas alterações, mas com um hash diferente. 

É importante observar que o comando transfere apenas o commit em si, não o contexto ou o histórico principal da ramificação original.

Você é novo no Git e no GitHub? Comece a usar o controle de versão neste tutorial amigável do GitHub e do Git.

Como usar o Git Cherry-Pick: Exemplos passo a passo

Agora que você entende a sintaxe básica de git cherry-pick, é hora de ver o comando em ação.

Esta seção fornece exemplos práticos que orientam você em cenários básicos comuns e mais complexos em que o cherry-picking é útil. Cada exemplo ilustra como aplicar as alterações de um ou mais commits a outro branch. 

Exemplo 1: Selecionando um único commit

Digamos que você tenha feito uma correção em um ramo de recursos que deseja aplicar ao ramo principal sem mesclar todo o ramo de recursos.

• Primeiro, encontre o hash do commit que você deseja selecionar executando:

git log

• Localize o hash do commit. 
• Mude para a filial principal:

git checkout main

• Execute o comando cherry-pick (suponha que o hash seja abc1234):

git cherry-pick abc1234

Quando você executar esse comando, o Git aplicará as alterações do commit identificado por abc1234 ao seu ramo atual (que, nesse caso, é main ). O Git cria um novo commit no branch principal que contém as mesmas alterações que o commit original, mas com um novo hash de commit.

Exemplo 2: Seleção de vários commits

Em algumas situações, você pode precisar aplicar vários commits distintos de uma ramificação para outra. Suponha que você tenha três commits separados em seu ramo de recursos que você precisa trazer para o ramo principal.

• Encontre os hashes do commit para cada commit que você deseja selecionar usando git log:

git log

• Mude para a filial principal:

git checkout main

• Execute o comando cherry-pick, listando os commits:

git cherry-pick abc1234 def5678 ghi7890

Exemplo 3: Escolha seletiva de um intervalo de confirmação

Digamos que você tenha feito uma série de commits no ramo de recursos e queira aplicá-los ao ramo principal de uma só vez, sem especificar cada commit individualmente. Como você faria isso?

• Use git log para identificar os commits iniciais e finais que você deseja selecionar (por exemplo, abc1234 para ghi7890).
• Mude para a filial principal:

git checkout main

• Execute o comando cherry-pick com um intervalo de commits:

git cherry-pick abc1234...ghi7890

Exemplo 4: Escolha de um commit de um ramo remoto

Às vezes, existe uma correção crítica em um ramo remoto e você deseja aplicá-la ao seu ramo local sem mesclar todo o ramo. Veja como você pode fazer isso:

• Obter as alterações mais recentes do repositório remoto

git fetch origin

• Liste os commits no ramo remoto para encontrar o hash de que você precisa:

git log origin/feature_branch --oneline

• Suponha que o hash de confirmação de que você precisa seja abc1234.
• Mude para sua agência principal local:

git checkout main

• Escolha o commit do ramo remoto:

git cherry-pick abc1234

Isso permite que você aplique um commit de um ramo remoto sem mesclar o ramo inteiro.

Você precisa verificar uma filial remota? Siga este guia passo a passop sobre o checkout do Git para filiais remotas.

Exemplo 5: Escolher um commit e modificá-lo

Se você escolher um commit, mas precisar fazer pequenas modificações antes de fazer o commit, poderá usar o modo interativo do Git. Veja como:

• Mudar para o ramo de destino:

git checkout main

• Escolha o commit, mas pare antes de fazer o commit:

git cherry-pick -n abc1234

O sinalizador -n (ou --no-commit) aplica as alterações, mas não cria um commit.

• Modifique os arquivos conforme necessário.
• Stage e confirmar as alterações manualmente:

git add .
git commit -m "Modified cherry-picked commit from feature_branch"

Isso é útil quando você precisa ajustar um commit escolhido a dedo antes de finalizá-lo.

Como lidar com conflitos durante o Git Cherry-Pick

Os conflitos são inevitáveis quando você escolhe os commits entre as ramificações, especialmente quando a base de código divergiu significativamente. 

Embora o site cherry-pick tenha sido projetado para aplicar as alterações de forma limpa, ele nem sempre pode reconciliar as diferenças automaticamente. Nesses casos, os conflitos devem ser resolvidos manualmente. Entender como surgem os conflitos e como lidar com eles é fundamental para concluir uma operação cherry-pick.

Como os conflitos acontecem

Os conflitos geralmente ocorrem quando as alterações do commit cherry-picked se sobrepõem ou contradizem as alterações já presentes no branch de destino. Por exemplo:

• A mesma linha foi modificada em ambas as ramificações: Se a mesma linha de código for modificada nas ramificações de origem e de destino, o Git não saberá qual versão aplicar.
• Arquivo excluído em uma ramificação, mas modificado em outra: Se um arquivo for excluído em uma ramificação, mas modificado no commit escolhido a dedo, o Git não saberá se deve mantê-lo ou aplicar as alterações.
• Alterações não relacionadas, mas o mesmo arquivo: Mesmo quando as alterações parecem não estar relacionadas, se elas ocorrerem no mesmo arquivo, o Git poderá sinalizá-las como um possível conflito.

Quando ocorrer um conflito, o Git interromperá a operação cherry-pick, deixando o seu diretório de trabalho em um estado conflitante que deve ser resolvido antes de continuar.

Resolução de conflitos

Quando surgir um conflito, o Git fornecerá indicadores dos arquivos conflitantes, e você precisará resolver manualmente as discrepâncias. Veja como você pode resolver conflitos:

1. Verifique os arquivos conflitantes: Execute o seguinte comando para ver quais arquivos estão em conflito:

git status

O comando exibirá a lista de arquivos com conflitos. 

2. Resolver os conflitos: Você pode editar manualmente os arquivos conflitantes para resolver os problemas. Remova os marcadores de conflito (<<<<<<<, =======, >>>>>>>) e determine quais alterações você deve manter ou como combiná-las.

3. Use o Git Mergetool (opcional): Se a resolução de conflitos manualmente for complicada, você poderá usar uma ferramenta de mesclagem para ajudar na visualização e na resolução de conflitos:

git mergetool

Dependendo da sua configuração, a ferramenta acima abrirá uma ferramenta de mesclagem visual, o que facilita a revisão e a resolução de conflitos.

4. Marque os conflitos como resolvidos: Depois de resolver os conflitos, marque os arquivos como resolvidos usando:

git add <conflicted-file>

5. Complete a coleta de cerejas: Depois que todos os conflitos forem resolvidos e os arquivos forem preparados, finalize a seleção por cereja executando:

git cherry-pick --continue

Muitos IDEs e ferramentas modernos, como o Visual Studio Code e o GitHub, oferecem recursos integrados de resolução de conflitos de mesclagem. A interface da Web do GitHub permite que você resolva conflitos diretamente nas solicitações pull, facilitando a colaboração em repositórios compartilhados sem precisar mudar para um ambiente local.

Ignorar um commit após um conflito

Às vezes, a resolução de um conflito pode ser muito complexa ou você pode perceber que o compromisso não é necessário, afinal. Nesses casos, você pode ignorar totalmente o commit.

1. Abortar o processo de seleção de cereja atual: Se o conflito for muito complicado e você não quiser aplicar o commit, poderá ignorá-lo executando:

git cherry-pick --skip

Isso abandonará o commit conflitante e passará para o próximo (se você estiver selecionando vários commits).

2. Abortar toda a seleção de cerejas: Se quiser abortar completamente a operação cherry-pick, você pode executar:

git cherry-pick --abort

Esse comando restaurará o diretório de trabalho para o estado em que se encontrava antes de você iniciar o cherry-pick. 

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

Práticas recomendadas para usar o Git Cherry-Pick

O uso indevido do site cherry-pick pode gerar históricos complicados e confusão no controle de versão do seu projeto. Para evitar essas armadilhas, a adesão às práticas recomendadas garante que você esteja usando o cherry-pick de forma eficaz, sem introduzir complexidade desnecessária à sua base de código.

Mantenha-o pequeno e específico

O cherry-picking é mais eficaz quando usado para commits pequenos e específicos que tratam de tarefas bem definidas, como correções de bugs ou aprimoramentos de recursos menores. 

Evite selecionar commits grandes e complexos que agrupem várias alterações, pois isso pode gerar conflitos e dificultar o gerenciamento da base de código. Quanto mais direcionado for o compromisso, mais fácil será aplicá-lo sem efeitos colaterais indesejados.

Documente suas escolhas

Para manter um histórico claro, sempre forneça o contexto adequado quando você fizer uma seleção seletiva. Isso pode ser feito por meio de mensagens detalhadas de confirmação ou anotações na documentação. 

A essência principal é que você deve explicar por que foi necessário fazer uma seleção seletiva. Isso é particularmente importante quando você seleciona ramos de longa duração ou ambientes colaborativos, pois ajuda os futuros colaboradores a entender por que as alterações foram aplicadas seletivamente.

Revisar o histórico de confirmações

Antes de fazer o cherry-picking, revise o histórico de commits das ramificações de origem e de destino. Essa etapa ajuda a identificar se o commit que você está prestes a selecionar depende de outras alterações. A falta de dependências pode resultar em funcionalidade incompleta ou bugs, portanto, certifique-se de que a escolha seletiva não introduza recursos ou atualizações incompletos.

Evite o uso excessivo de seleção seletiva

Embora o cherry-picking seja conveniente para aplicar alterações específicas, seu uso excessivo pode levar a um histórico fragmentado com commits duplicados entre as ramificações. Isso pode dificultar o rastreamento da origem de determinadas mudanças ou a compreensão do contexto de desenvolvimento mais amplo. 

Sempre avalie se a mesclagem ou o rebase é uma estratégia mais apropriada antes de fazer uma seleção seletiva. Use o site cherry-pick com moderação e de forma intencional para evitar sobrecarregar o histórico do commit.

Você está tendo problemas com arquivos desnecessários no Git? Saiba como usar o .gitignore de forma eficaz com o neste tutorial sobre como ignorar o Git.

Solução de problemas comuns com o Git Cherry-Pick

A solução de problemas que surgem ao usar o site cherry-pick requer uma compreensão clara dos mecanismos subjacentes do Git. Nesta seção, abordarei alguns problemas comuns que você pode encontrar ao fazer cherry-picking e como resolvê-los.

Escolhendo um commit que não existe

Às vezes, você pode tentar escolher um commit que não esteja acessível na ramificação atual ou que já tenha sido mesclado. Normalmente, isso resulta em uma mensagem de erro informando que o commit não pôde ser encontrado ou aplicado.

1. Compromisso não encontrado: Isso acontece quando o hash do commit que você está tentando selecionar não existe no repositório atual ou no contexto do branch. Certifique-se de que você está fazendo referência ao commit correto, verificando o histórico de commits com git log na ramificação em que o commit existe. Solução:

• Verifique novamente o hash do commit para garantir que esteja correto.
• Verifique se o commit existe em uma ramificação à qual você tem acesso.
• Se o commit estiver em uma ramificação remota, verifique se a ramificação foi obtida com git fetch.

2. Compromisso já aplicado: Se o commit já tiver sido mesclado ou escolhido a dedo no ramo de destino, o Git impedirá que você o duplique. Essa proteção mantém o histórico limpo e evita alterações redundantes. Solução:

• Use git log para verificar se o commit já está no ramo de destino.
• Se necessário, ignore a operação cherry-pick, pois as alterações já foram aplicadas.

Escolha seletiva após um rebase ou uma mesclagem

A escolha seletiva após um rebase ou mesclagem pode introduzir complexidades devido ao histórico alterado de suas ramificações. O rebase reescreve os históricos dos commits, enquanto a mesclagem combina os ramos, o que pode afetar a aplicabilidade de um cherry-pick.

1. Conflitos devido a commits refeitos: Após um rebase, o histórico de commits é reescrito, o que pode causar problemas se você tentar selecionar commits que foram alterados durante o processo de rebase. Você pode entrar em conflito quando o cherry-pick tentar aplicar alterações que não estejam alinhadas com o histórico reescrito. Solução:

• Revise cuidadosamente o histórico de commits após um rebase usando git log para garantir que o commit que você está escolhendo não tenha sido modificado.
• Resolva os conflitos como você faria em um processo cherry-pick padrão, usando git status e edições manuais.

2. Duplicar commits após uma mesclagem: A mesclagem de ramificações pode levar a uma situação em que um commit que você deseja selecionar já foi incluído no histórico mesclado. Se você selecioná-lo novamente, poderá fazer commits duplicados, o que pode bagunçar o seu histórico e dificultar o rastreamento das alterações. Solução:

• Antes de fazer o cherry-picking, inspecione o histórico de commits em ambas as ramificações para confirmar se o commit já foi mesclado.
• Evite escolher o mesmo commit se ele já estiver no ramo de destino.

Você precisa desfazer alterações no Git? Saiba quando você deve usar git reset em vez de git revert no tutorialis Git reset and revert.

Conclusão

git cherry-pick é uma maneira poderosa de aplicar commits específicos de um ramo para outro sem mesclar o ramo inteiro. Quer você esteja movendo uma correção de bug, uma atualização de recurso ou apenas aplicando alterações seletivamente, isso ajuda a manter o histórico do Git limpo e focado.

Neste guia, falei sobre como selecionar commits únicos e múltiplos, resolver conflitos e seguir as práticas recomendadas para evitar armadilhas comuns. Usando o cherry-pick com sabedoria, você pode melhorar seu fluxo de trabalho e manter seu repositório organizado.

Se você deseja aprofundar suas habilidades no Git, confira Foundations of Git para ter um bom ponto de partida. Você também pode explorar a Introdução aos conceitos do GitHub ou adotar uma abordagem estruturada com o programa de habilidades GitHub Foundations.

Agora que você já sabe como fazer o cherry-pick como um profissional, experimente fazer isso em seu próximo projeto!