Atualizar ramificações Git do mestre

Eu sou novo no Git e agora estou nessa situação:

• Eu tenho quatro ramos (mestre, b1, b2 e b3).
• Depois de trabalhar no b1-b3, percebi que havia algo para mudar no mestre de ramificação que deveria estar em todas as outras ramificações.
• Eu mudei o que eu precisava mastere ... aqui está o meu problema:

Como atualizo todas as outras ramificações com o mastercódigo da ramificação?

Você tem duas opções:

O primeiro é uma mesclagem, mas isso cria uma confirmação extra para a mesclagem.

Faça checkout em cada filial:

git checkout b1

Em seguida, mesclar:

git merge origin/master

Em seguida, pressione:

git push origin b1

Como alternativa, você pode fazer uma nova rebase:

git fetch
git rebase origin/master

Você tem basicamente duas opções:

1. Você se funde. Na verdade, isso é bastante simples e uma operação perfeitamente local:

   git checkout b1
   git merge master
   # repeat for b2 and b3
   

   Isso deixa o histórico exatamente como aconteceu: você partiu do mestre, fez alterações em todos os ramos e, finalmente, incorporou as mudanças do mestre nos três ramos.

   gitPara lidar com essa situação muito bem, ele foi projetado para mesclagens acontecendo em todas as direções, ao mesmo tempo. Você pode confiar que poderá reunir todos os threads corretamente. Simplesmente não se importa se o branch b1mescla masterou mastermescla b1, o commit de mesclagem parece igual ao git. A única diferença é que ramo acaba apontando para esse commit de mesclagem.

2. Você se rebase. Pessoas com um SVN ou experiência semelhante acham isso mais intuitivo. Os comandos são análogos ao caso de mesclagem:

   git checkout b1
   git rebase master
   # repeat for b2 and b3
   

   As pessoas gostam dessa abordagem porque ela mantém uma história linear em todos os ramos. No entanto, essa história linear é uma mentira, e você deve estar ciente de que é. Considere este gráfico de confirmação:

   A --- B --- C --- D <-- master
    \
     \-- E --- F --- G <-- b1
   

   A mesclagem resulta na história verdadeira:

   A --- B --- C --- D <-- master
    \                 \
     \-- E --- F --- G +-- H <-- b1
   

   A rebase, no entanto, fornece esse histórico:

   A --- B --- C --- D <-- master
                      \
                       \-- E' --- F' --- G' <-- b1
   

   O ponto é que os commits E', F'e G'nunca realmente existiram e provavelmente nunca foram testados. Eles podem até não ser compilados. Na verdade, é muito fácil criar confirmações sem sentido via rebase, especialmente quando as alterações mastersão importantes para o desenvolvimento b1.

   A conseqüência disso pode ser que você não consegue distinguir qual dos três commits E, Fe Grealmente introduziu uma regressão, diminuindo o valor degit bisect .

   Não estou dizendo que você não deveria usar git rebase. Tem seus usos. Mas sempre que você o usa, precisa estar ciente do fato de estar mentindo sobre a história. E você deve pelo menos compilar o teste que os novos commits.

git rebase masteré a maneira correta de fazer isso. A mesclagem significaria que uma consolidação seria criada para a mesclagem, enquanto a reestruturação não seria.

Se você estiver trabalhando em uma ramificação de vez em quando, ou muita coisa aconteceu em outras ramificações enquanto estiver trabalhando em alguma coisa, é melhor refazer sua ramificação para mestre. Isso mantém a história organizada e facilita muito o acompanhamento.

git checkout master
git pull
git checkout local_branch_name
git rebase master
git push --force # force required if you've already pushed

Notas:

• Não rebase as ramificações nas quais você colaborou com outras pessoas.
• Você deve refazer a ramificação na qual você estará mesclando, que nem sempre é mestre.

Há um capítulo sobre rebasing em http://git-scm.com/book/ch3-6.html e muitos outros recursos disponíveis na web.

A @cmaster fez a melhor resposta elaborada. Em resumo:

git checkout master #
git pull # update local master from remote master
git checkout <your_branch>
git merge master # solve merge conflicts if you have`

Você não deve reescrever o histórico da ramificação, mas mantê-los no estado real para referências futuras. Ao mesclar para o mestre, ele cria um commit extra, mas isso é barato. Confirma não custa.

Para atualizar outras ramificações como (backup) com sua cópia da ramificação principal. Você pode seguir de qualquer maneira (rebase ou mesclagem) ...

1. Faça o rebase (não haverá nenhuma confirmação extra feita na ramificação de backup).

2. Mesclar ramificações (haverá uma confirmação extra automaticamente na ramificação de backup).

   Nota: Rebase nada mais é do que estabelecer uma nova base (uma nova cópia)

git checkout backup
git merge master
git push

(Repita para outras ramificações, se houver, como backup2 & etc ..,)

git checkout backup
git rebase master
git push

(Repita para outras ramificações, se houver, como backup2 & etc ..,)

Você pode mesclar ou aplicar confirmações individuais nas ramificações usando git cherry-pick .

Existem duas opções para esse problema.

1) git rebase

2) fusão do git

Somente diff acima de ambos em caso de mesclagem, terá confirmação extra no histórico

1) ramo de verificação geral do git (b1, b2, b3)

2) origem / mestre do git rebase (no caso de conflitos serem resolvidos localmente, fazendo o git rebase --continue)

3) git push

Como alternativa, a opção git merge é semelhante

1) git checkout "your_branch" (b1, b2, b3)

2) mestre de mesclagem git

3) git push

para atualizar sua filial do mestre:

  git checkout master
  git pull
  git checkout your_branch
  git merge master