estratégia de fusão Git recursiva
O mecanismo de mesclagem (git misge e git pull commands) permite que as "estratégias de mesclagem" do backend sejam escolhidas com a opção - s. Algumas estratégias também podem tomar suas próprias opções, que podem ser aprovadas ao dar - X & lt; option & gt; argumentos para combinar e / ou git pull.
Isso só pode resolver duas cabeças (ou seja, o ramo atual e outro ramo que você retirou) usando um algoritmo de mesclagem de 3 vias. Ele tenta detectar cuidadosamente as ambiguidades de mesclagem cruzada e é considerado geralmente seguro e rápido.
Isso só pode resolver duas cabeças usando um algoritmo de mesclagem de 3 vias. Quando há mais de um antepassado comum que pode ser usado para a mesclagem de 3 vias, ele cria uma árvore mesclada dos antepassados comuns e usa isso como a árvore de referência para a mesclagem de 3 vias. Isso foi relatado como resultado de menos conflitos de fusão sem causar mismerges por testes feitos em compromissos de fusão reais tirados do histórico de desenvolvimento do kernel do Linux 2.6. Além disso, isso pode detectar e manipular fusões envolvendo renomeações. Esta é a estratégia de mesclagem padrão ao puxar ou mesclar um ramo.
A estratégia "recursiva" pode ter as seguintes opções:
Esta opção força os tipos de conflitos a serem automaticamente resolvidos, favorecendo a "nossa" versão. As mudanças da outra árvore que não estão em conflito com o nosso lado são refletidas no resultado de mesclagem. Para um arquivo binário, todo o conteúdo é retirado do nosso lado.
Isso não deve ser confundido com a estratégia de "nossa", que nem sequer olha o que a outra árvore contém. Ele descarta tudo o que a outra árvore fez, declarando que "nossa" história contém tudo o que aconteceu nele.
Este é o oposto do "nosso"; note que, ao contrário do "nosso", não há "deles" mescla a estratégia para confundir esta opção de fusão.
Com esta opção, "merge-recursive" gasta um pouco de tempo extra para evitar mismerges que às vezes ocorrem devido a linhas de correspondência sem importância (por exemplo, chaves de funções distintas). Use isso quando os ramos a serem fundidos divergiram de forma selvagem. Veja também git-diff [1] - paciência.
Diz a "fusão-recursiva" para usar um algoritmo de diferença diferente, o que pode ajudar a evitar mismerges que ocorrem devido a linhas de correspondência sem importância (como aparelhos de diferentes funções). Veja também git-diff [1] --diff-algorithm.
ignore-space-change ignore-all-space ignore-space-at-eol ignore-cr-at-eol.
Trata as linhas com o tipo de mudança de espaço indicado como inalterada por causa de uma fusão de três vias. As mudanças de espaço em branco misturadas com outras alterações em uma linha não são ignoradas. Veja também git-diff [1] - b, - w, --ignore-space-at-eol e --ignore-cr-at-eol.
Se a "sua" versão apenas introduzir mudanças de espaço em branco para uma linha, a "nossa" versão é usada;
Se a nossa versão introduzir mudanças no espaço em branco, a versão '' deles '' inclui uma alteração substancial, a 'sua' versão é usada;
Caso contrário, a fusão prossegue da maneira usual.
Isso executa um check-out virtual e check-in de todos os três estágios de um arquivo ao resolver uma mesclagem de três vias. Esta opção destina-se a ser usada quando mesclar ramos com diferentes filtros limpos ou regras de normalização de fim de linha. Consulte "Mesclando ramos com diferentes atributos check-in / checkout" em gitattributes [5] para detalhes.
Desativa a opção renormalize. Isso substitui a variável de configuração fusionar.
Desative a detecção de renomeação. Veja também git-diff [1] --no-renomeação.
Ativar a detecção de renomeação, opcionalmente, definir o limite de similaridade. Este é o padrão. Veja também git-diff [1] --find-renames.
Sinônimo desaprovado para find-renames = & lt; n & gt; .
Esta opção é uma forma mais avançada de estratégia "subárvore", onde a estratégia adivinha a forma como duas árvores devem ser deslocadas para combinar uma com a outra quando se fundem. Em vez disso, o caminho especificado é prefixado (ou despojado desde o início) para tornar a forma de duas árvores coincidir.
Isso resolve casos com mais de duas cabeças, mas se recusa a fazer uma fusão complexa que precisa de resolução manual. É principalmente destinado a ser usado para agrupar as cabeças de tópicos. Essa é a estratégia de mesclagem padrão ao puxar ou juntar mais de uma ramificação.
Isso resolve qualquer número de cabeças, mas a árvore resultante da mesclagem é sempre a da cabeça atual do ramo, ignorando efetivamente todas as mudanças de todos os outros ramos. É destinado a substituir o antigo histórico de desenvolvimento de filiais laterais. Observe que isso é diferente da opção - Xours para a estratégia de intercalação "recursiva".
Esta é uma estratégia recursiva modificada. Ao mesclar as árvores A e B, se B corresponde a uma subárvore de A, B é primeiro ajustado para coincidir com a estrutura em árvore de A, em vez de ler as árvores no mesmo nível. Este ajuste também é feito para a árvore-antepassada comum.
Com as estratégias que utilizam a fusão de 3 vias (incluindo o padrão, 'recursivo'), se uma alteração for feita em ambos os ramos, mas mais tarde será revertida em um dos ramos, essa mudança estará presente no resultado mesclado; Algumas pessoas acham esse comportamento confuso. Ocorre porque apenas as cabeças e a base de mesclagem são consideradas ao realizar uma mesclagem, e não o indivíduo comete. O algoritmo de mesclagem considera, portanto, a alteração revertida como nenhuma alteração, e substitui a versão alterada.
Blog da AlBlue & rsquo; s.
Macs, Modularidade e Mais.
Git Dica da Semana: Fusion Revisited.
A Dica Git da semana da semana é sobre a fusão. Você pode se inscrever no feed se quiser receber novas parcelas automaticamente.
Anteriormente, analisamos a fusão em abril, mas abordamos o índice na semana passada e os números de índice (ou estágio), que fazem parte das fusões. Esta semana, vamos ver o que isso significa com diferentes tipos de fusões. Se você não é familliar com fusões, dê uma olhada na publicação anterior primeiro.
A mesclagem permite reunir dois (ou mais) compromissos em um único commit de mesclagem, ao mesmo tempo que reúne todos os diferentes arquivos combinados nos dois. Se houver conflitos de mesclagem, estes devem ser resolvidos individualmente. Fósforos em que um dos commit é um antepassado do compromisso atual são referidos como fusões de avanço rápido e não resultam em um compromisso de mesclagem sendo criado. Quando você puxa de uma fonte remota, você está realmente fazendo uma busca e uma mesclagem em um passo e ndash; embora geralmente, você pode avançar rapidamente quando você faz.
Para os propósitos deste post, vou criar três ramos chamados & lsquo; Alex & rsquo ;, & lsquo; Bob & rsquo; e & lsquo; master & rsquo ;, em homenagem a Alice e Bob. Cada ramo terá um arquivo chamado Hello que conterá o texto & ldquo; Olá, meu nome é Alex & rdquo; (c. f. Bob), bem como um AlexsFile, BobsFile etc.
Quando você cria uma mesclagem, você tem a opção de dizer como a mesclagem será processada. A estratégia usual é recursiva. Isso significa que o Git irá caminhar para cada diretório (árvore) e descobrir quais arquivos têm diferenças em comparação com a revisão básica e, em seguida, usar aquele com alterações. (Se ambos tiverem alterações, o conteúdo do novo arquivo é mesclado textualmente, e se houver um problema com isso, um conflito se segue.) É por isso que você vê a mensagem & ldquo; Merge feita por recursive & rdquo; depois de fazer a operação:
O commit d612aa & hellip; é um nó de mesclagem em que traz dois ramos separados juntos. Uma vez que nenhum deles é um antepassado do outro, eles não podem ser encaminhados rapidamente e, como tal, o nó de mesclagem é criado. Podemos determinar os pais cometidos com HEAD ^ 1 e HEAD ^ 2:
É ainda mais fácil quando não há alterações a serem mescladas:
O avanço rápido aqui indica que o mestre está atrás de Bob, e então podemos simplesmente mover o ponteiro para a frente & ndash; Como resultado, não precisamos criar um nó de mesclagem.
Então, duas estratégias que o Git usa são fazer um avanço rápido ou uma fusão feita por recursiva. Isso cobre 99% das fusões que você precisará fazer; Mas vale a pena notar que a Git tem mais alguns truques é a manga, que pode ajudar em determinadas situações.
Os exemplos acima têm um ou dois pais. No entanto, um nó de mesclagem Git é capaz de representar mais de duas cabeças em uma mesclagem e usa uma estratégia chamada polvo. Isso é selecionado por padrão quando você mescla mais de dois ramos:
Nesse caso, temos três compromissos unindo o nó da mesclagem. o mestre (que tinha divergido), e os ramos de Alex e Bob de antes. Uma vez que nosso nó de mesclagem agora tem três pais, podemos usar git rev-parse para converter a HEAD ^ 1/2/3 na primeira, segunda e terceira cabeças.
E se os arquivos estiverem em conflito?
Podemos lançar uma ferramenta de três vias com git mergetool:
Observe que a mesclagem Octopus não manipula conflitos de mais de 2 arquivos. Se você fizer isso, você acabará com uma mensagem de erro diferente:
Finalmente, a última estratégia que vale a pena conhecer é a nossa estratégia. Isso leva qualquer número de cabeças e cria um nó de mesclagem, mas sem realmente fazer alterações. Em outras palavras, um HEIT ^ 1 de Shit Git sempre retornará vazio para uma estratégia do nosso:
Podemos verificar que estes são idênticos, uma vez que a árvore apontada por HEAD é a mesma que a árvore apontada pela HEAD ^ 1 (ou seja, o pai). O sufixo ^ é usado para mostrar a árvore associada ao commit.
O argumento --decorate to git log adiciona os nomes das ramificações à saída, o que pode ser útil para mostrar de onde as fusões vieram. O argumento --graph é principalmente usado com o argumento --online; embora você possa executar um git --graph, as mensagens de confirmação completas tendem a ocultar a estrutura do gráfico.
A nossa estratégia só é realmente útil se você deseja codificar um conjunto de compromissos anteriores, mas não os afeta no mestre atual (por exemplo, porque você escolheu alguns dos conteúdos e não quer levar outras peças, mas preservar eles na história, como é de alguma forma).
Mensagem de mesclagem e avanço rápido.
A mensagem de mesclagem será criada automaticamente, com base nos nomes das filiais que você está mesclando. No entanto, é possível passar uma opção - m, como com git commit, para fornecer uma mensagem adicional. Isso pode ser útil se a mensagem de mesclagem precisar de informações adicionais codificadas (como, por exemplo, quais bug (s) foram corrigidos).
Também é possível forçar uma fusão, mesmo que não seja necessário. Se você tem filiais baseados em tópicos, pode ser útil denotar que o trabalho foi realizado em um ramo separado antes de ser incorporado de novo ao mestre. Execução da mesclagem de git --no-ff criará um nó de mesclagem, seja ou não o ramo pode ser encaminhado ou não. Uma vez que o commit de mesclagem tem o nome do ramo que você está mesclando como parte do commit, você pode terminar com nomes descritivos para mostrar o recurso que foi concluído:
Ser capaz de mesclar com um --no-ff pode ser útil ao usar alguns tipos de fluxos de trabalho de confirmação, onde muitos ramos são usados para desenvolver recursos individuais e depois trazidos para um ramo principal posteriormente. Também vale a pena notar o argumento --merges permite filtrar apenas as fusões em um repositório:
Da próxima vez, veremos o que podemos fazer com os diferentes fluxos de trabalho do Git usando a mesclagem --no-ff.
Volte a próxima semana para outra parcela na série Git Tip of the Week.
Postagens recentes.
StackOverflow.
Em Delicious.
GitHub Repos.
Atualização do status. @alblue no GitHub.
Direitos autorais e cópia; 2017 - Alex Blewitt - Powered by Octopress.
estratégia de fusão Git recursiva
Obter através da App Store Leia esta publicação em nosso aplicativo!
git merge recursive theirs, como isso funciona?
Estou tendo um pouco de problema. Nós temos o nosso próprio CMS que está usando git para colaboração e versões e outras coisas.
Agora eu tenho dois repositórios git A e B, A que é um projeto e B que é o próprio CMS. Agora eu quero obter B em A, mas quando eu faço isso, eu tenho muitos conflitos de mesclagem e a solução para os conflitos é sempre usar o material de B.
Agora, o que eu acho que eu preciso é.
porque eu quero fundir e quando há um conflito de fusão, ele deve ser forçado a usar a solução de B. Mas eu não consigo fazer isso funcionar. Sempre me diz que é fatal: 'deles' não aponta para um commit.
Os recursivos deles, eu encontrei aqui.
Alguém sabe o que eu faço de errado?
Você deve usar esse formulário para passar opções de estratégia de mesclagem:
Certifique-se também de que a sua versão seja suprimida. É a característica bastante recente (?)
Eu acho que o motivo pelo qual está falhando é que você está especificando "recursive theirs" como a estratégia. "recursivo" é uma estratégia, e quando você coloca um espaço depois, "os seus" são interpretados como algo que git precisa mesclar sua cópia de trabalho com (por exemplo, outro ramo ou refspec).
Eu acho que você não poderá especificar uma estratégia exatamente como o que você deseja. Existe uma estratégia chamada "nossa", que é o oposto do que você está querendo.
O padrão usual usado nesta situação é combinar ou rebase no repositório "B". Dentro da cópia de trabalho do repositório "A", você faria um rebase, se possível (talvez não seja possível, se você já está compartilhando o repo git com outros desenvolvedores). Um rebase seria essencialmente rotear o repositório A de volta para um commit comum em ambos os repositórios, aplicar "B" comete, então "A" comete no topo. Você resolveria todos os conflitos de mesclagem ao longo do caminho.
Uma vez que você atravessa a dor de fusão ou rebaixamento no repositório "B", o futuro mescla será menos doloroso.
Capítulo 7. Fusão.
Fusionar é o processo de combinar as mudanças recentes de vários ramos em um único novo commit que está em todos esses ramos. Na maioria das vezes, há apenas dois ramos envolvidos, mas na verdade, pode haver qualquer número; se houver mais de dois, é chamado de "mesclagem de polvo". Quando há apenas dois ramos, o ramo atual é chamado de "nosso" lado da mesclagem, enquanto o outro ramo é chamado de "seu" lado. Como a mesclagem do polvo é incomum, geralmente assumiremos uma fusão de dois ramos nesta discussão.
Nós descrevemos como o Git pode iniciar uma fusão para você como parte do git pull (consulte "Pulling"), mas você também pode executar mesclagens explicitamente. Aqui está um cenário típico: você está trabalhando em um projeto de software e você tem uma idéia de um novo recurso, mas você não quer seu trabalho experimental nesse recurso para perturbar o seu principal desenvolvimento. Então você cria um recurso chamado ramificação para conter o trabalho:
Quando você precisa voltar a trabalhar na parte principal do seu projeto, você compromete seu trabalho no ramo de recursos e volte para o mestre (ou qualquer ramo em que você precise trabalhar):
Você continua assim por algum tempo. Eventualmente, se você decidir que não gosta da sua idéia de recurso, você pode descartar o trabalho excluindo o ramo com a ramificação git - recurso D. Se você decidir mantê-lo, no entanto, em algum momento, você vai querer incorporá-lo no código principal do projeto, e você faz isso com uma mesclagem:
É melhor ter todo o seu trabalho comprometido antes de executar a fusão git; ou seja, o status git não deve mostrar alterações pendentes ou arquivos não rastreados. A retirada de uma fusão para o seu estado inicial pode ser difícil caso contrário. Você pode usar o git stash como uma maneira rápida de salvar as mudanças de trabalho e restaurá-las mais tarde (consulte "git stash").
Essa fusão foi simples. Você adicionou os arquivos effulgent. c e epiphany. h no ramo de recursos, e eles não existiam no mestre, então o Git apenas os adicionou. Você fez alterações menores no main. c em ambos os ramos, mas essas mudanças não entraram em conflito, então o Git os combinou automaticamente e comprometeu sua versão mesclada. O gráfico ASCII com nomes de arquivos à esquerda é chamado de "difstat"; é um resumo das mudanças feitas por este commit. As linhas dos sinais mais e menos representam o número relativo de adições de linha ("inserções") e as exclusões feitas no arquivo correspondente.
Ambos os aspectos da fusão ocorreram aqui: conteúdo e estrutura. Primeiro, o Git combinou o conteúdo de ambos os ramos, adicionando e mesclando alterações em arquivos; então, gravou o fato da fusão estruturalmente, criando uma combinação combinando ambos os ramos juntos no gráfico de confirmação. Isso indica na história que os compromissos cujos conteúdos foram combinados para produzir o novo, tornando-os seus pais. Um "commit de mesclagem" é definido simplesmente como um commit com mais de um dos pais.
Você pode continuar esse processo o tempo que desejar, trabalhando no ramo de recursos separadamente e periodicamente mesclando seu trabalho em mestre. Se você fizer isso, você provavelmente também precisará se fundir do outro lado, atualizando o ramo de recursos com os trabalhos mais recentes no mestre, de modo que você não esteja trabalhando no código desatualizado; Para isso, basta fazer o inverso: mude para recurso e execute o mestre de mesclagem git.
Quando o seu novo recurso estiver totalmente incorporado ao desenvolvimento principal, e você não precisa mais trabalhar separadamente, você pode excluir o ramo de recursos com o recurso git branch - d; conforme discutido em "Excluindo um Ramo", o Git irá reclamar se você não tiver incorporado completamente o recurso no mestre, para evitar que você acidentalmente perca o trabalho. O recurso de exclusão não exclui nenhum de seus conteúdos ou histórico; ele simplesmente remove o nome "recurso" como um ponto de referência, um lugar no qual você pretende adicionar compromissos independentes mais tarde, já que você não precisa mais disso. Você pode reutilizar "recurso" como um nome de filial no futuro, se desejar, e não haverá colisão com o uso anterior; na verdade, além de possivelmente em mensagens de confirmação ou reflogs, uma vez que você exclui uma filial, não há registro no repositório próprio que já existiu! Os nomes das filiais servem para indicar quais partes do banco de dados do objeto ainda são de interesse e onde o desenvolvimento ainda está ocorrendo; se o conteúdo de uma filial for incorporado a outros ramos, e você não precisa mais de uma linha de desenvolvimento com esse nome, então você pode simplesmente excluí-lo e reutilizar o nome mais tarde para outra coisa se desejar. Da mesma forma, olhando para trás no gráfico de confirmação, não é possível saber em qual nome de filial um compromisso específico foi feito; mesmo em uma história linear, o nome do ramo atual pode ter sido alterado em algum momento do passado. Pode ser interessante ou útil saber isso em algumas situações, mas o Git simplesmente não mantém essa informação. Os ramos de Git são efêmeros em um sentido, apenas ferramentas para construir o gráfico de commit, que é o que importa.
Combinar Conflitos.
A fusão acima foi suave, mas e se você tivesse feito mudanças nos dois ramos que a Git não conseguiu combinar por conta própria? Estes são chamados de "conflitos de mesclagem", e Git iria parar e pedir-lhe para resolvê-los antes de cometer. Esse processo pode variar de simples a muito complexo, dependendo do conteúdo e das mudanças envolvidas; Felizmente, existem ferramentas disponíveis para ajudar, tanto no próprio Git quanto com o qual o Git pode trabalhar. Vamos passar por um exemplo simples. Suponha que você tenha um arquivo moebius com os seguintes conteúdos:
... e você comete compromissos nas filiais chandra e floyd mudando assim:
Você mudou as mesmas duas linhas de cada lado de maneiras diferentes, e a abordagem de mesclagem orientada por linha do Git não tentará adivinhar sua intenção ou combinar as linhas (por exemplo, formar uma única linha de monólitos de golfinhos, como sejam interessantes); Isso irá sinalizar um conflito de mesclagem:
A frase CONFLICTO (conteúdo) indica que o conflito é devido a alterações de conteúdo irreconciliáveis neste arquivo. Git também pode indicar outros motivos, como um conflito de adicionar / adicionar, no qual o mesmo nome de arquivo é adicionado a ambos os ramos, mas com conteúdo diferente.
Se você iniciar uma mesclagem e depois deseja cancelá-la - talvez você não estivesse esperando tantos conflitos e você não tem tempo para lidar com eles agora - basta usar git merge --abort.
Para obter uma visão geral do estado de mesclagem, use o status git. Qualquer mudança que Git resolva por conta própria será mostrada como já encenada para confirmação, e há uma seção separada no final para conflitos de mesclagem:
Caminhos não geridos são arquivos com conflitos que o Git não conseguiu resolver. Para descobrir o que deu errado em detalhes, use o git diff. Este comando não mostra apenas as diferenças entre várias combinações de árvore de trabalho, índice e compromete; Ele também possui um modo especial para ajudar com os conflitos de mesclagem:
Esta exibição mostra as versões alternativas da seção em conflito, separadas por ======= e marcadas com o ramo correspondente: nosso (o ramo atual) e deles (neste caso floyd, o ramo que estamos mesclando nos nossos) . Como de costume, git diff mostra diferenças entre a árvore de trabalho e o índice, que neste caso são os conflitos ainda por resolver; As mudanças já feitas e encenadas não são mostradas. Você pode usar o git diff --staged para ver aqueles; Adicione - stat para uma visão geral. Você verá que o Git atualizou o arquivo de trabalho com marcação semelhante:
Depois de editar o arquivo para resolver o conflito, use git add to stage sua versão fixa para confirmar e remova-a da lista de caminhos conflitantes (se a resolução for realmente excluir o arquivo, use git rm). Uma vez que você tenha abordado todos os conflitos e o status git já não relata nenhum caminho não gerido, você pode usar o commit git para completar a mesclagem. O Git apresentará uma mensagem de confirmação contendo detalhes sobre esta mesclagem, incluindo os seus ramos e conflitos, que você pode editar como você entender; nesse caso :
... e você pode ver que você criou um "commit de mesclagem" com mais de um dos pais:
O outro ramo, floyd, ficou onde estava, enquanto o ramo atual chandra avançou um compromisso de e355785d para aaba9d85, e esse último compromisso unifica os dois ramos. Um novo commit no floyd fará com que eles divertem novamente, e você pode se fundir novamente no futuro se precisar (em qualquer direção). Observe que, neste momento, um simples registro git mostrará compromissos de ambos os ramos, não apenas aqueles feitos em chandra:
Você pode ter esperado ver apenas confirma aeba9d85, e355785d e 50769fc9. Esta apresentação pode parecer estranha no início, mas é apenas uma maneira diferente de considerar a noção de "ramificação". Um ramo Git é definido como o conjunto de todos os compromissos alcançáveis no gráfico de confirmação da derivação; pense nisso como todos os compromissos que contribuíram com o conteúdo do compromisso da tip (que, após uma fusão, inclui todos os compromissos anteriores a esse em ambos os ramos).
Em casos simples, você pode obter o que você pensa como o histórico de "este ramo" com git log - primeiro pai, que apenas segue o primeiro pai de compromissos de fusão em vez de todos eles. No entanto, isso não é garantido e, em histórias mais complexas, não significará muito. Uma vez que o Git permite o histórico não linear, uma simples lista de compromissos geralmente não é muito útil, e você precisa de ferramentas de visualização para ajudá-lo a interpretá-lo (consulte "Ferramentas visuais").
Resolvendo conflitos de mesclagem.
O Git não possui ferramentas embutidas para interagir diretamente com os conflitos de mesclagem diretamente; é para isso que são utilizadas as ferramentas de mesclagem externas, que consideraremos em breve em "Ferramentas de mesclagem". No entanto, aqui estão algumas dicas para uso em casos simples.
git log - p - merge mostra todos os compromissos contendo alterações relevantes para qualquer arquivo não imerso, em qualquer ramo, juntamente com seus diffs. Isso pode ajudá-lo a identificar as mudanças no histórico que levaram aos conflitos. Se quiser descartar todas as mudanças de um lado da mesclagem, use git checkout - arquivo para atualizar o arquivo de trabalho com a cópia do ramo atual ou outro, seguido de git add file para marcar a mudança e marcar o conflito como resolvido. Tendo feito isso, se você gostaria de aplicar algumas das mudanças do lado oposto, use git checkout - p arquivo de ramificação. Isso inicia um ciclo interativo que permite que você aplique ou edite seletivamente seções diferentes (veja o item "patch" na seção "Modo interativo" de git-add (1) para obter detalhes).
No nosso exemplo, se você decidiu manter sua versão como padrão, mas aplicar seletivamente mudanças do outro ramo, você poderia fazer:
Se o ramo atual já estiver contido no outro (ou seja, HEAD é um antepassado da outra derivação), então, git merge irá simplesmente mover a ramificação atual para encontrar a outra em uma atualização de "fast-forward" e não faça um novo compromisso. Você pode forçar uma confiabilidade de qualquer forma com git merge --no-ff ("não fast-forward"), se você tiver algum motivo para fazê-lo. Se o inverso for verdadeiro, e o outro ramo já está contido neste, então o Git simplesmente dirá que o ramo atual está "já está atualizado" e não faz nada. O objetivo da fusão é incorporar no ramo atual qualquer alteração no outro ramo desde que os dois divergiram - mas eles não divergiram. Se você quiser usar o mecanismo de mesclagem de conteúdo e de resolução de conflitos do Git, mas não quiser criar um commit de mesclagem, use git merge --squash. Isso funciona como uma fusão normal em relação ao conteúdo, mas a confirmação que ele cria é apenas no ramo atual (ou seja, tem um único pai e não se conecta ao outro ramo no gráfico de confirmação). Você pode usar git merge - m para especificar uma mensagem de confirmação, assim como com git commit, embora lembre-se de que o Git fornece informações úteis na sua mensagem fornecida, que você prefere começar e editar em vez disso (o que acontece por padrão). Use git merge - não cometer para impedir que o Git comente quando uma fusão automática for bem-sucedida, caso queira ter uma olhada primeiro. Isso não é estritamente necessário, pois você sempre pode abortar o commit dando uma mensagem de confirmação em branco, ou faça as alterações que deseja depois e use git commit - amend. Git registra que uma fusão está em andamento configurando a referência MERGE_HEAD para apontar para a outra ramificação; É assim que sabe fazer um commit de mesclagem (em oposição a uma simples confirmação no ramo atual), mesmo quando existem comandos interativos enquanto você resolve conflitos.
Detalhes sobre a fusão.
Ao se fundir, o Git considera as mudanças ocorridas nas filiais em questão desde que elas divergiram. No exemplo acima, os ramos chandra e floyd divergiram no commit 50769fc9, de modo que as mudanças a reconciliar foram aquelas em compromissos e355785d e a5374035. Esses ramos podem ter divergido e foram mesclados várias vezes anteriormente, mas você só será solicitado a lidar com novas mudanças desde que aconteceu o último. Alguns outros sistemas de controle de versão não possuem esse recurso, de modo que a fusão de filiais repetidamente é um problema: você acaba resolvendo os mesmos conflitos repetidamente.
Mais precisamente, ao combinar vários ramos, o Git procura uma "base de mesclagem": um antepassado comum recente de todas as dicas de ramo, para usar como um ponto de referência para arbitrar alterações. Embora em situações complicadas possa haver múltiplas possibilidades para uma base de mesclagem (veja git-merge-base (1)), no caso comum do nosso exemplo, há uma única escolha óbvia, que o Git descobre automaticamente. Uma vez que nossa fusão agora envolve três compromissos - duas dicas de ramo e a base de mesclagem - é chamado de "fusão de três vias".
Lembre-se de que o status de git mostrou nossos conflitos, os "caminhos não misturados". Onde ele mantém essa informação? Há marcadores de conflito nos arquivos de trabalho, mas seria lenta ler todos os arquivos para esse propósito e, em qualquer caso, não ajudaria um conflito de modificação / exclusão. A resposta demonstra mais uma vez a utilidade do índice. Quando há um conflito de mesclagem para um arquivo, o Git simplesmente não armazena nenhuma versão do arquivo no índice, mas três: aqueles pertencentes à base de mesclagem e aos ramos atuais e "outros", numerados 1, 2 e 3, respectivamente. O número é chamado de "estágio" do arquivo e é uma propriedade distinta de uma entrada de índice, juntamente com o nome do arquivo, bits de modo, e assim por diante. Na verdade, há uma terceira etapa, 0, que é o estado usual de uma entrada que não possui nenhum conflito de mesclagem associado. Podemos ver isso usando git ls-files, que mostra o conteúdo do índice. Antes da fusão, vemos:
Os campos aqui são os bits de modo, ID do objeto blob que contém o conteúdo do arquivo, o número do estágio e o nome do arquivo. Depois de executar o git fundir floyd e obter um conflito para este arquivo, vemos algo muito diferente (usando - u em vez de - s mostraria apenas caminhos sem memória, aqui temos apenas um arquivo de qualquer maneira):
Note-se que o ID do estágio 2 corresponde ao que era anteriormente o estágio 0 acima, uma vez que o estágio 2 é a versão no ramo atual. Você pode usar git cat-file para ver o conteúdo das diferentes etapas, aqui a versão de mesclagem em série 1:
Você pode se referir a uma etapa específica de um arquivo com a sintaxe: n: caminho; então git show: 1: moebius é um equivalente mais fácil para isso.
Git funde os três compromissos no índice dessa maneira no início da mesclagem. Em seguida, segue um conjunto de regras simples para resolver rapidamente os casos fáceis; por exemplo:
Se os três estágios coincidirem, reduza-se para um único estágio 0. Se o estágio 1 corresponder ao estágio 2, então reduza para um único estágio 0 que corresponde ao estágio 3 (ou vice-versa): um lado fez uma mudança enquanto o outro não fazia nada. Se o estágio 1 corresponder ao estágio 2, mas não há nenhuma etapa 3, em seguida, remova o arquivo: não fizemos nenhuma alteração, enquanto o outro ramo deletou, então aceite a mudança da outra filial. Se os estágios 1 e 2 diferirem, e não há estágio 3, então relate um conflito "modificar / excluir": mudamos o arquivo, enquanto o outro ramo dele se apagou; o usuário deve decidir o que fazer.
…e assim por diante. Observe que, para correspondência, o Git não precisa buscar os arquivos reais; ele pode apenas comparar as IDs do objeto blob já no índice, pois são hashes do conteúdo dos arquivos. Isso é muito rápido; O endereçamento baseado em conteúdo gera novamente. Você pode ler sobre esse processo com mais detalhes em git-read-tree (1). Todos os arquivos que não podem ser facilmente resolvidos dessa maneira devem então ser examinados para tentar mesclar seus conteúdos.
Ferramentas de mesclagem.
A mescla pode ser um trabalho complexo, com você olhando para dezenas de seções conflitantes de mudanças de código-fonte de você e de outras pessoas e tentando combiná-las em um único conjunto de trabalho. Existem ferramentas disponíveis que vão muito além da saída de texto simples do git diff, ajudando você a visualizar e resolver esses conflitos. O Git integra-se suavemente com estas "ferramentas de fusão" externas, para ajudá-lo a fazer o trabalho com mais facilidade. O Git suporta mais de uma dúzia de ferramentas de fusão gratuitas e comerciais fora da caixa, incluindo araxis, emerge, opendiff, kdiff3 e gvimdiff. Ele também define uma interface com a qual você pode usar a maioria dessas ferramentas, geralmente exigindo apenas um script de wrapper simples para conectá-lo ao Git.
Não podemos investigar os detalhes das ferramentas de fusão individuais; muitos deles são programas complexos por direito próprio e exigem que outro pequeno livro descreva. Aqui, descreveremos como eles funcionam com o Git em geral.
O driver para usar uma ferramenta de mesclagem é git mergetool. Uma vez invocado, esse comando é executado em todos os arquivos com conflitos de mesclagem, solicitando cada um se você quiser invocar a ferramenta de mesclagem selecionada no arquivo. A ferramenta de mesclagem padrão é opendiff, mas você pode definir um padrão diferente com a variável de configuração do Merge. tool Git. A ferramenta geralmente apresentará uma visão das versões "nosso" e "deles" do arquivo, juntamente com a base de mesclagem, e fornecerá formas de passar de uma mudança ou conflito para o próximo, selecione a mudança do lado a ser usada ( ou combiná-los), etc. Quando você encerrar a ferramenta de mesclagem indicando sucesso, o Git adicionará sua versão mesclada ao índice (assim, marcando esse conflito conforme resolvido) e vá para o próximo arquivo não sinalizado.
O - y mude para git mergetool diz-lhe para executar a ferramenta em todos os arquivos não imersos, sem pausar para solicitar sim ou não para cada um. git mergetool deixa um foo. orig de backup para cada arquivo foo que ele processa, já que você pode ter modificado você mesmo antes de executar a ferramenta de mesclagem. Você pode configurar mergetool. keepBackup no para desativar esse recurso. Na verdade, o Git ainda faz o backup; Ele simplesmente o exclui quando a ferramenta de mesclagem é executada com sucesso, de modo que o backup ainda esteja lá no caso de a ferramenta falhar.
If a merge tool exits unexpectedly or doesn’t work properly, you may see files like these left behind (for the file main. c ):
These are the temporary files that Git uses to pass the various file versions to the merge tool.
Custom Merge Tools.
If you want to use a merge tool not directly supported by Git, it need only obey some simple conventions; usually, you’ll write a glue script to accommodate them. Git passes four filenames to the tool as environment variables :
The tool should exit with a code of zero to indicate that the user is happy with the merged version, saved to the filename in the MERGED environment variable. A nonzero exit code means that Git should ignore that file and not mark this conflict resolved. To define a new Git merge tool named “foo” with your own program named newtool :
This shows the files being passed on the command line to newtool ; if your program reads the environment variables itself, then of course that’s not required. The trustExitCode setting means that Git will interpret the tool’s exit code as previously described; if this setting is false, Git will prompt the user for what to do anyway.
Merge Strategies.
Git has a number of approaches it can take to automatically merge files that have been changed by both sides of a merge; that is to say, exactly what it does in analyzing text to determine the boundaries of changed blocks, when blocks have been moved, when changes can be safely merged, and when they should be punted to the user. These approaches are called “merge strategies,” and each may in turn have various options; Git can even be extended with new strategies by writing custom “merge drivers,” without having to touch Git proper.
The built-in merge strategies are described in git-merge(1) . The many options are quite technical and involved, and Git’s default choice of strategy is usually sufficient; we will not cover them in depth here. However, here are a few tips involving merge strategies that are generally useful:
Why the Octopus?
An octopus merge is generally used to tie together several topic branches with the master branch in preparation for a new release of a project, bringing in all their separate contributions. The individual branches should already have been reconciled with the master and have no conflicts amongst them, or else as mentioned, the octopus merge will not work. The octopus merge does not have any inherent advantage over simply merging all the topic branches into the master pairwise and reconciling the conflicts there; it accomplishes the same goal and incorporates the same history. However, with a large number of branches, it can make for a cleaner and more easily understood commit graph, and so some people prefer it. See Figure 7-1.
Reusing Previous Merge Decisions.
Git can remember merge conflict resolutions you made in the past, and reuse them automatically if you run into similar conflicts later. This feature goes by the name git rerere , for “reuse recorded resolution.” This is useful if you’re working on a particularly difficult merge. You may abort a merge and retry it in various ways, but having resolved some conflicts in the meantime, this feature can remember and reapply those decisions. It can also be helpful if you’re rewriting repository history, or in maintaining branches on which you end up resolving the same conflicts repeatedly until the branch’s content can finally be merged appropriately.
Git merge strategy recursive
Anexe? T = 30 para iniciar a reprodução a 30s,? T = 3: 20 para iniciar a reprodução a 3m 20s.
Incorporar link de imagem.
Use snippets abaixo para exibir uma captura de tela ligada a esta gravação. Útil em locais onde os scripts não são permitidos (por exemplo, no arquivo README de um projeto).
Incorporar o jogador.
Se você estiver incorporando em sua própria página ou em um site que permita tags de script, você pode usar o widget completo do jogador:
Cole a tag de script acima onde deseja que o jogador seja exibido em sua página.
Baixe esta gravação.
Repetição no terminal.
Você pode reproduzir esta gravação em seu terminal com comando de comando asciinema:
Se você não tiver instalado asciinema cli, consulte as instruções de instalação.
Use o player autônomo em seu site.
Baixe o jogador do asciinema da página de lançamento do jogador (você só precisa do arquivo. js e. css), então use-o assim:
Veja o leitor de leitura do asciinema para obter instruções de uso completo.
Obter através da App Store Leia esta publicação em nosso aplicativo!
git merge recursive theirs, como isso funciona?
Estou tendo um pouco de problema. Nós temos o nosso próprio CMS que está usando git para colaboração e versões e outras coisas.
Agora eu tenho dois repositórios git A e B, A que é um projeto e B que é o próprio CMS. Agora eu quero obter B em A, mas quando eu faço isso, eu tenho muitos conflitos de mesclagem e a solução para os conflitos é sempre usar o material de B.
Agora, o que eu acho que eu preciso é.
porque eu quero fundir e quando há um conflito de fusão, ele deve ser forçado a usar a solução de B. Mas eu não consigo fazer isso funcionar. Sempre me diz que é fatal: 'deles' não aponta para um commit.
Os recursivos deles, eu encontrei aqui.
Alguém sabe o que eu faço de errado?
Você deve usar esse formulário para passar opções de estratégia de mesclagem:
Certifique-se também de que a sua versão seja suprimida. É a característica bastante recente (?)
Eu acho que o motivo pelo qual está falhando é que você está especificando "recursive theirs" como a estratégia. "recursivo" é uma estratégia, e quando você coloca um espaço depois, "os seus" são interpretados como algo que git precisa mesclar sua cópia de trabalho com (por exemplo, outro ramo ou refspec).
Eu acho que você não poderá especificar uma estratégia exatamente como o que você deseja. Existe uma estratégia chamada "nossa", que é o oposto do que você está querendo.
O padrão usual usado nesta situação é combinar ou rebase no repositório "B". Dentro da cópia de trabalho do repositório "A", você faria um rebase, se possível (talvez não seja possível, se você já está compartilhando o repo git com outros desenvolvedores). Um rebase seria essencialmente rotear o repositório A de volta para um commit comum em ambos os repositórios, aplicar "B" comete, então "A" comete no topo. Você resolveria todos os conflitos de mesclagem ao longo do caminho.
Uma vez que você atravessa a dor de fusão ou rebaixamento no repositório "B", o futuro mescla será menos doloroso.
Capítulo 7. Fusão.
Fusionar é o processo de combinar as mudanças recentes de vários ramos em um único novo commit que está em todos esses ramos. Na maioria das vezes, há apenas dois ramos envolvidos, mas na verdade, pode haver qualquer número; se houver mais de dois, é chamado de "mesclagem de polvo". Quando há apenas dois ramos, o ramo atual é chamado de "nosso" lado da mesclagem, enquanto o outro ramo é chamado de "seu" lado. Como a mesclagem do polvo é incomum, geralmente assumiremos uma fusão de dois ramos nesta discussão.
Nós descrevemos como o Git pode iniciar uma fusão para você como parte do git pull (consulte "Pulling"), mas você também pode executar mesclagens explicitamente. Aqui está um cenário típico: você está trabalhando em um projeto de software e você tem uma idéia de um novo recurso, mas você não quer seu trabalho experimental nesse recurso para perturbar o seu principal desenvolvimento. Então você cria um recurso chamado ramificação para conter o trabalho:
Quando você precisa voltar a trabalhar na parte principal do seu projeto, você compromete seu trabalho no ramo de recursos e volte para o mestre (ou qualquer ramo em que você precise trabalhar):
Você continua assim por algum tempo. Eventualmente, se você decidir que não gosta da sua idéia de recurso, você pode descartar o trabalho excluindo o ramo com a ramificação git - recurso D. Se você decidir mantê-lo, no entanto, em algum momento, você vai querer incorporá-lo no código principal do projeto, e você faz isso com uma mesclagem:
É melhor ter todo o seu trabalho comprometido antes de executar a fusão git; ou seja, o status git não deve mostrar alterações pendentes ou arquivos não rastreados. A retirada de uma fusão para o seu estado inicial pode ser difícil caso contrário. Você pode usar o git stash como uma maneira rápida de salvar as mudanças de trabalho e restaurá-las mais tarde (consulte "git stash").
Essa fusão foi simples. Você adicionou os arquivos effulgent. c e epiphany. h no ramo de recursos, e eles não existiam no mestre, então o Git apenas os adicionou. Você fez alterações menores no main. c em ambos os ramos, mas essas mudanças não entraram em conflito, então o Git os combinou automaticamente e comprometeu sua versão mesclada. O gráfico ASCII com nomes de arquivos à esquerda é chamado de "difstat"; é um resumo das mudanças feitas por este commit. As linhas dos sinais mais e menos representam o número relativo de adições de linha ("inserções") e as exclusões feitas no arquivo correspondente.
Ambos os aspectos da fusão ocorreram aqui: conteúdo e estrutura. Primeiro, o Git combinou o conteúdo de ambos os ramos, adicionando e mesclando alterações em arquivos; então, gravou o fato da fusão estruturalmente, criando uma combinação combinando ambos os ramos juntos no gráfico de confirmação. Isso indica na história que os compromissos cujos conteúdos foram combinados para produzir o novo, tornando-os seus pais. Um "commit de mesclagem" é definido simplesmente como um commit com mais de um dos pais.
Você pode continuar esse processo o tempo que desejar, trabalhando no ramo de recursos separadamente e periodicamente mesclando seu trabalho em mestre. Se você fizer isso, você provavelmente também precisará se fundir do outro lado, atualizando o ramo de recursos com os trabalhos mais recentes no mestre, de modo que você não esteja trabalhando no código desatualizado; Para isso, basta fazer o inverso: mude para recurso e execute o mestre de mesclagem git.
Quando o seu novo recurso estiver totalmente incorporado ao desenvolvimento principal, e você não precisa mais trabalhar separadamente, você pode excluir o ramo de recursos com o recurso git branch - d; conforme discutido em "Excluindo um Ramo", o Git irá reclamar se você não tiver incorporado completamente o recurso no mestre, para evitar que você acidentalmente perca o trabalho. O recurso de exclusão não exclui nenhum de seus conteúdos ou histórico; ele simplesmente remove o nome "recurso" como um ponto de referência, um lugar no qual você pretende adicionar compromissos independentes mais tarde, já que você não precisa mais disso. Você pode reutilizar "recurso" como um nome de filial no futuro, se desejar, e não haverá colisão com o uso anterior; na verdade, além de possivelmente em mensagens de confirmação ou reflogs, uma vez que você exclui uma filial, não há registro no repositório próprio que já existiu! Os nomes das filiais servem para indicar quais partes do banco de dados do objeto ainda são de interesse e onde o desenvolvimento ainda está ocorrendo; se o conteúdo de uma filial for incorporado a outros ramos, e você não precisa mais de uma linha de desenvolvimento com esse nome, então você pode simplesmente excluí-lo e reutilizar o nome mais tarde para outra coisa se desejar. Da mesma forma, olhando para trás no gráfico de confirmação, não é possível saber em qual nome de filial um compromisso específico foi feito; mesmo em uma história linear, o nome do ramo atual pode ter sido alterado em algum momento do passado. Pode ser interessante ou útil saber isso em algumas situações, mas o Git simplesmente não mantém essa informação. Os ramos de Git são efêmeros em um sentido, apenas ferramentas para construir o gráfico de commit, que é o que importa.
Combinar Conflitos.
A fusão acima foi suave, mas e se você tivesse feito mudanças nos dois ramos que a Git não conseguiu combinar por conta própria? Estes são chamados de "conflitos de mesclagem", e Git iria parar e pedir-lhe para resolvê-los antes de cometer. Esse processo pode variar de simples a muito complexo, dependendo do conteúdo e das mudanças envolvidas; Felizmente, existem ferramentas disponíveis para ajudar, tanto no próprio Git quanto com o qual o Git pode trabalhar. Vamos passar por um exemplo simples. Suponha que você tenha um arquivo moebius com os seguintes conteúdos:
... e você comete compromissos nas filiais chandra e floyd mudando assim:
Você mudou as mesmas duas linhas de cada lado de maneiras diferentes, e a abordagem de mesclagem orientada por linha do Git não tentará adivinhar sua intenção ou combinar as linhas (por exemplo, formar uma única linha de monólitos de golfinhos, como sejam interessantes); Isso irá sinalizar um conflito de mesclagem:
A frase CONFLICTO (conteúdo) indica que o conflito é devido a alterações de conteúdo irreconciliáveis neste arquivo. Git também pode indicar outros motivos, como um conflito de adicionar / adicionar, no qual o mesmo nome de arquivo é adicionado a ambos os ramos, mas com conteúdo diferente.
Se você iniciar uma mesclagem e depois deseja cancelá-la - talvez você não estivesse esperando tantos conflitos e você não tem tempo para lidar com eles agora - basta usar git merge --abort.
Para obter uma visão geral do estado de mesclagem, use o status git. Qualquer mudança que Git resolva por conta própria será mostrada como já encenada para confirmação, e há uma seção separada no final para conflitos de mesclagem:
Caminhos não geridos são arquivos com conflitos que o Git não conseguiu resolver. Para descobrir o que deu errado em detalhes, use o git diff. Este comando não mostra apenas as diferenças entre várias combinações de árvore de trabalho, índice e compromete; Ele também possui um modo especial para ajudar com os conflitos de mesclagem:
Esta exibição mostra as versões alternativas da seção em conflito, separadas por ======= e marcadas com o ramo correspondente: nosso (o ramo atual) e deles (neste caso floyd, o ramo que estamos mesclando nos nossos) . Como de costume, git diff mostra diferenças entre a árvore de trabalho e o índice, que neste caso são os conflitos ainda por resolver; As mudanças já feitas e encenadas não são mostradas. Você pode usar o git diff --staged para ver aqueles; Adicione - stat para uma visão geral. Você verá que o Git atualizou o arquivo de trabalho com marcação semelhante:
Depois de editar o arquivo para resolver o conflito, use git add to stage sua versão fixa para confirmar e remova-a da lista de caminhos conflitantes (se a resolução for realmente excluir o arquivo, use git rm). Uma vez que você tenha abordado todos os conflitos e o status git já não relata nenhum caminho não gerido, você pode usar o commit git para completar a mesclagem. O Git apresentará uma mensagem de confirmação contendo detalhes sobre esta mesclagem, incluindo os seus ramos e conflitos, que você pode editar como você entender; nesse caso :
... e você pode ver que você criou um "commit de mesclagem" com mais de um dos pais:
O outro ramo, floyd, ficou onde estava, enquanto o ramo atual chandra avançou um compromisso de e355785d para aaba9d85, e esse último compromisso unifica os dois ramos. Um novo commit no floyd fará com que eles divertem novamente, e você pode se fundir novamente no futuro se precisar (em qualquer direção). Observe que, neste momento, um simples registro git mostrará compromissos de ambos os ramos, não apenas aqueles feitos em chandra:
Você pode ter esperado ver apenas confirma aeba9d85, e355785d e 50769fc9. Esta apresentação pode parecer estranha no início, mas é apenas uma maneira diferente de considerar a noção de "ramificação". Um ramo Git é definido como o conjunto de todos os compromissos alcançáveis no gráfico de confirmação da derivação; pense nisso como todos os compromissos que contribuíram com o conteúdo do compromisso da tip (que, após uma fusão, inclui todos os compromissos anteriores a esse em ambos os ramos).
Em casos simples, você pode obter o que você pensa como o histórico de "este ramo" com git log - primeiro pai, que apenas segue o primeiro pai de compromissos de fusão em vez de todos eles. No entanto, isso não é garantido e, em histórias mais complexas, não significará muito. Uma vez que o Git permite o histórico não linear, uma simples lista de compromissos geralmente não é muito útil, e você precisa de ferramentas de visualização para ajudá-lo a interpretá-lo (consulte "Ferramentas visuais").
Resolvendo conflitos de mesclagem.
O Git não possui ferramentas embutidas para interagir diretamente com os conflitos de mesclagem diretamente; é para isso que são utilizadas as ferramentas de mesclagem externas, que consideraremos em breve em "Ferramentas de mesclagem". No entanto, aqui estão algumas dicas para uso em casos simples.
git log - p - merge mostra todos os compromissos contendo alterações relevantes para qualquer arquivo não imerso, em qualquer ramo, juntamente com seus diffs. Isso pode ajudá-lo a identificar as mudanças no histórico que levaram aos conflitos. Se quiser descartar todas as mudanças de um lado da mesclagem, use git checkout - arquivo para atualizar o arquivo de trabalho com a cópia do ramo atual ou outro, seguido de git add file para marcar a mudança e marcar o conflito como resolvido. Tendo feito isso, se você gostaria de aplicar algumas das mudanças do lado oposto, use git checkout - p arquivo de ramificação. Isso inicia um ciclo interativo que permite que você aplique ou edite seletivamente seções diferentes (veja o item "patch" na seção "Modo interativo" de git-add (1) para obter detalhes).
No nosso exemplo, se você decidiu manter sua versão como padrão, mas aplicar seletivamente mudanças do outro ramo, você poderia fazer:
Se o ramo atual já estiver contido no outro (ou seja, HEAD é um antepassado da outra derivação), então, git merge irá simplesmente mover a ramificação atual para encontrar a outra em uma atualização de "fast-forward" e não faça um novo compromisso. Você pode forçar uma confiabilidade de qualquer forma com git merge --no-ff ("não fast-forward"), se você tiver algum motivo para fazê-lo. Se o inverso for verdadeiro, e o outro ramo já está contido neste, então o Git simplesmente dirá que o ramo atual está "já está atualizado" e não faz nada. O objetivo da fusão é incorporar no ramo atual qualquer alteração no outro ramo desde que os dois divergiram - mas eles não divergiram. Se você quiser usar o mecanismo de mesclagem de conteúdo e de resolução de conflitos do Git, mas não quiser criar um commit de mesclagem, use git merge --squash. Isso funciona como uma fusão normal em relação ao conteúdo, mas a confirmação que ele cria é apenas no ramo atual (ou seja, tem um único pai e não se conecta ao outro ramo no gráfico de confirmação). Você pode usar git merge - m para especificar uma mensagem de confirmação, assim como com git commit, embora lembre-se de que o Git fornece informações úteis na sua mensagem fornecida, que você prefere começar e editar em vez disso (o que acontece por padrão). Use git merge - não cometer para impedir que o Git comente quando uma fusão automática for bem-sucedida, caso queira ter uma olhada primeiro. Isso não é estritamente necessário, pois você sempre pode abortar o commit dando uma mensagem de confirmação em branco, ou faça as alterações que deseja depois e use git commit - amend. Git registra que uma fusão está em andamento configurando a referência MERGE_HEAD para apontar para a outra ramificação; É assim que sabe fazer um commit de mesclagem (em oposição a uma simples confirmação no ramo atual), mesmo quando existem comandos interativos enquanto você resolve conflitos.
Detalhes sobre a fusão.
Ao se fundir, o Git considera as mudanças ocorridas nas filiais em questão desde que elas divergiram. No exemplo acima, os ramos chandra e floyd divergiram no commit 50769fc9, de modo que as mudanças a reconciliar foram aquelas em compromissos e355785d e a5374035. Esses ramos podem ter divergido e foram mesclados várias vezes anteriormente, mas você só será solicitado a lidar com novas mudanças desde que aconteceu o último. Alguns outros sistemas de controle de versão não possuem esse recurso, de modo que a fusão de filiais repetidamente é um problema: você acaba resolvendo os mesmos conflitos repetidamente.
Mais precisamente, ao combinar vários ramos, o Git procura uma "base de mesclagem": um antepassado comum recente de todas as dicas de ramo, para usar como um ponto de referência para arbitrar alterações. Embora em situações complicadas possa haver múltiplas possibilidades para uma base de mesclagem (veja git-merge-base (1)), no caso comum do nosso exemplo, há uma única escolha óbvia, que o Git descobre automaticamente. Uma vez que nossa fusão agora envolve três compromissos - duas dicas de ramo e a base de mesclagem - é chamado de "fusão de três vias".
Lembre-se de que o status de git mostrou nossos conflitos, os "caminhos não misturados". Onde ele mantém essa informação? Há marcadores de conflito nos arquivos de trabalho, mas seria lenta ler todos os arquivos para esse propósito e, em qualquer caso, não ajudaria um conflito de modificação / exclusão. A resposta demonstra mais uma vez a utilidade do índice. Quando há um conflito de mesclagem para um arquivo, o Git simplesmente não armazena nenhuma versão do arquivo no índice, mas três: aqueles pertencentes à base de mesclagem e aos ramos atuais e "outros", numerados 1, 2 e 3, respectivamente. O número é chamado de "estágio" do arquivo e é uma propriedade distinta de uma entrada de índice, juntamente com o nome do arquivo, bits de modo, e assim por diante. Na verdade, há uma terceira etapa, 0, que é o estado usual de uma entrada que não possui nenhum conflito de mesclagem associado. Podemos ver isso usando git ls-files, que mostra o conteúdo do índice. Antes da fusão, vemos:
Os campos aqui são os bits de modo, ID do objeto blob que contém o conteúdo do arquivo, o número do estágio e o nome do arquivo. Depois de executar o git fundir floyd e obter um conflito para este arquivo, vemos algo muito diferente (usando - u em vez de - s mostraria apenas caminhos sem memória, aqui temos apenas um arquivo de qualquer maneira):
Note-se que o ID do estágio 2 corresponde ao que era anteriormente o estágio 0 acima, uma vez que o estágio 2 é a versão no ramo atual. Você pode usar git cat-file para ver o conteúdo das diferentes etapas, aqui a versão de mesclagem em série 1:
Você pode se referir a uma etapa específica de um arquivo com a sintaxe: n: caminho; então git show: 1: moebius é um equivalente mais fácil para isso.
Git funde os três compromissos no índice dessa maneira no início da mesclagem. Em seguida, segue um conjunto de regras simples para resolver rapidamente os casos fáceis; por exemplo:
Se os três estágios coincidirem, reduza-se para um único estágio 0. Se o estágio 1 corresponder ao estágio 2, então reduza para um único estágio 0 que corresponde ao estágio 3 (ou vice-versa): um lado fez uma mudança enquanto o outro não fazia nada. Se o estágio 1 corresponder ao estágio 2, mas não há nenhuma etapa 3, em seguida, remova o arquivo: não fizemos nenhuma alteração, enquanto o outro ramo deletou, então aceite a mudança da outra filial. Se os estágios 1 e 2 diferirem, e não há estágio 3, então relate um conflito "modificar / excluir": mudamos o arquivo, enquanto o outro ramo dele se apagou; o usuário deve decidir o que fazer.
…e assim por diante. Observe que, para correspondência, o Git não precisa buscar os arquivos reais; ele pode apenas comparar as IDs do objeto blob já no índice, pois são hashes do conteúdo dos arquivos. Isso é muito rápido; O endereçamento baseado em conteúdo gera novamente. Você pode ler sobre esse processo com mais detalhes em git-read-tree (1). Todos os arquivos que não podem ser facilmente resolvidos dessa maneira devem então ser examinados para tentar mesclar seus conteúdos.
Ferramentas de mesclagem.
A mescla pode ser um trabalho complexo, com você olhando para dezenas de seções conflitantes de mudanças de código-fonte de você e de outras pessoas e tentando combiná-las em um único conjunto de trabalho. Existem ferramentas disponíveis que vão muito além da saída de texto simples do git diff, ajudando você a visualizar e resolver esses conflitos. O Git integra-se suavemente com estas "ferramentas de fusão" externas, para ajudá-lo a fazer o trabalho com mais facilidade. O Git suporta mais de uma dúzia de ferramentas de fusão gratuitas e comerciais fora da caixa, incluindo araxis, emerge, opendiff, kdiff3 e gvimdiff. Ele também define uma interface com a qual você pode usar a maioria dessas ferramentas, geralmente exigindo apenas um script de wrapper simples para conectá-lo ao Git.
Não podemos investigar os detalhes das ferramentas de fusão individuais; muitos deles são programas complexos por direito próprio e exigem que outro pequeno livro descreva. Aqui, descreveremos como eles funcionam com o Git em geral.
O driver para usar uma ferramenta de mesclagem é git mergetool. Uma vez invocado, esse comando é executado em todos os arquivos com conflitos de mesclagem, solicitando cada um se você quiser invocar a ferramenta de mesclagem selecionada no arquivo. A ferramenta de mesclagem padrão é opendiff, mas você pode definir um padrão diferente com a variável de configuração do Merge. tool Git. A ferramenta geralmente apresentará uma visão das versões "nosso" e "deles" do arquivo, juntamente com a base de mesclagem, e fornecerá formas de passar de uma mudança ou conflito para o próximo, selecione a mudança do lado a ser usada ( ou combiná-los), etc. Quando você encerrar a ferramenta de mesclagem indicando sucesso, o Git adicionará sua versão mesclada ao índice (assim, marcando esse conflito conforme resolvido) e vá para o próximo arquivo não sinalizado.
O - y mude para git mergetool diz-lhe para executar a ferramenta em todos os arquivos não imersos, sem pausar para solicitar sim ou não para cada um. git mergetool deixa um foo. orig de backup para cada arquivo foo que ele processa, já que você pode ter modificado você mesmo antes de executar a ferramenta de mesclagem. Você pode configurar mergetool. keepBackup no para desativar esse recurso. Na verdade, o Git ainda faz o backup; Ele simplesmente o exclui quando a ferramenta de mesclagem é executada com sucesso, de modo que o backup ainda esteja lá no caso de a ferramenta falhar.
If a merge tool exits unexpectedly or doesn’t work properly, you may see files like these left behind (for the file main. c ):
These are the temporary files that Git uses to pass the various file versions to the merge tool.
Custom Merge Tools.
If you want to use a merge tool not directly supported by Git, it need only obey some simple conventions; usually, you’ll write a glue script to accommodate them. Git passes four filenames to the tool as environment variables :
The tool should exit with a code of zero to indicate that the user is happy with the merged version, saved to the filename in the MERGED environment variable. A nonzero exit code means that Git should ignore that file and not mark this conflict resolved. To define a new Git merge tool named “foo” with your own program named newtool :
This shows the files being passed on the command line to newtool ; if your program reads the environment variables itself, then of course that’s not required. The trustExitCode setting means that Git will interpret the tool’s exit code as previously described; if this setting is false, Git will prompt the user for what to do anyway.
Merge Strategies.
Git has a number of approaches it can take to automatically merge files that have been changed by both sides of a merge; that is to say, exactly what it does in analyzing text to determine the boundaries of changed blocks, when blocks have been moved, when changes can be safely merged, and when they should be punted to the user. These approaches are called “merge strategies,” and each may in turn have various options; Git can even be extended with new strategies by writing custom “merge drivers,” without having to touch Git proper.
The built-in merge strategies are described in git-merge(1) . The many options are quite technical and involved, and Git’s default choice of strategy is usually sufficient; we will not cover them in depth here. However, here are a few tips involving merge strategies that are generally useful:
Why the Octopus?
An octopus merge is generally used to tie together several topic branches with the master branch in preparation for a new release of a project, bringing in all their separate contributions. The individual branches should already have been reconciled with the master and have no conflicts amongst them, or else as mentioned, the octopus merge will not work. The octopus merge does not have any inherent advantage over simply merging all the topic branches into the master pairwise and reconciling the conflicts there; it accomplishes the same goal and incorporates the same history. However, with a large number of branches, it can make for a cleaner and more easily understood commit graph, and so some people prefer it. See Figure 7-1.
Reusing Previous Merge Decisions.
Git can remember merge conflict resolutions you made in the past, and reuse them automatically if you run into similar conflicts later. This feature goes by the name git rerere , for “reuse recorded resolution.” This is useful if you’re working on a particularly difficult merge. You may abort a merge and retry it in various ways, but having resolved some conflicts in the meantime, this feature can remember and reapply those decisions. It can also be helpful if you’re rewriting repository history, or in maintaining branches on which you end up resolving the same conflicts repeatedly until the branch’s content can finally be merged appropriately.
Git merge strategy recursive
Anexe? T = 30 para iniciar a reprodução a 30s,? T = 3: 20 para iniciar a reprodução a 3m 20s.
Incorporar link de imagem.
Use snippets abaixo para exibir uma captura de tela ligada a esta gravação. Útil em locais onde os scripts não são permitidos (por exemplo, no arquivo README de um projeto).
Incorporar o jogador.
Se você estiver incorporando em sua própria página ou em um site que permita tags de script, você pode usar o widget completo do jogador:
Cole a tag de script acima onde deseja que o jogador seja exibido em sua página.
Baixe esta gravação.
Repetição no terminal.
Você pode reproduzir esta gravação em seu terminal com comando de comando asciinema:
Se você não tiver instalado asciinema cli, consulte as instruções de instalação.
Use o player autônomo em seu site.
Baixe o jogador do asciinema da página de lançamento do jogador (você só precisa do arquivo. js e. css), então use-o assim:
Veja o leitor de leitura do asciinema para obter instruções de uso completo.
Comments
Post a Comment