Mettre à jour les branches Git depuis le maître

Je suis nouveau sur Git, et maintenant je suis dans cette situation:

• J'ai quatre branches (master, b1, b2 et b3).
• Après avoir travaillé sur b1-b3, j'ai réalisé que j'avais quelque chose à changer sur le maître de branche qui devrait être dans toutes les autres branches.
• J'ai changé ce dont j'avais besoin masteret ... voici mon problème:

Comment mettre à jour toutes les autres branches avec le mastercode de branche?

Vous avez deux options:

Le premier est une fusion, mais cela crée un commit supplémentaire pour la fusion.

Commander chaque succursale:

git checkout b1

Fusionnez ensuite:

git merge origin/master

Appuyez ensuite sur:

git push origin b1

Alternativement, vous pouvez faire un rebase:

git fetch
git rebase origin/master

Vous avez essentiellement deux options:

1. Vous fusionnez. C'est en fait assez simple, et une opération parfaitement locale:

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

   Cela laisse l'historique exactement tel qu'il s'est produit: vous avez dérivé de master, vous avez apporté des modifications à toutes les branches, et enfin vous avez incorporé les modifications de master dans les trois branches.

   gitpeut très bien gérer cette situation, il est conçu pour les fusions qui se produisent dans toutes les directions, en même temps. Vous pouvez lui faire confiance pour pouvoir réunir correctement tous les threads. Il ne se soucie simplement pas de savoir si la branche b1fusionne masterou masterfusionne b1, la validation de la fusion ressemble tout de même à git. La seule différence est, quelle branche finit par pointer vers ce commit de fusion.

2. Vous rebasez. Les personnes possédant un SVN ou des antécédents similaires trouvent cela plus intuitif. Les commandes sont analogues au cas de fusion:

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

   Les gens aiment cette approche car elle conserve une histoire linéaire dans toutes les branches. Cependant, cette histoire linéaire est un mensonge, et vous devez être conscient qu'elle l'est. Considérez ce graphique de validation:

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

   La fusion entraîne la véritable histoire:

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

   Le rebase, cependant, vous donne cette histoire:

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

   Le fait est que les engagements E', F'et G'n'ont jamais vraiment existé, et n'ont probablement jamais été testés. Ils peuvent même ne pas compiler. Il est en fait assez facile de créer des commits absurdes via un rebase, surtout lorsque les changements dans mastersont importants pour le développement deb1 .

   La conséquence de cela peut être que vous ne pouvez pas distinguer lequel des trois commits E,F et en Gfait introduit une régression, ce qui diminue la valeur de git bisect.

   Je ne dis pas que vous ne devriez pas utiliser git rebase. Il a ses utilisations. Mais chaque fois que vous l'utilisez, vous devez être conscient du fait que vous mentez sur l'histoire. Et vous devez au moins compiler tester les nouveaux commits.

git rebase masterest la bonne façon de le faire. La fusion signifierait qu'un commit serait créé pour la fusion, contrairement au rebasage.

Si vous avez travaillé sur une branche de façon intermittente, ou que beaucoup de choses se sont produites dans d'autres branches pendant que vous travailliez sur quelque chose, il est préférable de rebaser votre branche sur master. Cela permet de garder l'historique bien rangé et rend les choses beaucoup plus faciles à suivre.

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

Remarques:

• Ne rebasez pas les branches sur lesquelles vous avez collaboré avec d'autres.
• Vous devez rebaser sur la branche vers laquelle vous allez fusionner qui n'est pas toujours maître.

Il y a un chapitre sur le rebasage sur http://git-scm.com/book/ch3-6.html , et de nombreuses autres ressources sur le Web.

@cmaster a fait la meilleure réponse élaborée. En bref:

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

Vous ne devez pas réécrire l'historique des branches au lieu de les conserver dans leur état réel pour de futures références. Lors de la fusion vers master, il crée un commit supplémentaire mais c'est bon marché. Les engagements ne coûtent pas.

Pour mettre à jour d'autres branches comme (sauvegarde) avec votre copie de branche principale. Vous pouvez suivre les deux méthodes (rebaser ou fusionner) ...

1. Faites une nouvelle base (il n'y aura pas de validation supplémentaire dans la branche de sauvegarde).

2. Fusionner les branches (il y aura automatiquement un commit supplémentaire dans la branche de sauvegarde).

   Remarque: Rebase n'est rien d'autre que l'établissement d'une nouvelle base (une nouvelle copie)

git checkout backup
git merge master
git push

(Répétez l'opération pour les autres branches, le cas échéant, comme backup2, etc.)

git checkout backup
git rebase master
git push

(Répétez l'opération pour les autres branches, le cas échéant, comme backup2, etc.)

Vous pouvez fusionner, ou vous pouvez appliquer des validations individuelles entre les branches en utilisant git cherry-pick .

Il existe deux options pour ce problème.

1) git rebase

2) Git Merge

Seul diff avec au-dessus des deux en cas de fusion, aura un commit supplémentaire dans l'historique

1) Git Checkout Branch (B1, B2, B3)

2) git rebase origin / master (En cas de conflits, résolvez localement en faisant git rebase --continue)

3) git push

Alternativement, l'option de fusion git est similaire

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

2) Git Merge Master

3) git push

pour mettre à jour votre branche depuis le maître:

  git checkout master
  git pull
  git checkout your_branch
  git merge master