Quando você usaria as diferentes estratégias de mesclagem do git?

Na página de manual do git-merge, há várias estratégias de mesclagem que você pode usar.

• resolver - Isso pode resolver apenas duas cabeças (ou seja, a ramificação atual e outra ramificada da qual você retirou) usando o algoritmo de mesclagem de 3 vias. Ele tenta detectar cuidadosamente ambiguidades cruzadas de mesclagem e é considerado geralmente seguro e rápido.

• recursivo - Isso pode resolver apenas duas cabeças usando o algoritmo de mesclagem de 3 vias. Quando há mais de um ancestral comum que pode ser usado para mesclagem de 3 vias, ele cria uma árvore mesclada dos ancestrais comuns e a usa como a árvore de referência para a mesclagem de 3 vias. Foi relatado que isso resulta em menos conflitos de mesclagem sem causar fusões incorretas por testes feitos em confirmações de mesclagem reais retiradas do histórico de desenvolvimento do kernel Linux 2.6. Além disso, isso pode detectar e manipular fusões envolvendo renomeações. Essa é a estratégia de mesclagem padrão ao extrair ou mesclar uma ramificação.

• polvo - Isso resolve mais de dois casos, mas se recusa a fazer mesclagens complexas que precisam de resolução manual. Destina-se principalmente a ser usado para agrupar cabeças de ramificação de tópicos. Essa é a estratégia de mesclagem padrão ao extrair ou mesclar mais de uma ramificação.

• our - Isso resolve qualquer número de cabeças, mas o resultado da mesclagem é sempre a cabeça de ramificação atual. Ele deve ser usado para substituir o histórico antigo de desenvolvimento de ramificações laterais.

• subárvore - Esta é uma estratégia recursiva modificada. Ao mesclar as árvores A e B, se B corresponder a uma subárvore de A, B será ajustado primeiro para corresponder à estrutura de árvore de A, em vez de ler as árvores no mesmo nível. Esse ajuste também é feito na árvore ancestral comum.

Quando devo especificar algo diferente do padrão? Quais são os melhores cenários?

Não estou familiarizado com a resolução, mas usei os outros:

Recursivo

Recursiva é o padrão para mesclagens sem avanço rápido. Estamos todos familiarizados com isso.

Polvo

Eu usei polvo quando tive várias árvores que precisavam ser mescladas. Você vê isso em projetos maiores, onde muitas filiais tiveram desenvolvimento independente e está tudo pronto para se unir em um único cabeçalho.

Um ramo de polvo mescla várias cabeças em um commit, desde que seja possível.

Para ilustração, imagine que você tenha um projeto que tenha um mestre e, em seguida, três ramos para mesclar (chame-os de a, bec).

Uma série de mesclagens recursivas seria assim (observe que a primeira mesclagem foi um avanço rápido, pois não forcei a recursão):

No entanto, uma única mesclagem de polvo ficaria assim:

commit ae632e99ba0ccd0e9e06d09e8647659220d043b9
Merge: f51262e... c9ce629... aa0f25d...

Nosso

Nosso == Quero puxar outra cabeça, mas jogar fora todas as mudanças que a cabeça introduz.

Isso mantém o histórico de uma ramificação sem nenhum dos efeitos da ramificação.

(Leia: nem sequer são analisadas as alterações entre esses ramos. Os ramos são apenas mesclados e nada é feito nos arquivos. Se você deseja mesclar no outro ramo e sempre que houver a pergunta "nossa versão do arquivo ou sua versão "você pode usar git merge -X ours)

Subárvore

A subárvore é útil quando você deseja mesclar outro projeto em um subdiretório do seu projeto atual. Útil quando você tem uma biblioteca que não deseja incluir como submódulo.

Na verdade, as únicas duas estratégias que você gostaria de escolher são as nossas, se você deseja abandonar as alterações trazidas por ramificação, mas mantém a ramificação no histórico e a subárvore, se estiver mesclando um projeto independente no subdiretório do superprojeto (como 'git-gui' em ' repositório git ').

a mesclagem de polvo é usada automaticamente ao mesclar mais de duas ramificações. A resolução está aqui principalmente por razões históricas e para quando você é atingido por casos de canto de estratégia de mesclagem recursiva .

Estratégia de mesclagem "resolver" vs "recursiva"

Recursiva é a atual estratégia de duas cabeças padrão, mas depois de algumas pesquisas, finalmente encontrei algumas informações sobre a estratégia de mesclagem "resolver".

Retirado do livro O'Reilly, Version Control with Git ( Amazon ) (parafraseado):

Originalmente, "resolver" era a estratégia padrão para mesclagens do Git.

Em situações de mesclagem cruzada, em que há mais de uma base de mesclagem possível, a estratégia de resolução funciona da seguinte maneira: escolha uma das possíveis bases de mesclagem e espere o melhor. Na verdade, isso não é tão ruim quanto parece. Geralmente, os usuários trabalham em diferentes partes do código. Nesse caso, o Git detecta que está realizando algumas alterações já existentes e ignora as alterações duplicadas, evitando o conflito. Ou, se essas são pequenas alterações que causam conflitos, pelo menos o conflito deve ser fácil para o desenvolvedor lidar.

Eu mesclei árvores com êxito usando "resolve" que falhou com a estratégia recursiva padrão. Eu estava recebendo fatal: git write-tree failed to write a treeerros e, graças a esta postagem no blog ( espelho ), tentei "-s resolve", que funcionou. Ainda não sei exatamente por que ... mas acho que foi porque eu tive alterações duplicadas nas duas árvores e resolvi "ignorá-las" adequadamente.

Como as respostas acima não estão mostrando todos os detalhes da estratégia. Por exemplo, alguma resposta está faltando os detalhes sobre a importação resolveopção eo recursiveque tem muitas opções de sub como ours, theirs, patience, renormalize, etc.

Portanto, eu recomendaria visitar a gitdocumentação oficial que explica todos os recursos possíveis:

https://git-scm.com/docs/merge-strategies