nuevo github




Melhor(e mais segura) maneira de mesclar um git branch em master (6)

Como eu faria isso

git checkout master
git pull origin master
git merge test
git push origin master

Se eu tenho um ramo local de um remoto, não me sinto confortável com a fusão de outros ramos do que este com o controle remoto. Além disso, eu não iria empurrar as minhas alterações, até que eu esteja feliz com o que eu quero empurrar e também eu não iria empurrar as coisas em tudo, que são apenas para mim e meu repositório local. Na sua descrição, parece que esse test é só para você? Então, não há razão para publicá-lo.

git sempre tenta respeitar as suas e outras mudanças, e assim vai --rebase . Eu não acho que eu possa explicar isso apropriadamente, então dê uma olhada no livro do Git - Rebasing ou git-ready: Intro no rebasing para uma pequena descrição. É um recurso bem legal

Uma nova ramificação do master é criada, chamamos de test .

Existem vários desenvolvedores que se comprometem a master ou criar outras ramificações e depois se fundem no master .

Digamos que o trabalho no test esteja demorando vários dias e você deseja manter continuamente o test atualizado com os commits dentro do master .

Eu faria git pull origin master do test .

Pergunta 1: Essa é a abordagem correta? Outros desenvolvedores poderiam ter trabalhado facilmente nos mesmos arquivos que eu trabalhei btw.

Meu trabalho no test está pronto e estou pronto para mesclar de volta ao master . Aqui estão as duas maneiras em que posso pensar:

UMA:

git checkout test
git pull origin master
git push origin test
git checkout master
git pull origin test 

B:

git checkout test
git pull origin master
git checkout master
git merge test

Eu não estou usando --rebase porque do meu entendimento, o rebase irá obter as mudanças do master e empilhar o meu em cima disso, portanto, pode sobrescrever as alterações feitas por outras pessoas.

Pergunta 2: Qual desses dois métodos está correto? Qual a diferença aí?

O objetivo de tudo isso é manter meu branch de test atualizado com as coisas que estão acontecendo no master e depois eu poderia mesclá-lo de volta ao master esperando manter a linha do tempo o mais linear possível.


Esse é o fluxo de trabalho que uso no meu trabalho com a equipe. O cenário é como você descreveu. Primeiro, quando eu terminar de trabalhar no test eu rebaso com o mestre para puxar o que foi adicionado ao master durante o tempo em que estive trabalhando no branch de test .

git pull -r upstream master

Isto irá puxar as mudanças para o master desde que você bifurcou o branch de test e as aplicou, e então aplicará as mudanças que você fez para testar "em cima" do estado atual do master. Pode haver conflitos aqui, se as outras pessoas tiverem feito alterações nos mesmos arquivos que você editou no teste. Se houver, você terá que corrigi-los manualmente e confirmar. Uma vez feito isso, você será bom para mudar para o branch master e mesclar o test sem problemas.


Eu primeiro faria a ramificação to be ser mesclada o mais limpa possível. Execute seus testes, verifique se o estado é o desejado. Limpe os novos commits pelo git squash .

Além da resposta da KingCrunches , sugiro usar

git checkout master
git pull origin master
git merge --squash test
git commit
git push origin master

Você pode ter feito muitos commits no outro branch, que deve ser apenas um commit no master branch. Para manter o histórico de commit o mais limpo possível, você pode querer esmagar todos os seus commits do branch de teste em um commit no branch master (veja também: Git: To squash or not squash? ). Então você também pode reescrever a mensagem de commit para algo muito expressivo. Algo que é fácil de ler e entender, sem entrar no código.

edit: você pode estar interessado em

Então, no GitHub, eu acabei fazendo o seguinte para uma ramificação de recurso mybranch :

Receba as últimas da origem

$ git checkout master
$ git pull origin master

Encontre o hash da base de mesclagem:

$ git merge-base mybranch master
c193ea5e11f5699ae1f58b5b7029d1097395196f

$ git checkout mybranch
$ git rebase -i c193ea5e11f5699ae1f58b5b7029d1097395196f

Agora, certifique-se apenas o primeiro é pick , o resto é s :

pick 00f1e76 Add first draft of the Pflichtenheft
s d1c84b6 Update to two class problem
s 7486cd8 Explain steps better

Em seguida, escolha uma mensagem de commit muito boa e pressione para o GitHub. Faça o pedido de puxar então.

Após a mesclagem da solicitação pull, você pode excluí-la localmente:

$ git branch -d mybranch

e no GitHub

$ git push origin :mybranch

Eu usaria o método de rebase. Principalmente porque reflete perfeitamente seu caso semanticamente, ie. O que você quer fazer é atualizar o estado do seu ramo atual e "fingir" como se fosse baseado no mais recente.

Então, mesmo sem verificar o master , eu gostaria de:

git fetch origin
git rebase -i origin/master
# ...solve possible conflicts here

É claro que buscar a origem não atualiza o estado local do seu master (pois não realiza uma mesclagem), mas é perfeitamente aceitável para nosso propósito - queremos evitar a mudança, para economizar tempo.


Tópico antigo, mas não encontrei meu jeito de fazer isso. Pode ser valioso para alguém que trabalha com rebase e quer mesclar todos os commits de um branch no topo do master. Se houver um conflito no caminho, você poderá resolvê-los para cada commit.

Obter Master e Branch atualizados:

git checkout master
git pull --rebase origin master
git checkout <branch_name>
git pull --rebase origin <branch_name>

Merge Branch no topo do Master:

git checkout <branch_name>
git rebase master
git add .
git rebase continue

Se você se deparar com Conflitos durante o Rebase:

Primeiro, resolva o conflito no arquivo. Então:

git add .
git rebase --continue

Quando o rebase terminar, rebate a ramificação no topo do master:

git checkout master
git rebase <branch_name>

git checkout master
git pull origin master
# Merge branch test into master
git merge test

Após a mesclagem, se o arquivo for alterado, quando você mesclá-lo será através do erro "Resolver Conflito"

Então você precisa primeiro resolver todos os seus conflitos então, você tem que comprometer novamente todas as suas mudanças e então empurrar

git push origin master

É melhor fazer quem fez mudanças no ramo de teste, porque ele sabia que mudanças ele fez.





git-merge