Obter alterações do mestre para o ramo no Git

No meu repositório, tenho um ramo chamado no aqqual estou trabalhando.

Em seguida, cometi um novo trabalho e erros master.

Qual é a melhor maneira de colocar esses commits no aqbranch? Crie outro novo ramo mastere mescle-o aq?

Confira a aqramificação e refaça a partir de master.

git checkout aq
git rebase master

Você deve poder apenas git merge origin/masterquando estiver no seu ramo aq.

git checkout aq
git merge origin/master

Primeiro confira para dominar:

git checkout master

Faça todas as alterações, hotfix e confirmações e empurre seu mestre.

Volte para o seu ramo, 'aq', e junte o mestre nele:

git checkout aq
git merge master

Sua filial estará atualizada com o mestre. Um exemplo bom e básico de mesclagem é a ramificação de 3,2 Git - ramificação e mesclagem básicas .

Não há garantia de que as correções principais não estejam entre outras confirmações, portanto, você não pode simplesmente mesclar. Faz

git checkout aq
git cherry-pick commit1
git cherry-pick commit2
git cherry-pick commit3
...

assumindo que esses commits representam as correções de bugs.

De agora em diante, mantenha as correções de erros em um ramo separado. Você será capaz de apenas

git merge hotfixes

quando você deseja agrupar todos eles no ramo de desenvolvimento regular.

Tanto cherry-pickos commits relevantes no ramo aqou merge ramo masterem ramo aq.

Mesclar com aq

git checkout master
git pull
git checkout aq
git merge --no-ff master
git push

Jeito fácil

# 1. Create a new remote branch A base on last master
# 2. Checkout A
# 3. Merge aq to A

Para mim, eu já tinha alterações em vigor e queria as últimas da ramificação base. Eu era incapaz de fazer rebasee cherry-picklevaria uma eternidade, então fiz o seguinte:

git fetch origin <base branch name>  
git merge FETCH_HEAD

então neste caso:

git fetch origin master  
git merge FETCH_HEAD

Isso ( daqui ) funcionou para mim:

git checkout aq
git pull origin master
...
git push

Citação:

git pull origin masterbusca e mescla o conteúdo da ramificação principal com sua ramificação e cria uma confirmação de mesclagem. Se houver algum conflito de mesclagem, você será notificado nesse estágio e deverá resolver os commits de mesclagem antes de continuar . Quando você estiver pronto para enviar suas confirmações locais, incluindo sua nova confirmação de mesclagem, para o servidor remoto, execute git push.

Você tem algumas opções. git rebase master aqna ramificação que manterá os nomes de confirmação, mas NÃO REBASE se for uma ramificação remota. Você pode git merge master aqse não se importar em manter os nomes de confirmação. Se você deseja manter os nomes de confirmação e é uma ramificação remota, ela é git cherry-pick <commit hash>confirmada em sua ramificação.

Você também pode fazer isso executando uma única linha.
git merge aq master

Isso é equivalente a

git checkout aq
git merge master

EDITAR:

A minha resposta abaixo documenta uma maneira de mesclar masterem aq, onde se você ver os detalhes da fusão que lista as alterações feitas em aqantes da fusão, não as alterações feitas no master. Eu percebi que isso provavelmente não é o que você quer, mesmo que você pense que é!

Somente:

git checkout aq
git merge master

está bem.

Sim, essa mesclagem simples mostrará que as alterações de masterforam feitas aqnesse ponto, e não o contrário; mas tudo bem - já que foi isso que aconteceu! Posteriormente, quando você finalmente mesclar sua ramificação master, é quando uma mesclagem finalmente mostrará todas as alterações feitas master(o que é exatamente o que você deseja e é o commit no qual as pessoas esperam encontrar essas informações).

Eu verifiquei e a abordagem abaixo também mostra exatamente as mesmas alterações (todas as alterações feitas aqdesde a divisão original entre aqe master) que a abordagem normal acima, quando você finalmente mescla tudo de volta master. Portanto, acho que sua única desvantagem real (além de ser excessivamente complexa e não-padrão ...: - /) é que, se você rever n mudanças recentes com git reset --hard HEAD~<n>e isso ultrapassar a mesclagem, a versão abaixo será revertida no ramo 'errado', que você deve consertar manualmente (por exemplo, com git reflog& git reset --hard [sha]).

[Então, o que eu pensava anteriormente era que:]

Há um problema com:

git checkout aq
git merge master

porque as alterações mostradas no commit de mesclagem (por exemplo, se você procurar agora ou mais tarde no Github, Bitbucket ou seu visualizador de histórico de git local favorito) são as alterações feitas no master, que podem não ser exatamente o que você deseja.

Por outro lado

git checkout master
git merge aq

mostra as alterações feitas no aq, que provavelmente é o que você deseja. (Ou, pelo menos, geralmente é o que eu quero!) Mas a mesclagem que mostra as mudanças corretas está no ramo errado!

Como lidar?!

O processo completo, terminando com uma confirmação de mesclagem, mostrando as alterações feitas no aq (conforme a segunda mesclagem acima), mas com a mesclagem que afeta o ramo aq, é:

git checkout master
git merge aq
git checkout aq
git merge master
git checkout master
git reset --hard HEAD~1
git checkout aq

Isto: mescla aq no master, avança rapidamente a mesma mesclagem no aq, desfaz no master e o coloca novamente no aq!

Sinto que estou perdendo alguma coisa - isso parece ser algo que você obviamente deseja e algo difícil de fazer.

Além disso, rebase NÃO é equivalente. Perde os timestamps e a identidade dos commits feitos no aq, o que também não é o que eu quero.

Cenário:

• Eu criei uma filial do master, por exemplo, branch-1 e a puxei para o meu local.
• Meu amigo criou uma ramificação do master say branch-2.
• Ele comprometeu algumas alterações de código no mestre.
• Agora eu quero levar essas alterações da ramificação mestre para minha ramificação local.

Solução

git stash // to save all existing changes in local branch
git checkout master // Switch to master branch from branch-1
git pull // take changes from the master
git checkout branch-1 // switchback to your own branch
git rebase master // merge all the changes and move you git head  forward
git stash apply // reapply all you saved changes 

Você pode encontrar conflitos no seu arquivo após executar o "git stash apply". Você precisa corrigi-lo manualmente e agora está pronto para fazer o push.